axic/roadmap.md

## roadmap.md

      
    Raw
  

              roadmap.md
            
          
    eWASM Roadmap 2017-2018

UPDATE: for a clearer and up to date picture please refer to https://github.com/ewasm and https://gitter.im/ewasm/lobby
(Intro: https://github.com/ewasm)
The goal is to launch a preliminary test environment ("test net") with eWASM very early 2018 and to have a
stable eWASM test ecosystem by mid-2018.
Timeline:

Early 2018: Preliminary test net
Mid Late 2018: Stable test net (around Devcon4)
End of 2018 Mid/End 2019: Earliest time for potential adoption on main net (assuming 6 months after stable test net)

Note: this is a document constantly updated - see the version history for changes
Components:

Mining node: Hera (C/C++) + cpp-ethereum

A prototype of this works, but needs to be updated
for latest EVM-C (the API between Hera and cpp-ethereum)
and to implement the entire eWASM spec.
Downside of cpp-ethereum is the lack of PoA support.
Interested parties: @jakelang, @axic
Update: Hera is progressing well. See https://github.com/ewasm/hera

Mining node: Hera (C/C++) + go-ethereum

Hera can be used via EVM-C with geth too, though the
EMV-C implementation is quite outdated. It needs
to be improved.
Interested parties: @chfast
Update: A working prototype and a pull request under discussion is pending at go-ethereum


Mining node: native eWASM + go-ethereum
As a long term solution a WebAssembly interpreter
should be implemented in Go (preferred by the geth team).


Interested parties: @gballet
Update: A working prototype and a pull request under discussion is pending at go-ethereum


Light client: ewasm-kernel + evm2wasm (Javascript)
This project implements thin bindings needed for Javascript
and it also uses a Javascript version of evm2wasm, therefore
it is able to run both eWASM and EVM contracts.
It needs to be updated to the latest spec and battle tested
against the recent Ethereum state tests. That will ensure that
both ewasm-kernel and evm2wasm works correctly.
Once ewasm-kernel works, it should be made compatible with testrpc (or ganache-core)
so that it could be used to run truffle tests and in Remix.
This can be achieved by either:

adding an API compatible with ethereumjs-vm or
changing the code in testrpc which interacts with the VM.

Interested parties: @jwasinger
Update: This project is on hold.


Metering (the "Sentinel" contract) written in eWASM
This component can be used by every node to process contracts during deployment time.
It is a required component for launching a test net, but the work
mentioned above can be done parallel to this.
Interested parties: @axic, @jakelang, @wanderer
Update: This is in progress.


C library for eWASM
This has been written, but can be further optimised indefinitely.
Interested parties: @axic, @jakelang
Update: This project is on hold.


Precompiled contracts written in eWASM
This has been written, but need to be made compliant with the latests specs. (Depends on 6.)
Interested parties: @axic
Update: This has been mostly done. Available at https://github.com/ewasm/ewasm-precompiles


evm2wasm (EVM transcompiler) written in eWASM
The transcompiler currently exists in Javascript where each of the EVM opcodes
has a implementation written in WebAssembly and the script combines these
templates together and finally compiles them to bytecode.
The templates should be complete, though new Byzantium instructions are missing.
The goal is to move the project into C and have it compiled into bytecode so
that it can be shared with all the clients (as mentioned above).
This depends on 4. (fully tested Javascript evm2wasm), 5. (library for writing bytecode) and 6.
Interested parties: @jwasinger
Update: evm2wasm has been translated into C++ and is used together with Hera. It passes a limited number of tests. Further work is on hold. Available at https://github.com/ewasm/evm2wasm


Writing example contracts in C, C++ or Rust
Though testing eWASM will be possible through using regular EVM contracts which
use the precompiles, it would be certainly beneficial writing native contracts as well.
Potential ideas:

Implement ENS registar / resolver in C
Implement RSA in C (with or without using the modexp contract)
Implement Smartpool.io (which basically does an Ethash verification)

Update: See the "WRC20 challenge".


Solidity/Julia to eWASM compilation


The Solidity project has a new internal language called Julia for which a preliminary
compiler exists to output eWASM bytecode. Another component is to compile Solidity to Julia.
This part is unlikely to be finished soon, certainly not within the proposed timeframes above.
Update: Project on hold.