Ether sold

The ethereum ether sale has now concluded.

Total ether purchased:

 ETH

Current price:

1 bitcoin buys 2000 ether
Buy Ether

ether sale ends in:

Days
:
Hours
:
Minutes
:
Seconds

time remaining at current price:

Days
:
Hours
:
Minutes
:
Seconds
next price: 1 bitcoin buys 2000 ether

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.

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

purchase ether

info >purchase >download

STEP 1

Enter amount to purchase in either bitcoin or ether.

amount in bitcoin

=

amount in ether

Price: 1 bitcoin buys  ether.
Minimum purchase amount is 0.01 bitcoin or 
 ether, maximum purchase amount is  bitcoin or  ether.

STEP 2

Enter a valid email address. Your wallet backup will be emailed to this address.

STEP 3

Enter a password. This is required to encrypt and access your wallet.

  • 10+ characters
  • Upper and lowercase letters
  • Numbers
  • Symbols

STEP 4

Move your mouse around the screen to generate a random wallet,
and once you are done you will be moved to the next screen.

To ensure that you remember your password,
please re-enter it here and click the button to go to the next step:

{{password_validation_error}}  

If you cannot remember your password, click here to start the purchase process fresh.

Go back

You are about to buy {{ethToBuy}} ether for {{btcToSend}} bitcoin

DO NOT LEAVE THIS PAGE once you have sent bitcoin.
When your bitcoin is received you will be taken to the next step.
DO NOT SEND bitcoin more than once to the bitcoin address unless you are still on this page.

STEP 5

Send exactly {{btcToSend}} bitcoin to the address below:

Payment address:

{{wallet.btcaddr}}

purchase status: {{status}}

Loading...

Your ethereum address:

{{wallet.ethaddr}}

PLEASE ENSURE THAT YOU HAVE DOWNLOADED YOUR WALLET AND ENSURED THAT THE
.JSON WALLET FILE (ethereum-wallet-.json) IS ON YOUR COMPUTER BEFORE YOU SEND ANY BTC.

You will also be emailed a backup of this file and redirected to the final step when a transaction is detected.

Download your wallet

print page

Thank you!

Step 6: Download your wallet

This file represents your private key to your wallet. It is in the form of a .json file that has been encrypted with your password. When the ethereum blockchain goes live you can import this file into your wallet and the balance will reflect the amount of purchased ether.

(Re-) Download your wallet

Recommendations

  1. Write down your password and store it in a secure location
  2. Backup your wallet .json file on multiple secure mediums
  3. Visit our forums if you have any questions or contact us at helpdesk@ethereum.org.
Done

Transaction Information

bitcoin transaction ID:

{{transactionHash}}

X/X

Your bitcoin payment must receive six confirmations
in order to be considered valid

Your email address:

{{email}}

Your ethereum address:

{{wallet.ethaddr}}

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

Videos

download

Proof of Concept client

windows client
mac client
linux source
build from source

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.

open source, one click app install.

  • law
  • cloud storage
  • prediction markets
  • trading
  • decentralized hosting
  • your own currency

— or —

make your ownmake your own
HTML5 CSS3 JS
Mobile & desktop reference clients.
Turing complete contracts on a blockchain.
C++GoPython
flexible implementations.

Contact media ethereum

--

Stephan Tual CCO

stephan@ethereum.org

--

Hub Locations

--

Ethereum Switzerland GmbH

Grienbachstrasse 55 Baar-Inwil 6340

--

Ethereum Toronto

Financial District, Toronto, Canada

--

Ethereum New York

--

Ethereum London

--

Ethereum Berlin

--

Ethereum Amsterdam

--

press & media sources

Desktop Backgrounds

1280x720px

1280x1024px

1440x900px

1920x1080px

2560 x 1600px

ethereum meetups

Meet developers and entrepreneurs at one of our meetups

You can also find answers to your questions on our forums, wiki, or blog