ethereum

The ethereum ether sale has now concluded.

Estimated ether purchased:

ETH

ether sale ends in:

Days

Hours

Minutes

Seconds

time remaining at current price:

Days

Hours

Minutes

Seconds

what is the ether sale?

Ether is a necessary element -- a fuel -- for operating the distributed application software platform we are building: ethereum. Without the requirement of payment of ether for every computational step and storage operation within the system, infinite loops or excessive storage demands could bog down ethereum and effectively destroy it.

People interested in acquiring ether to build and distribute decentralized applications, or to pay for their usage, are able to do so in the Genesis Sale using bitcoin, thereby locking-in their supply at a known price. This sale will help us fund the continued development of the software platform, scheduled for release in the winter of 2014/2015.

Once the initial batch of ether is created in the genesis block - the go-live date of the software platform - people who have purchased ether in the pre-sale will be able to claim their product using the wallet that they downloaded and the password that they created during the purchase. If you buy ether DO NOT LOSE THE WALLET OR PASSWORD otherwise your ETHER WILL BE LOST.

Also, please note that before the release of the Genesis Block in the winter of 2014/2015, ether will not be usable in any way, in fact it won’t technically be created until that point in time.

If you have already purchased ether, you can check your account balance by entering your address here:

Check balance

If your funds got stuck in the intermediate BTC address you can recover them using the tool below:

resources

To learn more about ethereum:
Ethereum White Paper

For development specifications:
ĐΞV PLAN

Ethereum Roadmap:
Ethereum Roadmap

To learn more about our plans:
Intended Use of Revenue

Terms of ether sale:
Terms and Conditions of the
Ethereum Genesis Sale

Ether Product Purchase Agreement:
Ether Product Purchase Agreement

news

Introduction

Status

Ether Sale

The ether sale has started - please check above for instructions on how to purchase ether

Release date and Mining

We expect to launch our live mainnet in Q4 2014. All Ether generated on the testnet is 'play Ether' and is reset regularly to prevent its resale.

Client downloads

The current clients available on this site are purely proofs of concept intended for an advanced technical audience. They do not reflect the final UI of our reference clients.

Twitter

Tweets by @ethereumproject

Videos

Links

Forums

Blog

Wiki

Code

Whitepaper

Yellow paper

Google+

Facebook

YouTube

Meetups

General FAQ

Writing Smart Contracts FAQ

GoLang code and Build FAQ

C++ code and Build FAQ

Meetup FAQ

Mining FAQ

download

Proof of Concept client

ethereum go

ethereum c++

ethereum java

ethereum github

What

Ethereum is a platform and a programming language that makes it possible for any developer to build and publish next-generation distributed applications.

Ether, Ethereum's cryptofuel, powers the applications on the decentralized network.

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 white and yellow papers.

…will you build with Ethereum?

Name Registration

if tx.value < block.basefee * 200:
    stop
if contract.storage[tx.data[0]] or tx.data[0] < 100:
    stop
contract.storage[tx.data[0]] = tx.data[1]

Metacoin Protocol

if tx.output[0] != MARKER:
    break
else if balance[tx.output[1]] < decode_value(tx.output[3]):
    break
else if not tx.hasSignature(tx.output[1]):
    break
else:
    balance[tx.output[1]] -= decode_value(tx.output[3]);
    balance[tx.output[2]] += decode_value(tx.output[3]);

Sub-currencies

init:
    # Initial: premine 1000000 units to creator
    contract.storage[msg.sender] = 1000000
code:
    # If a message with one item is sent, that's a balance query
    if msg.datasize == 1:
        addr = msg.data[0]
        return(contract.storage[addr])
    # If a message with two items [to, value] are sent, that's a transfer request
    else:
        from = msg.sender
        fromvalue = contract.storage[from]
        to = msg.data[0]
        value = msg.data[1]
        if fromvalue >= value:
            contract.storage[from] = fromvalue - value
            contract.storage[to] = contract.storage[to] + value
            return(1)
        else:
            return(0)

Data Feed

# Database updateable only by the original creator
init:
    contract.storage[1000] = msg.sender
code:
    // Message of the form [key, value] updates the database
    if msg.sender == contract.storage[1000] and msg.datasize == 2:
        contract.storage[msg.data[0]] = msg.data[1]
    // Database query
    else:
        return(contract.storage[msg.data[0]])

Hedging Contract

if tx.value < 200 * block.basefee:
    stop
if contract.storage[1000] == 0:
    if tx.value < 1000 * 10^18:
        stop
    contract.storage[1000] = 1
    contract.storage[1001] = 998 * block.contract_storage(D)[I]
    contract.storage[1002] = block.timestamp + 30 * 86400
    contract.storage[1003] = tx.sender
else:
    ethervalue = contract.storage[1001] / block.contract_storage(D)[I]
    if ethervalue >= 5000:
        mktx(contract.storage[1003],5000 * 10^18,0,0)
    else if block.timestamp > contract.storage[1002]:
        mktx(contract.storage[1003],ethervalue * 10^18,0,0)
        mktx(A,(5000 - ethervalue) * 10^18,0,0)

Decentralized Autonomous Organizations

if tx.value < tx.basefee * 200:
    stop
if contract.storage[tx.sender] == 0:
    stop
k = sha3(32,tx.data[1])
if tx.data[0] == 0:
    if contract.storage[k + tx.sender] == 0:
        contract.storage[k + tx.sender] = 1
        contract.storage[k] += 1
else if tx.data[0] == 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[0] == 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

Crowd Fund

if msg.data[0] == 0:
    # Start a campaign, data [goal, time limit]
    id = contract.storage[-1]
    contract.storage[-1] = id + 2^128
    contract.storage[id] = msg.sender // Campaign creator
    contract.storage[id + 1] = msg.data[1] // Goal
    contract.storage[id + 2] = block.timestamp + msg.data[2] // Time limit
    contract.storage[id + 3] = id + 5 // Start recording donations here
    // contract.storage[id + 4] is a running counter
    return(id)
elif msg.data[0] == 1:
    # Contribute to a campaign [id]
    id = msg.data[1]
    val = contract.storage[id + 4]
    contract.storage[id + 4] = val + msg.value
    sub_index = contract.storage[id + 3]
    contract.storage[sub_index] = msg.sender
    contract.storage[sub_index + 1] = msg.value
    contract.storage[id + 3] = sub_index + 2
    # Enough funding?
    if val + msg.value >= contract.storage[id + 1]:
        send(contract.storage[id], val + msg.value)
        v = id
        f = sub_index + 2
        while v < f:
            contract.storage[v] = 0
            v += 1
        return(1)
    # Expired?
    if block.timestamp > contract.storage[id + 2]:
        v = id
        f = sub_index + 2
        while v < id + 5:
            contract.storage[v] = 0
            v += 1
        while v < f:
            send(contract.storage[v], contract.storage[v + 1])
            contract.storage[v] = 0
            contract.storage[v + 1] = 0
            v += 2
        return(2)
elif msg.data[0] == 2:
    # Progress report [id]
    return(contract.storage[msg.data[1]] + 4)

Namecoin

// Namecoin

if !contract.storage[msg.data[0]]: # Is the key not yet taken?
    # Then take it!
    contract.storage[msg.data[0]] = msg.data[1]
    return(1)
else:

    return(0) // Otherwise do nothing

Quick Sort

if msg.datasize < 2:
    return(msg.data, msg.datasize)
else:
    low = array(msg.datasize)
    lsz = 0
    high = array(msg.datasize)
    hsz = 0
    i = 1
    while i < msg.datasize:
        if msg.data[i] < msg.data[0]:
            low[lsz] = msg.data[i]
            lsz += 1
        else:
            high[hsz] = msg.data[i]
            hsz += 1
        i = i + 1
    low = call(contract.address, low, lsz, lsz)
    high = call(contract.address, high, hsz, hsz)
    o = array(msg.datasize)
    i = 0
    while i < lsz:
        o[i] = low[i]
        i += 1
    o[lsz] = msg.data[0]
    j = 0
    while j < hsz:
        o[lsz + 1 + j] = high[j]
        j += 1
    return(o, msg.datasize)

SchellingCoin

# SchellingCoin implementation
#
# Stored variables:
#
# 0: last_processed_block
# 1: number of hashes submitted
# 2: value
# 3: quicksort_pairs address
#
# 2^160 + 3x: hash
# 2^160 + 3x + 1: deposit
# 2^160 + 3x + 2: address
# 2^170 + x: value
#
# Transaction types:
#
# [1, sha3([address, value])] -> id: submit hash (only works when block number mod 100 < 50)
#
# [2, id, value]: submit answer (only works when block number mod 100 >= 50)
#
# [3]: balance query
#
# [4]: value query
#
# Parameters:
#
# Epoch length: 100 blocks
# Target savings depletion rate: 0.1% per epoch

init:
    contract.storage[0] = block.number
    contract.storage[3] = create('quicksort_pairs.se')
    
code:
    HASHES = 2^160
    VALUES = 2^170
    if block.number / 100 > contract.storage[0] / 100:
        # Sort all hashes
        N = contract.storage[1]
        o = array(N)
        i = 0
        j = 0
        while i < N:
            if contract.storage[VALUES + i]:
                o[j] = contract.storage[VALUES + i]
                o[j + 1] = i
                j += 2
            i += 1
        values = call(contract.storage[3], o, j, j)
        
        # Calculate total deposit, refund non-submitters and
        # cleanup
        
        deposits = array(j / 2)
        addresses = array(j / 2)
        
        i = 0
        total_deposit = 0
        while i < j / 2:
            base_index = HASHES + values[i * 2 + 1] * 3
            contract.storage[base_index] = 0
            deposits[i] = contract.storage[base_index + 1]
            contract.storage[base_index + 1] = 0
            addresses[i] = contract.storage[base_index + 2]
            contract.storage[base_index + 2] = 0
            if contract.storage[VALUES + values[i * 2 + 1]]:
                total_deposit += deposits[i]
            else:
                send(addresses[i], deposits[i] * 999 / 1000)
            i += 1
            
        inverse_profit_ratio = total_deposit / (contract.balance / 1000) + 1
        
        # Reward everyone
        i = 0
        running_deposit_sum = 0
        halfway_passed = 0
        while i < j / 2:
            new_deposit_sum = running_deposit_sum + deposits[i]
            if new_deposit_sum > total_deposit / 4 and running_deposit_sum < total_deposit * 3 / 4:
                send(addresses[i], deposits[i] + deposits[i] / inverse_profit_ratio * 2)
            else:
                send(addresses[i], deposits[i] - deposits[i] / inverse_profit_ratio)
                
            if not halfway_passed and new_deposit_sum > total_deposit / 2:
                contract.storage[2] = contract.storage[VALUES + i]
                halfway_passed = 1
            contract.storage[VALUES + i] = 0
            running_deposit_sum = new_deposit_sum
            i += 1
        contract.storage[0] = block.number
        contract.storage[1] = 0
        
    # Hash submission
    if msg.data[0] == 1:
        if block.number % 100 < 50:
            cur = contract.storage[1]
            pos = HASHES + cur * 3
            contract.storage[pos] = msg.data[1]
            contract.storage[pos + 1] = msg.value
            contract.storage[pos + 2] = msg.sender
            contract.storage[1] = cur + 1
            return(cur)
    # Value submission
    elif msg.data[0] == 2:
        if sha3([msg.sender, msg.data[2]], 2) == contract.storage[HASHES + msg.data[1] * 3]:
            contract.storage[VALUES + msg.data[1]] = msg.data[2]
            return(1)
    # Balance request
    elif msg.data[0] == 3:
        return(contract.balance)
    # Value request
    else:
        return(contract.storage[2])

Why?

Most of the services you use today have something in common: they are centralized. For example, when when you deposit money at your bank, you trust them to be honest, be secure and be independently audited. The same is true when you post pictures on Facebook, or an important document on Dropbox. History has proven time and time again that this model is flawed, but necessary, as ‘trustless’ operations have been so far both unprofitable and too complex to implement.

Enter Ethereum.

Applications built on Ethereum do not require their users to trust the developers with their personal information or funds. Ethereum not only addresses the issues described above, it also opens the door to whole new kinds of applications that have never been seen before

philosophy

Simplicity

Ethereum is a protocol that is open to all. Any programmer should be able to write smart contracts and Ethereum apps in languages they already are familiar with.

Programmers should also be able to implement the entire specification with relative ease, in order to minimize the influence that any specific individual or group could have on the protocol.

The Ethereum protocol should be as simple as possible, and optimizations which add complexity should not be included unless they provide a very substantial benefit.

Universality

Ethereum does not have "features". Instead, Ethereum provides a scripting language which you can use to construct any program you can think on top of a distributed network.

This has implications going far beyond finance and smart contracts. Imagine what sort of problems could be solved if software was executed in a cloud, was always auditable, and always trustable. This opens the door to the development of voting machines, health care systems, traffic navigation, etc. where users stay in control of their funds and personal information at all times, as part of a network that's both censorship and collusion-proof.

Modularity

Different elements of the Ethereum protocol should be designed to be as modular and autonomous as possible. During the course of development, it should be easy to make small modifications to the protocol in one place and have the entire stack continue to function as normal.

Innovations such as our Proof of Work algorithm, Patricia Trees and RLP should be implemented as separate libraries and made feature-complete even if Ethereum does not require their entire feature set.

The development of Ethereum should benefit the entire cryptocurrency ecosystem.

Non-Discrimination

The protocol should not attempt to actively restrict or prevent specific categories of usage. The regulatory mechanisms in the protocol should only be designed to regulate harm, not attempt to oppose specific undesirable applications.

For example, you should be able to run an infinite loop on top of Ethereum for as long as you are willing to keep paying the per computational step fee for it.

Agility

The details of the Ethereum protocol are not set in stone, although of course we will be extremely judicious about making modifications to high-level constructs such as the low-level VM language and the address system.

Computational tests taking place later on in the development process may lead us to discover that certain modifications to the algorithms or scripting languages could substantially improve scalability or security. If any such opportunities are found, we will certainly make use of them.

What can you make out of ether?

Create a Currency
and issue Shares

Contracts, Law and Escrow

Financial Instruments and Derivatives

Decentralized Organizations (DAOs)

Decentralized Voting

Decentralized Data Storage

Contracts are the main building blocks of Ethereum. A contract is a computer program that lives inside the distributed Ethereum network and has its own ether balance, memory and code. Every time you send a transaction to a contract, it executes its code, which can store data, send transactions and interact with other contracts.

Contracts are maintained by the network, without any central ownership or control. Contracts are written in languages instantly familiar to any programmer and powered by Ether, Ethereum's cryptofuel. You can find out more in our wiki.