In diesem Blogbeitrag werden wir einen eigenen Ethereum ERC20-Token erstellen, welcher grundsätzlich für einen ITO (Initial Token Offering) genutzt werden kann und auf der Ethereum Blockchain handelbar ist.
Des Weiteren werden wir einige Konzepte (Blockchain, Ethereum, ...), Begriffe (Security Token vs. Utility Token, Coin/Cryptocurrency...) und Standards (z.B. ERC20) behandeln.
Eine Blockchain ist ein revisionssicheres digitales Hauptbuch von Transaktionen, welches grundsätzlich nicht nur finanzielle Transaktionen, sondern praktisch jegliche Art von Transaktionen erfassen kann.
Eine Blockchain ist somit, im einfachsten Sinne, eine Serie von unveränderlichen Datensätzen inklusive Zeitstempeln, welche von einem dezentralen Netzwerk von Computern verwaltet werden, welche keiner einzelnen Organisation oder Person gehören (gegenübergestellt einem zentralen Server welcher unter voller Kontrolle einer einzelnen Organisation oder Person steht).
Diese Datensätze ("Block") sind durch kryptographische Prinzipien miteinander verbunden ("Chain").
Eine Blockchain ist somit eine grundsätzlich einfache, aber potenziell disruptive Art, Transaktionen zu verifizieren. Eine Partei einer solchen Transaktion initiiert dabei den Prozess, indem sie einen Block erstellt. Dieser Block wird von den im Netz verteilten Computern geprüft und bestätigt. Der verifizierte Block wird anschließend zur Kette hinzugefügt, welche im gesamten Netz gespeichert ist, wodurch nicht nur ein einzelner eindeutiger Datensatz, sondern ein eindeutiger Datensatz inklusive einer einzigartigen Historie erstellt wird - der Versuch einer Fälschung eines einzelnen Datensatzes würde somit bedeuten, die gesamte Kette in potenziell Millionen von Fällen zu falsifizieren.
Ein solches Blockchain-Netzwerk unterliegt somit keiner zentralen Autorität - da es sich um ein dezentrales und unveränderliches Hauptbuch handelt, sind die Informationen in eben diesem (also die jeweiligen Transaktionen) für jedermann sichtbar, so zum Beispiel die gesamte Transaktionshistorie eines physischen oder digitalen Gutes oder Rechtes.
Die Cryptocurreny Bitcoin verwendet dieses Modell für den Zahlungsverkehr, es kann aber auch auf viele andere Arten eingesetzt werden und eignet sich im Grunde genommen potenziell für all jene Anwendungsfälle, in welchen eine neutrale, zeitnahe und revisionssichere Bestätigung von Transaktionen - so zum Beispiel die Unterzeichnung eines Vertrages oder der Besitzwechsel von physischen oder digitalen Gütern oder Rechten - von Nöten ist.
Grundsätzlich sind Transaktionen auf solchen Blockchains kostenfrei - wofür in der Regel durchaus Kosten anfallen, ist Infrastruktur. Diese wird in der Regel dadurch gedeckt, dass zum Beispiel der Initiator einer Transaktion so genanntes "Gas" für jene Computer im Netzwerk in Aussicht stellt, welche die Transaktion bestätigen, als Motivation für die Betreiber jener Knoten, deren Rechenleistung dem Netzwerk zur Verfügung zu stellen. Auf der Ethereum Blockchain wird dieses Gas in der Cryptocurrency ETH (Ether) gezahlt, die Kosten in "gängiger" Währung (also zum Beispiel Euro) sind also vom jeweiligen Wechselkurs von ETH abhängig. Zum Zeitpunkt des Verfassens dieses Artikels kostet eine solche Transaktionsbestätigung innerhalb von ca. 2 Minuten auf der Ethereum Blockchain umgerechnet etwa € 0,012, eine Bestätigung unter ca. 5 Minuten etwa € 0,0045. Je mehr Computer im Netzwerk die Transaktion bestätigen, als desto sicherer (im Sinne dessen dass sie stattgefunden hat) kann diese angesehen werden.
Gegenübergestellt analoger Praktiken - so zum Beispiel ein Notar welcher eine Transaktion bestätigt - ergibt sich dadurch Potenzial einerseits Kosten und Zeitaufwand solche sensiblen Transaktionen betreffend stark zu senken, während andererseits Aspekte der Revisionssicherheit und Transparenz erhöht werden.
Am einfachsten lässt sich Ethereum wohl als offene Softwareplattform beschreiben, welche auf Blockchain-Technologie basiert und es Entwicklern ermöglicht, dezentrale Anwendungen zu erstellen und einzusetzen.
Wie Bitcoin ist Ethereum ein verteiltes öffentliches Blockchain-Netzwerk. Obwohl es einige signifikante technische Unterschiede zwischen beiden gibt, ist der wohl wichtigste Unterschied jener, dass sich Bitcoin und Ethereum in Bezug auf Zweck und Fähigkeit erheblich unterscheiden. Bitcoin bietet eine spezialisierte Anwendung der Blockchain-Technologie, nämlich ein Peer-to-Peer e-Zahlungssystem, welches Online-Bitcoin-Zahlungen ermöglicht.
Während also die Bitcoin-Blockchain verwendet wird, um den Besitz der digitalen Währung (Bitcoins) zu verfolgen, konzentriert sich die Ethereum-Blockchain auf die Ausführung von Programmcodes jeglicher dezentralen Anwendung.
In der Ethereum-Blockchain werden gegen Rechenleistung ("minen") sogenannte Ether (ETH) verdient, ein Crypto-Token, der das Netzwerk antreibt. Neben seiner Rolle als handelbare Kryptowährung wird Ether auch von Anwendungsentwicklern verwendet, um Transaktionsgebühren und Dienstleistungen im Ethereum-Netzwerk zu bezahlen.
Wie eingangs beschrieben, ermöglicht unter Anderem die Ethereum-Blockchain die Nutzung von Token, welche von Anwendern gekauft, verkauft und gehandelt werden können. Diese sind nicht zu verwechseln mit Ether, welches wiederum wie weiter oben beschrieben "lediglich" die natürliche Währung der Ethereum Blockchain-Infrastruktur darstellt.
Token wiederum sind digitale Assets oder Programme, welche auf der Blockchain basieren. Diese Token dienen dem Zweck, ihnen einen Wert zuzuschreiben, so zum Beispiel Schuldscheine, Genussrechte, Leistungen oder reale Objekte. Somit sind Token im Allgemeinen nicht mit Kryptowährungen (zum Beispiel Bitcoin oder Ether) zu verwechseln. Token sind im Grunde genommen sogenannte "Smart Contracts", die im Fall von ERC20, auf der Ethereum-Blockchain ausgeführt werden.
Den ERC20 Standard einführend gab Ethereum 2015 erstmals technische Spezifikationen für einen Token auf seiner Blockchain aus, wobei "ERC" für "Ethereum Request for Comments" steht. ERC20 ist also ein Standardprotokoll, welches die Eigenschaften und die Funktionsweise eines Ethereum-Blockchain-Tokens definiert.
Ein Token im Allgemeinen ist im Grunde genommen einfach eine digitale Repräsentation von potenziell allem. Ein Token kann beispielsweise eine Aktie, eine Anleihe, eine Option oder eine Immobilie etc. repräsentieren. Ein Token kann aber auch Zugriffsrechte auf eine Blockchain oder Blockchain-App repräsentieren, und Token können auch zur Automatisierung an "Reibstellen" in verschiedenen Branchen eingesetzt werden.
Utility-Token, sind Token, welche einen spezifischen "Nutzen" auf der Blockchain oder einer auf jener basierenden App haben. Utility-Token werden auch als "App Coins" bezeichnet, da diese eben explizit für eine bestimmte App oder Blockchain konzipiert sind.
Aus diesem Grund sind Utility-Token ausschließlich für einen solchen jeweils spezifischen Gebrauch bestimmt und kein Anlageinstrument.
Security-Token wiederum repräsentieren Investments, wie zum Beispiel Wertpapiere wie Aktien, Anleihen, Fonds etc., digital. So werden Wertpapiere von Unternehmen, Fondshäusern oder Immobilienfonds, welche über die Blockchain ausgegeben werden, als Security-Token bezeichnet. Ebenso wie es bei traditionellen "Securities" der Fall ist, repräsentieren Security-Token somit Profitbeteiligung, Zinseinnahmen oder geben Stimmrechte oder generieren Gewinne für die Inhaber jener Token.
Während Security-Token somit diversen Vorschriften und rechtlichen Rahmenbedingungen zu unterliegen haben an welche sich der Emittent halten muss, gilt dies nicht für 100%ige Utility-Token.
2.1.1 MetaMask
MetaMask (https://metamask.io/) ist eine Browserextension (Chrome, Firefox, Opera) welche es ermöglicht, Ethereum dApps direkt im Browser und ohne einen vollständigen Ethereum-Node auszuführen.
MetaMask ermöglicht es somit, Identitäten auf verschiedenen Websites zu verwalten und Blockchain-Transaktionen zu signieren.
2.3.2 Remix - Ethereum IDE
Remix (http://remix.ethereum.org) ist ein Online-Compiler, welcher es uns ermöglicht, unseren folgenden Smart Contract direkt auf der Ethereum-Blockchain zu veröffentlichen.
2.3.3 ERC20-Token Smart Contract
Folgend ein beispielhafter (Nutzung auf eigene Gefahr!) Smart-Contract, welcher wie weiter unten beschrieben im nächsten Schritt angepasst werden kann um einen eigenen ERC20-Token zu erstellen. (Quelle: Token Factory und @maxnachamkin)
pragma solidity ^0.4.4;
contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
//if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract ERC20Token is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
string public name; //Name of the token
uint8 public decimals; //How many decimals to show. ie. There could 1000 base units with 3 decimals
string public symbol; //An identifier: eg AXM
string public version = 'H1.0'; //human 0.1 standard. Just an arbitrary versioning scheme.
//
// CHANGE THE FOLLOWING VALUES FOR YOUR TOKEN!
//
//make sure this function name matches the contract name above. So if you're token is called TutorialToken, make sure the //contract name above is also TutorialToken instead of ERC20Token
function ERC20Token(
) {
balances[msg.sender] = NUMBER_OF_TOKENS; // Give the creator all initial tokens (100000 for example)
totalSupply = NUMBER_OF_TOKENS; // Update total supply (100000 for example)
name = "NAME_OF_TOKEN"; // Set the name for display purposes
decimals = DECIMALS; // Amount of decimals
symbol = "SYM"; // Set the symbol for display purposes
}
/* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
//it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
}
Folgende Parameter sollten angepasst werden:
NUMBER_OF_TOKENS Die Gesamtanzahl an ausgegebenen Token, zum Beispiel 100 (und in diesem Fall auch die Anzahl an Tokens, welche der Ersteller initial in seiner Wallet hältDECIMALS Die Anzahl der Dezimalstellen und somit Definition der maximalen Teilbarkeit des Token, zum Beispiel 18NAME_OF_TOKEN Der Anzeigename des Tokens, zum Beispiel "Axom Token"SYM Kürzel des Tokens, zum Beispiel "AXM"Der oben angeführten Smart-Contract-Code kann, nach den oben beschriebenen individuellen Anpassungen, kopiert und in das Hauptfenster von Remix (http://remix.ethereum.org) eingefügt werden.
Im Tab "Run" kann der Smart-Contract nun auf die Ethereum-Blockchain deployed werden. Die im Smart-Contract-Code definierte Gesamtanzahl von Tokens (zB 100) sollen mit der MetaMask Wallet assoziert und in dieser gehalten werden (von welcher aus diese im nächsten Schritt gehandelt werden könnten).
Auf folgende Werte sollte in den entsprechenden Feldern vor Deployment geachtet werden:
Environment "Injected Web3"Account Sollte mit der MetaMask Wallet-Adresse übereinstimmenDer Screen sollte somit wie folgt aussehen:
Mit Klick auf "Deploy" und anschließender Bestätigung kann der Smart-Contract deployed werden; sobald die Transaktion durch das Ethereum-Blockchain-Netzwerk bestätigt wurde (Anmerkung: dies kann einige Minuten dauern), sollte die definierte Anzahl (also z.B. 100) an ausgegebenen Token hernach in der MetaMask Wallet aufscheinen.
Unsere emittierten Token sollten sich nun in unserer MetaMask Wallet wiederfinden, was ungefähr wie folgt aussehen sollte (Anm.: im u.a. Screenshot sind nur noch 99 Token vorhanden, da zum Zeitpunkt der Erstellung dieses Artikels ein Token bereits getraded worden war):
Durch Klick auf "Send" kann nun eine definierbare Anzahl des ERC20-Token an eine beliebige ETH-Wallet gesendet werden; der Screen hierfür sollte dann wie folgt aussehen:
Anmerkung: Wie eingangs beschrieben sind alle Transaktionen welche auf einer Blockchain, also in diesem Beispiel der Ethereum-Blockchain, transparent einsehbar. Für die Ethereum-Blockchain existiert http://etherscan.io/, ein Ethereum-Blockchain-Explorer.
Darüber lassen sich die im Rahmen dieses Tutorials durch den Autor getätigten Transaktionen einsehen: 1. Deployment des Smart-Contracts sowie 2. Trade eines AXM Token.
Tags
Inhalt
Kommentare
Noch keine Kommentare