D(genesis_block) = 2^36 D(block) = if anc(block,1).timestamp >= anc(block,501).timestamp + 60 * 500: D(block.parent) - floor(D(block.parent) / 1000) else: D(block.parent) + floor(D(block.parent) / 1000)
if tx.output != MARKER: break else if balance[tx.output] < decode_value(tx.output): break else if not tx.hasSignature(tx.output): break else: balance[tx.output] -= decode_value(tx.output); balance[tx.output] += decode_value(tx.output);
if tx.value < 100 * block.basefee: stop elif contract.storage: from = tx.sender to = tx.data value = tx.data if to <= 1000: stop if contract.storage[from] < value: stop contract.storage[from] = contract.storage[from] - value contract.storage[to] = contract.storage[to] + value else: contract.storage[MYCREATOR] = 10^18 contract.storage = 1
if tx.sender != FEEDOWNER: stop contract.storage[data] = data
if tx.value < 200 * block.basefee: stop if contract.storage == 0: if tx.value < 1000 * 10^18: stop contract.storage = 1 contract.storage = 998 * block.contract_storage(D)[I] contract.storage = block.timestamp + 30 * 86400 contract.storage = tx.sender else: ethervalue = contract.storage / block.contract_storage(D)[I] if ethervalue >= 5000: mktx(contract.storage,5000 * 10^18,0,0) else if block.timestamp > contract.storage: mktx(contract.storage,ethervalue * 10^18,0,0) mktx(A,(5000 - ethervalue) * 10^18,0,0)
if tx.value < block.basefee * 200: stop if contract.storage[tx.data] or tx.data < 100: stop contract.storage[tx.data] = tx.data
Decentralized Autonomous Organizations
if tx.value < tx.basefee * 200: stop if contract.storage[tx.sender] == 0: stop k = sha3(32,tx.data) if tx.data == 0: if contract.storage[k + tx.sender] == 0: contract.storage[k + tx.sender] = 1 contract.storage[k] += 1 else if tx.data == 1: if tx.value <= tx.datan * block.basefee * 200 or contract.storage[k]: stop i = 2 while i < tx.datan: contract.storage[k + i] = tx.data[i] i = i + 1 contract.storage[k] = 1 contract.storage[k+1] = tx.datan else if tx.data == 2: if contract.storage[k] >= contract.storage[2 ^ 255] * 2 / 3: if tx.value <= tx.datan * block.basefee * 200: stop i = 3 L = contract.storage[k+1] loc = contract.storage[k+2] while i < L: contract.storage[loc+i-3] = tx.data[i] i = i + 1 if contract.storage[2 ^ 255 + 1] == 0: contract.storage[2 ^ 255 + 1] = 1 contract.storage[C] = 1
Ethereum is a platform and a programming language that makes it possible for any developer to build and publish next-generation decentralized applications.
Ethereum can be used to codify, decentralize, secure and trade just about anything: voting, domain names, financial exchanges, crowdfunding, company governance, contracts and agreements of most kind, intellectual property, and even smart property thanks to hardware integration.
Ethereum borrows the concept of decentralized consensus that makes bitcoin so resilient, yet makes it trivial to build on its foundation. To find out more about how Ethereum works, consult the whitepaper.
What will you build out of the Ether?
When the grand experiment that is bitcoin began, the anonymous wizard desired to test two parameters- a trustless, decentralized database enjoying security enforced by the austere relentlessness of cryptography and a robust transaction system capable of sending value across the world without intermediaries. Yet the past five years years have painfully demonstrated a third missing feature: a sufficiently powerful Turing-complete scripting language.
Up until this point, most innovation in advanced applications such as domain and identity registration, user-issued currencies, smart property, smart contracts, and decentralized exchange has been highly fragmented, and implementing any of these technologies has required creating an entire meta-protocol layer or even a specialized blockchain. Theoretically, however, each and every one of these innovations and more can potentially be made hundreds of times easier to implement, and easier to scale, if only there was a stronger foundational layer with a powerful scripting language for all of these protocols to build upon. And this need is what we seek to satisfy.
The Ethereum protocol should be as simple as possible, even at the cost of some data storage inefficiency or time inefficiency. An average programmer should ideally be able to follow and implement the entire specification, so as to eventually help minimize the influence that any specific individual or elite group can have on the protocol and furthering the vision of Ethereum as a protocol that is open to all. Optimizations which add complexity should not be included unless they provide very substantial benefit.
It is a fundamental part of Ethereum's design philosophy that Ethereum does not have "features". Instead, Ethereum provides an internal Turing-complete scripting language which you can use to construct any smart contract or transaction type that can be mathematically defined. Want to invent your own financial derivative? With Ethereum, you can. Want to make your own currency? Set it up as an Ethereum contract. Want to set up a full-scale Daemon or Skynet? You may need to have a few thousand interlocking contracts, and be sure to feed them generously, to do that, but nothing is stopping you.
Different parts of the Ethereum protocol should be designed to be as modular and separable as possible. Over the course of development, it should be easy to make a small protocol modification in one place and have the application stack continue to function without any further modification. Innovations such as Dagger, Patricia trees and RLP should be implemented as separate libraries and made to be feature-complete even if Ethereum does not require certain features so as to make them usable in other protocols as well. Ethereum development should be maximally done so as to benefit the entire cryptocurrency ecosystem, not just itself.
The protocol should not attempt to actively restrict or prevent specific categories of usage, and all regulatory mechanisms in the protocol should be designed to directly regulate the harm, not attempt to oppose specific undesirable applications. You can even run an infinite loop script on top of Ethereum for as long as you are willing to keep paying the per-computational-step transaction fee for it.
Details of the Ethereum protocol are not set in stone. Although we will be extremely judicious about making modifications to high-level constructs such as the C-like language and the address system, computational tests later on in the development process may lead us to discover that certain modifications to the algorithm or scripting language will substantially improve scalability or security. If any such opportunities are found, we will make use of them.
Create a Currency
What can you make out of ether?
Contracts are the main building block of Ethereum. A contract is like a computer program that lives inside the Ethereum network and has its own ether balance, memory and code. Every time you send a transaction to a contract, the contract executes its code, which can store data, send transactions and even interact with other contracts. You can use contracts to issue currencies, construct your own escrow contracts or financial derivatives, and even create on-blockchain data stores. Thanks to Turing-completeness, Ethereum contracts let you create self-enforcing smart contracts with any conditions that can be mathematically defined. You can find out more in the whitepaper.
- Joseph Lubin
- Gavin Wood
- Jeffrey Wilcke
- Jeremy Wood
- Mathias Grønnebæk
- Ryan Taylor
- Dr. Emanuele Costa
- Eric Lombrozo
- Max Kaye
- Jonathan Mohan
- Paul Snow
- Jerry Liu
- Bin Lu
- Hai Nguyen
- Amir Shetrit
- Steve Dakh
- Kyle Kurbegovich
- Tim Hughes
- Richard Stott
- Ian Meikle
- Nicolas Fierro
- Aeron Buchanan
- Jason Colby
- Marko Simovic