What does it mean to issue a token “on top of” Ethereum?
Understanding how Ethereum-based tokens work and their relationship to Ether.
Even for those with an understanding of cryptocurrencies, Ethereum and other advanced open blockchain networks can be confusing, especially when people start talking about launching their new cryptocurrency or token on top of Ethereum. How can one valuable digital item “run” or “be launched” on top of another valuable digital item? This backgrounder will answer that question, but first we need to cover a fair amount of background material. Much of the confusion stems from the cryptocurrency community’s unfortunate habit of using the same name to describe multiple different things; so, to start, we’ll try to disambiguate a few terms.
Protocols, Networks, Tokens
Bitcoin is a peer-to-peer network. Bitcoin is a computer protocol for electronic cash. Bitcoin is a provably scarce token that will have a positive value if there is demand for it. All of these are true statements, which means that Bitcoin, the word, is used to describe three different things: (1) a group of networked computers on the Internet, (2) a set of rules and procedures for passing data between computers, and (3) valuable tokens that exist as a consequence of these networked computers running that Bitcoin protocol software. Those valuable tokens, bitcoins, in turn perform at least three functions: (1) people who dedicate computing resources to making the network work (i.e. miners) are rewarded with bitcoins, (2) users of the network can send bitcoins to other users as a payment medium, and (3) users can (and often must) pay fees in bitcoin in order to use the network.
Many people interested in open blockchain networks started with Bitcoin and never had this distinction entirely spelled-out for them. So, when it comes to a new network like Ethereum, things can become confusing. Ethereum is the name of a peer-to-peer computer network similar to but distinct from Bitcoin; it’s also the name of a protocol or set of rules and procedures for computers that borrows some technologies and ideas from the Bitcoin protocol but also has a fair amount of novel, additional functionality. Ether is the name for the scarce token that emerges as a result of networked computers running the Ethereum protocol and it is also, like bitcoin: (1) a reward for participation, (2) a currency, and (3) a medium for paying fees.
How Ethereum is Different
Unlike the Bitcoin protocol, the Ethereum protocol was explicitly designed to do more than just create and record transfers of the network’s native tokens. It is a more generalized protocol.
Recall that any blockchain technology does the following: it will allow connected computers to reach agreement over shared data. For Bitcoin, that shared data is a list of bitcoin transactions. This is why the Bitcoin blockchain is commonly referred to as a ledger. It’s like a book full of entries that either create new units of bitcoin or describe a transfer of existing units from one public address (the closest thing Bitcoin has to a user account) to another. We call it a ledger because that word is familiar to non-technical people, but really it is better described as a log or (even better) a logfile. In computer science, a logfile is just a record of events that occur as a piece of software (i.e. a computer program) runs. So the Bitcoin protocol generates this logfile, called the Bitcoin blockchain, and it reflects all the events that happen on the Bitcoin network.
The types of events that the Bitcoin protocol allows to be recorded into that logfile are limited and simple—they are the transactions that we discussed earlier, transactions made either as payments between users, fees for use, or as rewards for people that help to make the network and protocol infrastructure work.
Some transactions can be a bit more complex. For example, there are so-called “multi-sig” transactions where one person will send money to an address that’s been configured to require two-out-of-three people to agree in order to transact in the future (i.e. transactions sending money out of that address require multiple digital signatures, hence the name multi-sig). Here, the logfile is recording an event that is a bit more complicated. The usual event says: Alice sent to Bob. This multi-sig event said: Alice sent to Bob, Carol, and Doug and specified that two of those three people must agree in order to use the funds in the future. In general, however, the data recorded into the log usually looks the same, it’s bitcoin transaction after bitcoin transaction, again and again into the future.
In Ethereum, the logfile (i.e. the Ethereum blockchain) can be filled with a wider variety of event information. Just like Bitcoin, it can contain a log of transaction-like events where one person sent ether to another, but it can also contain a log of the execution and the results from running any sort of computer program. So, if I write a computer program like the old Windows game minesweeper, and then append the computer code that powers my game to the Ethereum blockchain, every event that happens in that game (clicking a square to reveal either a mine or a free space, number of lives remaining, high scores, etc.) will also be recorded in the blockchain. Whenever I or someone else on the Ethereum network plays the game, new game-related events are appended to the Ethereum blockchain (e.g. Player One clicked on square A:4 and blew up). Moreover, those game-related events are appended to the log simultaneously with any other events generated by any other computer programs currently running on the Ethereum network.
The Ethereum blockchain really is like a proper computer logfile; it records every event that occurs while the computer is running. The big difference is that it is actually logging events redundantly on every one of the computers connected to the Ethereum network. So when I uploaded the game, a copy of that game code was appended to every connected computer’s copy of the logfile, and whenever anyone plays the game, game events are recorded exactly the same on every computer on the network. That’s why the Ethereum network as a whole can be thought of as a singular giant computer—the Ethereum Virtual Machine—which everyone can use to run applications and to independently verify the integrity of any computation.
If it was free for anyone to run any type of application on the Ethereum Virtual Machine, the system would quickly become overloaded. Also, if people could freely write applications that endlessly looped, consuming more and more system resources each cycle, they’d be able to easily crash every computer connected to the network. To stop this from happening, the Ethereum protocol makes every computation (indeed every step within a computation) require a small fee that goes to the particular computer on the network that recorded the official version of the log for that period. This is similar to fees in Bitcoin, where any fees attached to a bitcoin transaction go to the miner who mined the block that included the transaction. How do you pay the fees? With ether, of course. When used in this manner, ether is referred to as “gas” for running the code; it’s the necessary fuel for computation.
Running or Launching a Token on Ethereum
If anyone can run any sort of code (for a fee) and allow anyone else to interact with the code and trust the result, then Ethereum can be a very useful tool for all sorts of group computational problems. One obvious use-case is making a token that has, like Bitcoin, a scarce supply. Here the application code would simply wait for people to send it some ether, and then it would add an event to the Ethereum blockchain specifying that the sender now controls an amount of this new token (which could mean that a digital signature from that sender’s ether wallet is needed in order to transfer the new token to someone else).
The scarcity of that token is guaranteed because a variable in the application corresponding to total available supply is explicitly declared (e.g. total tokens = 21 million) and then added, along with other aspects of the application code to the ethereum logfile. If the creator of the token later regrets her choice and wants to increase the supply, she can create a new application (with a new alternative supply amount) but she can’t alter the old version of the application because the logfile, like the bitcoin blockchain, is append-only, and entries in the past cannot be changed unless the decentralized community of Ethereum miners all agree to change the Ethereum protocol itself. Alternatively, a developer could create a token application that allows someone, or perhaps a group of people, to periodically adjust the total supply in an attempt to create a stable monetary policy. Either way, the code—whether it specifies a permanent total supply or describes a mechanism for supply changes—is set in stone when it is added to the blockchain.
These applications need to be coded carefully, no one wants to suddenly realize they only bought 1/1,000,000th of the total supply of something putatively rare instead of the advertised 1/100th. To encourage best practices, there is an open source standard for coding token-issuing ethereum applications.
You might ask, why would anyone want to do all of this when we already have bitcoin and ether; why create another new token?! The simple answer is that even in the real world we often use all sorts of items rather like we use cash. We use tickets, coupons, stock and bond certificates, vouchers, food stamps, deeds, and a variety of other bearer instruments because they entitle the holder to different things. Rather than do all that with various pieces of paper, or notations on a centralized database, why not make tokens that people can control with their smartphones and whose authenticity can be verified by on an open peer-to-peer network?
So, I might write an Ethereum application that allows anyone to create event tickets, sell them to audiences, and makes ticket-taking and anti-counterfeiting controls easier. People send ether to the application, specify which event they want to attend, and they get a ticket. They can keep it or—if they’d like—they could sell it to someone else on the network. When the final holder of the ticket arrives at the venue, they simply show the ticket to the organizer by showing them a QR code on their phone. Events recorded publicly to the ethereum blockchain verify the unbroken chain of title from the ticket seller to its current bearer.
Some people are creating tokens that relate to Internet infrastructure, like a token that can be spent to automatically pay for the cheapest and lowest latency cloud storage on a decentralized network of storage providers. Others may develop an open social network, like Twitter or Facebook but without a company in control, where tokens are used to make small payments for messaging capacity and to prevent spam and robot accounts from ruining the quality of conversations on the network.
The particular value of any token will depend on a variety of factors described in the application code that created it (e.g. the total supply of tokens), as well as the market demand for the token, which could be driven by a desire to use the tokens (e.g. desire to attend the token-ticketed event or buy the token-denominated cloud storage) or by speculation over future use-value.
The important thing to keep in mind is that just because it is the Ethereum virtual machine that runs the shared computations that describe the token’s distribution and movements, that doesn’t mean that the value of the token is the same as the value of ether. Ether will be used as gas to run any token-related applications (and in a certain sense if ether’s value was to plummet it might endanger the stability of the Ethereum Virtual Machine, and—therefore—the usefulness of any tokens running on top of Etheruem), but the token’s value is generally unlinked to the value of ether itself. Confusing the two is like confusing the gas you put in the car with groceries you put in the car and drive home.