So erstellen Sie auf einfache Weise einen ERC20-Token

Das Ziel dieses Artikels ist es, zu zeigen, wie man in möglichst kurzer Zeit einen ERC20-Token erstellt.

Beginnen wir mit den Grundlagen: Was ist ein ERC20-Token?

In den letzten Jahren hat sich die ERC20-Token-Spezifikation zum De-facto-Standard für Ethereum-Token entwickelt. Mit anderen Worten, die meisten Ethereum-Kontrakte, die es heute gibt, sind ERC20-konform. In diesem Artikel wird detailliert beschrieben, wie Sie Ihren eigenen Ethereum-Token erstellen können, aber bevor wir beginnen, werfen wir einen genaueren Blick auf den ERC20-Standard.

Was macht ERC20-Token so attraktiv und erfolgreich? Es spielen mehrere Faktoren eine Rolle:

1. ERC20-Token sind einfach und leicht bereitzustellen, wie Sie in diesem Tutorial sehen werden.
2. Der ERC20-Standard löst ein erhebliches Problem, da Blockchain-basierte Marktplätze und Krypto-Wallets einen einzigen, standardisierten Satz von Befehlen benötigen, um mit den von ihnen verwalteten Token zu kommunizieren. Dazu gehören Interaktionsregeln zwischen verschiedenen Token sowie Token-Kaufregeln.
3. Es war die erste populäre Spezifikation, die Ethereum-Token-Standardisierung anbot. Es war keineswegs das erste , aber dank seiner Popularität wurde es schnell zum Industriestandard.

Genau wie andere Ethereum-Token werden ERC20-Token als Smart Contracts implementiert und dezentral auf der Ethereum Virtual Machine (EVM) ausgeführt.

Solidity: die Smart Contract Programmiersprache

Ethereum Smart Contracts sind in Solidity geschrieben. Es gibt zwar alternative Sprachen, aber kaum jemand verwendet sie für diesen Zweck. Solidity ähnelt JavaScript. Wenn Sie also etwas über JavaScript oder sogar Java und andere C-ähnliche Sprachen wissen, sollten Sie keine Probleme haben, herauszufinden, dass ein Code in Solidity dies tut, noch bevor Sie Solidity tatsächlich genug beherrschen, um es zu verwenden es.

Hier beginnt der Spaß, denn Sie sollten in kürzester Zeit mit der Erstellung eines einfachen ERC20-Vertrags beginnen können. Dies ist eine unkomplizierte Aufgabe, die so einfach ist, dass dieser Artikel zeigt, wie Sie ein ERC20-Token in weniger als einer Stunde schreiben und bereitstellen können.

Das Token, das wir in dieser Demonstration erstellen werden, wird eine einfache ERC20-Implementierung sein, ohne zu viel Schnickschnack. Ich habe jedoch viele ähnlich einfache Token in der realen Welt gesehen, und sie tendieren dazu, recht gut abzuschneiden.

Überblick über den ERC20-Token-Standard

Was ist ERC20?

Einfach ausgedrückt definiert der ERC20-Standard eine Reihe von Funktionen, die von allen ERC20-Token implementiert werden müssen, um die Integration mit anderen Verträgen, Wallets oder Marktplätzen zu ermöglichen. Dieser Satz von Funktionen ist ziemlich kurz und einfach.

 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);

ERC20-Funktionen ermöglichen es einem externen Benutzer, beispielsweise einer Krypto-Wallet-App, das Guthaben eines Benutzers herauszufinden und Gelder mit der entsprechenden Autorisierung von einem Benutzer zu einem anderen zu überweisen.

Der Smart Contract definiert zwei spezifisch definierte Ereignisse:

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

Diese Ereignisse werden aufgerufen oder ausgegeben, wenn einem Benutzer Rechte zum Abheben von Token von einem Konto gewährt werden und nachdem die Token tatsächlich übertragen wurden.

Neben den Standard-ERC20-Funktionen verfügen viele ERC20-Token auch über zusätzliche Felder und einige sind de facto Teil des ERC20-Standards geworden, wenn nicht schriftlich, dann in der Praxis. Hier sind einige Beispiele für solche Felder.

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

Hier sind einige Punkte zur Nomenklatur von ERC20 und Solidity:

• Auf eine public Funktion kann außerhalb des Vertrags selbst zugegriffen werden
• view bedeutet grundsätzlich konstant, dh der interne Zustand des Vertrages wird durch die Funktion nicht verändert
• Ein event ist die Art und Weise von Solidity, dass Kunden, z. B. Ihr Anwendungs-Frontend, über bestimmte Vorkommnisse innerhalb des Vertrags benachrichtigt werden können

Die meisten Solidity-Sprachkonstrukte sollten klar sein, wenn Sie bereits über grundlegende Java/JavaScript-Kenntnisse verfügen.

Schreiben eines ERC20-Tokens in Solidity

Nachdem wir nun die Grundlagen skizziert und erklärt haben, was zum Erstellen eines ERC20-Tokens erforderlich ist, ist es an der Zeit, mit dem Schreiben von Logik zu beginnen.

Zuerst müssen wir zwei Mapping-Objekte definieren. Dies ist der Solidity-Begriff für ein assoziatives oder Schlüssel/Wert-Array:

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

Der Ausdruck mapping(address => uint256) definiert ein assoziatives Array, dessen Schlüssel vom Typ address sind – eine Zahl, die zur Bezeichnung von Kontoadressen verwendet wird, und dessen Werte vom Typ uint256 sind – eine 256-Bit-Ganzzahl, die normalerweise zum Speichern von Token-Salden verwendet wird.

Das erste Zuordnungsobjekt, balances , enthält den Token-Saldo jedes Eigentümerkontos.

Das zweite Zuordnungsobjekt, „ allowed “, enthält alle Konten, die zur Auszahlung von einem bestimmten Konto zugelassen sind, zusammen mit der jeweils zulässigen Auszahlungssumme.

Wie Sie sehen können, ist das Wertfeld der zulässigen Zuordnung selbst eine Zuordnung der Kontoadresse zu ihrer genehmigten Auszahlungssumme.

Diese Zuordnungen werden zusammen mit allen anderen Vertragsfeldern in der Blockchain gespeichert und abgebaut , was dazu führt, dass Änderungen an alle Netzwerkbenutzerknoten weitergegeben werden.

Blockchain-Speicher ist teuer und die Benutzer Ihres Vertrags müssen auf die eine oder andere Weise dafür bezahlen. Daher sollten Sie immer versuchen, die Speichergröße und Schreibvorgänge in die Blockchain zu minimieren.

Nachdem wir nun die erforderlichen Datenstrukturen eingerichtet haben, können wir damit beginnen, die ERC20-Logik tatsächlich in die entsprechenden Funktionen zu schreiben.

Festlegen der Anzahl der ICO-Token

Wie legen wir die Anzahl der ICO-Token fest? Nun, es gibt eine Reihe von Möglichkeiten, die maximale Anzahl von ICO-Token festzulegen, und diese Angelegenheit allein könnte eine lange Diskussion wert sein.

Für die Anforderungen unseres ECR20-Tutorials verwenden wir den einfachsten Ansatz: Legen Sie die Gesamtmenge der Token zum Zeitpunkt der Vertragserstellung fest und weisen Sie zunächst alle dem „Vertragseigentümer“ zu, dh dem Konto, das den Smart Contract bereitgestellt hat:

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

Ein Konstruktor ist eine spezielle Funktion, die von Ethereum automatisch direkt nach der Bereitstellung des Vertrags aufgerufen wird. Es wird normalerweise verwendet, um den Zustand des Tokens mithilfe von Parametern zu initialisieren, die vom Bereitstellungskonto des Vertrags übergeben werden.

msg ist eine globale Variable, die von Ethereum selbst deklariert und gefüllt wird. Sie enthält wichtige Daten zur Vertragsabwicklung. Das Feld, das wir hier verwenden: msg.sender enthält das Ethereum-Konto, das die aktuelle Vertragsfunktion ausführt.

Nur das bereitstellende Konto kann den Ersteller eines Vertrags eingeben. Beim Vertragsstart weist diese Funktion verfügbare Token dem Konto „Vertragseigentümer“ zu.

Holen Sie sich den gesamten Token-Vorrat

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

Diese Funktion gibt die Anzahl aller von diesem Vertrag zugewiesenen Token unabhängig vom Eigentümer zurück.

Holen Sie sich das Token-Guthaben des Eigentümers

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

balanceOf gibt den aktuellen Token-Saldo eines Kontos zurück, das durch die Adresse seines Besitzers identifiziert wird.

Token auf ein anderes Konto übertragen

 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; }

Wie der Name schon sagt, wird die transfer verwendet, um die Anzahl von numTokens an Token vom Guthaben des Besitzers auf das eines anderen Benutzers oder receiver zu verschieben. Der übertragende Eigentümer ist msg.sender , dh derjenige, der die Funktion ausführt, was impliziert, dass nur der Eigentümer der Token sie an andere übertragen kann.

Die Art und Weise von Solidity, ein Prädikat zu behaupten, ist require . In diesem Fall muss das übertragende Konto über ein ausreichendes Guthaben verfügen, um die Überweisung auszuführen. Wenn require fehlschlägt, wird die Transaktion sofort zurückgesetzt, ohne dass Änderungen in die Blockchain geschrieben werden.

Unmittelbar vor dem Beenden löst die Funktion das ERC20-Ereignis Transfer aus, sodass registrierte Listener auf den Abschluss reagieren können.

Genehmigen Sie den Delegierten zum Abheben von Token

Diese Funktion wird am häufigsten in einem Token-Marktplatz-Szenario verwendet.

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

approve ermöglicht einem Eigentümer, dh msg.sender , einem Delegiertenkonto – möglicherweise dem Marktplatz selbst – zu genehmigen, Token von seinem Konto abzuheben und sie auf andere Konten zu übertragen.

Wie Sie sehen können, wird diese Funktion für Szenarien verwendet, in denen Eigentümer Token auf einem Marktplatz anbieten. Es ermöglicht dem Marktplatz, die Transaktion abzuschließen, ohne auf eine vorherige Genehmigung zu warten.

Am Ende ihrer Ausführung löst diese Funktion ein Approval aus.

Erhalten Sie die Anzahl der zur Auszahlung genehmigten Token

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

Diese Funktion gibt die aktuelle genehmigte Anzahl von Token von einem Eigentümer an einen bestimmten Delegaten zurück, wie in der approve festgelegt.

Übertragen von Token durch Delegierten

Die transferFrom Funktion ist der Peer der zuvor besprochenen approve Funktion. Es ermöglicht einem zur Auszahlung zugelassenen Delegierten, Eigentümergelder auf ein Drittkonto zu überweisen.

 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; }

Die beiden require Anweisungen beim Funktionsstart sollen überprüfen, ob die Transaktion legitim ist, dh dass der Eigentümer über genügend Token zum Übertragen verfügt und dass der Delegierte die Genehmigung hat, dass (mindestens) numTokens zurückgezogen werden.

Zusätzlich zur Übertragung des numTokens Betrags vom Eigentümer an den Käufer zieht diese Funktion auch numTokens von der Zulage des Delegierten ab. Dies ermöglicht es einem Delegierten mit einer bestimmten Genehmigung im Grunde, diese in mehrere separate Auszahlungen aufzuteilen, was ein typisches Marktverhalten ist.

Wir könnten hier aufhören und eine gültige ERC20-Implementierung haben. Wir wollen jedoch noch einen Schritt weiter gehen, denn wir wollen einen Industriestärke-Token. Dies erfordert, dass wir unseren Code etwas sicherer machen, obwohl wir immer noch in der Lage sein werden, das Token relativ einfach, wenn nicht sogar grundlegend zu halten.

SafeMath Solidity-Bibliothek

SafeMath ist eine Solidity-Bibliothek, die darauf abzielt, mit Hackern umzugehen, die bekanntermaßen Verträge brechen: Integer-Overflow-Angriff. Bei einem solchen Angriff zwingt der Hacker den Vertrag, falsche numerische Werte zu verwenden, indem er Parameter übergibt, die die relevanten Ganzzahlen über ihre Maximalwerte hinaus bringen.

SafeMath schützt davor, indem es auf Überlauf prüft, bevor die arithmetische Aktion ausgeführt wird, wodurch die Gefahr eines Überlaufangriffs beseitigt wird. Die Bibliothek ist so klein, dass die Auswirkung auf die Vertragsgröße minimal ist, keine Leistung und nur geringe Einbußen bei den Speicherkosten entstehen.

Lassen Sie uns SafeMath zu unserem Code hinzufügen:

 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; } }

SafeMath verwendet assert -Anweisungen, um die Richtigkeit der übergebenen Parameter zu überprüfen. Sollte assert fehlschlagen, wird die Funktionsausführung sofort gestoppt und alle Blockchain-Änderungen werden rückgängig gemacht.

Als nächstes fügen wir die folgende Anweisung hinzu, die die Bibliothek dem Solidity-Compiler vorstellt:

using SafeMath for uint256;

Dann ersetzen wir die naive Arithmetik, die wir zu Beginn verwendet haben, durch SafeMath-Funktionen:

 balances[msg.sender] = balances[msg.sender].sub(numTokens); balances[receiver] = balances[receiver].add(numTokens); balances[buyer] = balances[buyer].add(numTokens); balances[owner] = balances[owner].sub(numTokens);

Alles zusammen packen

In Solidity werden die Funktionen und Ereignisse eines Smart Contracts in eine Entität namens Contract verpackt, die Sie stillschweigend in eine „Blockchain-Klasse“ übersetzen können. Nachfolgend finden Sie den ERC20-kompatiblen Vertrag, den wir erstellt haben, einschließlich einer Zusammenfassung unseres Codes. Die Namens- und Symbolfelder können beliebig geändert werden. Die meisten Token behalten den Dezimalwert bei 18, also werden wir dasselbe tun.

Ethereum-Vertragsbereitstellung

Es ist an der Zeit, unseren Vertrag für die Blockchain bereitzustellen. Nach der Bereitstellung wird unser Vertrag auf alle am Netzwerk teilnehmenden Knoten übertragen. Alle am Vertrag vorgenommenen Änderungen werden an alle teilnehmenden Knoten weitergegeben.

Ethereum-Entwickler verwenden normalerweise Bereitstellungstools wie Truffle. Sogar Truffle ist für die begrenzten Anforderungen dieses Artikels übertrieben, und ein einfaches Online-Tool namens Remix wird ausreichen.

Um es zu verwenden, müssen Sie das MetaMask-Plugin in Ihrem Browser und ein Rinkeby-Konto (Ethereum-Testnetzwerk) mit mindestens etwas Rinkeby-Ether installieren. Dies sind relativ einfache Schritte, daher gehen wir nicht ins Detail.

Falls Sie beides nicht haben, gehen Sie zu MetaMask und Rinkeby, um Download-Links zu erhalten und klare Installations- und Verwendungsanweisungen zu erhalten.

Nachdem wir nun alle Bausteine ​​eingerichtet haben, gehen wir zu Remix und fügen den obigen Code, einschließlich der Pragma-Zeile und der SafeMath-Bibliothek, in den Online-Editor ein.

Dann springen wir zur zweiten Registerkarte rechts mit dem Namen „ Run “ und klicken auf „ Deploy “. Ein MetaMask-Popup erscheint und fordert uns auf, die Transaktion zu bestätigen. Natürlich werden wir dem zustimmen.

• Grünes Kästchen: Stellen Sie sicher, dass Sie auf Rinkeby sind
• Blaues Kästchen: Stellen Sie Ihren gesamten Token-Vorrat ein
• Rotes Kästchen: Einsatz!

Inhalt : https://gist.github.com/giladHaimov/8e81dbde10c9aeff69a1d683ed6870be#file-basicerc20-sol

Herzlichen Glückwunsch! Sie haben gerade Ihren ersten ERC20-Token bereitgestellt, wie ein echter Ethereum-Profi. Wie versprochen, ist der Token einfach und leicht, aber dennoch voll funktionsfähig, ERC20-Standard-konform und mit MathSafe gesichert. Es kann gekauft, bezahlt und über die Blockchain übertragen werden.

Ist das alles, was Smart Contracts ausmacht?

Nein, nicht einmal annähernd, da unsere kurze Demonstration kaum an der Oberfläche kratzt und sich ausschließlich mit einem Aspekt der intelligenten Vertragsentwicklung befasst.

Intelligente Verträge können viel komplexer sein, abhängig von Ihrer Geschäftslogik, Ihrer Modellierung der Benutzerinteraktion, ob Sie das Prägen und Brennen von Token zulassen oder nicht, Lebenszyklusänderungen, die Sie in den Vertrag einführen, die Notwendigkeit von Funktionen auf Administratorebene, die normalerweise mit einem einhergehen admin-autorisierten Satz von Funktionen und so weiter. Du bekommst das Bild.

Wenn Sie jedoch wiederholen können, was wir hier getan haben, ist dies eine solide Grundlage, um Ihr Wissen zu erweitern und bei Bedarf zu komplexeren Verträgen überzugehen.