Ethereum has grown very rapidly in the last few months. Transaction volume on the blockchain has more than doubled, surpassing 10 transactions per second for days at a time. The number of new accounts created per day passed 100,000, and the number of nodes has increased despite rising system requirements. As attention and interest in the blockchain space as a whole continues to hit new highs, we are entering a new phase in the industry’s growth: the phase where we are finally going from experiments and tests to real, live applications.
- A Casper proof of stake testnet based on pyethereum has been released.
- Various simplifications to the algorithm, including the reduction to one message type, have been finalized (also updated the accountable safety proof in Isabelle).
- The Casper FFG basics paper has been released.
- See presentations (i) and (ii) from Karl Floersch on Casper FFG, and (iii) from Jon Choi on cryptoeconomics; see also this explainer of Casper by Jon Choi.
- A specification of version 1 of sharding has been released: https://github.com/ethereum/sharding.
- Development of the sharding client has moved from pyethereum to py-evm.
- All of the different components, including account abstraction, the new transaction format, access list restrictions, the binary trie, and the shard watching and validating algorithm, are in the process of being developed.
- See presentation from Hsiao-Wwei Wang on sharding.
- Sharding implementation is underway in the sharding branch.
- JSON-RPC server implementation underway.
- Very rough initial Documentation.
- Light Client development continues. You can now run a minimalistic light node.
- Full support for Byzantium fork rules.
EIPs (Ethereum Improvement Proposals)
We merged 12 EIPs since the last roundup.
- We received a contribution from Sidney Amani and his colleagues at Data61 that reduces the number of reasoning steps in EVM code verification.
- Fixed a bug in Bamboo related to JSON ABI formatting.
- Testeth now checks that test .json files are updated with the test filler files. Each test has a hash of its filler.
- Testeth will show a warning if there is a test without a filler.
- Transaction test fillers are now in general format. One test describes a case for all different fork rules.
- Some large test suites (with many tests) were split into separate smaller ones for better execution on threads via ctest.
- Testeth random code options were revived. With `–createRandomTest`, testeth will generate a smart random state test. This command also accepts options for generating a random code.
- Testeth options throw a warning/error if used incorrectly.
- New tests were added from the spreadsheet.
- A PR with YAML support for test filler files is in progress. Unlike JSON format, YAML format allows user comments and multiline fields for nice smart contract representation.
Latest update (remix.ethereum.org) includes:
- A way to record transactions (in order to execute them later on).
- Use of the standard JSON IO interface for the Solidity Compiler.
- Improvement on the Solidity Editor.
- Direct use of the ABI to interact with contracts.
- General interface improvement.
- New Static Analysis module.
Thanks to @ninabreznik (Solidity Editor), @serapath (Recorder), @ryestew (Interface) for their active contributions.
We are now focusing on improving the code editor, improving Remixd (which is now hardly usable for huge folders) and polishing the themes.
We continue to work try our best to update remix.ethereum.org each month and for each important bug fix. As Remix is under heavy development, there are always new features coming in, so feel free to contribute feedback and code.
We are working on an optimizer for our new intermediate language IULIA. The first goal is to turn the extremely modular code of the new ABI coder into efficient code. Of course all inline assembly and also the main code generator will benefit from this work in the end. In contrast to the old optimizer, which basically soaked in bytecode into an internal representation and then re-generated the code from scratch, the new optimizer is composed of many small and very simple individual stages that directly operate on the IULIA AST and thus are easily verifiable for correctness.
The second large area of work is the SMT checker component. It is now able to correctly follow branching and joining control flow and also takes conditions into account. Experimental loop unrolling is the next stage.
I would like to thank the many voluntary external contributors for their hard work (individual attributions are made on the release page, as always)!
We are continuing the efforts to fuzz-test the EVM, and we are also applying fuzz testing to other areas of the Ethereum platform such as the geth networking stack and the solidity pipeline where we are seeing if it can be used for quality assurance of some new IULIA components.
We are creating a new signer to enable more advanced use cases where account management is decoupled from the network node. The idea is to have a what-you-see-is-what-you-sign experience, where the sensitive components can be executed in a separate VM, or on a separate computer or a mobile phone.
There has been quite a lot of activity on the bounty-front, particularly targeting Mist, and we’d like to remind all usersurge you not to use the Mist browser on untrusted networks or untrusted websites.
Also, EthereumJ is finally being added to the group of clients which undergo Hive-testing, and EthereumJS is being added to the group of clients supporting the common shared json output so that it can play along with the others in the Evmlab tools.
We have completed migrating the repositories for most of the python libraries to the Ethereum Foundation github. Many of these libraries were renamed in the process to conform to a single naming convention. If you use any of the following libraries, you should update your dependencies.
- ethereum-utils renamed to eth-utils
- ethereum-abi-utils renamed to eth-abi
- ethereum-keys renamed to eth-keys
- ethereum-keyfile renamed to eth-keyfile
- ethereum-tester renamed to eth-tester
In addition, most of the python tooling will now issue deprecation warnings when run using python 2. Support for python 2 will be removed in the first quarter of 2018. Please upgrade to python 3 if you haven’t already.
The eth-tester python library has gotten a few upgrades and improvements. This library is still in a pre-release beta.
- New pyethereum>=2.1.0,<2.2.0 backend
- Updated py-evm backend for latest byzantium rules.
- Various bug fixes.
Web3.py lets your python code interact with an Ethereum node. Version 4 was released, as Beta, including these changes:
- Automatic Ethereum Name Service lookups: methods that accept hex addresses now accept ENS names.
- Working with local private keys: sign and verify simple transactions, contract transactions and messages.
- Better guessing at connection parameters, for less boilerplate when initializing Web3.
- EIP 55 checksum addresses returned everywhere, and required as input.
- Better native handling of string and bytes types; more `bytes`, less hex `str`.
- Our Byzantium update is well-received (pre-Byzantium still usable with v2.2.2 release) and already used by Remix and Ganache (former TestRPC).
- Devcon3 talks on web3.js 1.0, the EthJS dev toolkit and remix development, were presented, as were also various other talks regardingwith relevant technical background.
- New rustbn.js library for the elliptic pairing precompiles in the VM based on the Rust library from Zcash/Parity.
- Support for merkle proof creation and verification in the merkle-patricia-tree library (courtesy of @jbaylina).
- EIP-8 compatibility and better documentation for our devp2p library.
- A lot of Devcon3 EthJS feedback, coming updates: possible callback support removal for Node.js clarity, easy BLS signing libs (thanks DFinity!), an Ethereum node wrapper for easier testing, package management helper libraries, better filtering support.
The 1.0 branch is evolving with the help of a lot of community contributions. Even though it is still in beta, many developers already use 1.0 for their projects and the response so far has been overwhelmingly positive. In the next weeks, the web3-accounts package will be audited as it can be used for generating keys and signing messages and transactions.
eWASM (Ethereum WebAssembly)
Progress continues on ewasm-kernel and evm2wasm, which form a prototype VM and transpiler written in JS. Progress also continues on Hera, a VM written in C++ that is compatible with the EVM-C API. We are working to transpile the EVM state tests into an eWASM test suite which can be used for testing Hera. The near-term goal is to build a “Geth+Hera” client and use it to launch an eWASM testnet.
- The cpp-ethereum is Byzantium ready from the Byzantium first block.
- The EVM-C interface is progressing. An experimental branch of go-ethereum exists where geth is powered by EVMJIT virtual machine through EVM-C API. You can find a running node of type “Geth+EVMJIT” on https://ethstats.net from time to time.
- EVMJIT is also Byzantium ready. We are working on upgrading LLVM from 3.9 to 5.0 (thanks @dmakarov). There is someI also hope for finally using ORC JIT API instead of MCJIT.
- RPC API cleaned up.
- Ropsten sync improvements.
- More multithreading problems fixed.
- EVM traces now follow the standardized format.
- Communicating with devp2p v5 nodes fixed.
- Fix to support networks with high CHAIN_ID value.
- Command-line interface reworked and improved.
- External proxy tool now is used to serve HTTP RPC requests instead of having HTTP server inside the client.
- A lot of various fixes around Continuous Integration and building experience.
- New Contributing Guidelines. Code formatting now can be automated with clang-format.
- The work on the snapshot sync continues: snapshot importing now consumes less memory; cpp-ethereum nodes now can serve snapshots to other nodes; instructions added for those willing to try syncing from the snapshot.
There has been one geth release since the last roundup, v1.7.3. Highlights in that release
- Version 2 of the les light client protocol. les/2 adds support for retrieving partial log bloom filters, which enables quick log filtering with the light client.
- `geth –dev` is much faster and uses Proof of Authority instead of Proof of Work.
For the next release, work is focused on:
- An overhaul of the VM tracing infrastructure:
- support for tracing a range of blocks, including reconstructing historical states.
- predefined tracing functions, e.g. for collecting all internal transactions or the state closure of a particular call.
- Moving handling of account private keys from geth into helper tools:
- the signer, a tool for signing transactions.
- ethkey, a command-line tool for dealing with key files.
- Shipping a working peer discovery v5 prototype and publishing associated EIPs.
- Enabling more static analysis tools for continuous integration builds.
Ethereum Wallet and Mist Beta had surpassed the 3 million downloads mark, combined. The latest version, 0.9.3, was downloaded over 450k times.
Our team welcomes two new members: Marc Garreau and Ryan Ghods. After a while, we’re back to a full squad.
Main changes since the last update:
– Light client integration and Wallet Dapp adaptations, although the LES v2 is still experimental.
– A rewrite of the core of Mist, enabling a better state control and resources handled by the application.
– Studies and a lot of mocks/sketches concerning the next step of node, transaction and accounts management.
– Numerous bug fixes and issue handling.
We recently released a security alert concerning Chromium vulnerabilities affecting Mist Browser Beta.
One of our projects is PSS, a messaging system built on top of Swarm. The features planned for PoC3 are mostly done, and PSS is already used as the backend of the prototype chat application of Mainframe.
PSS uses the routing network of Swarm to deliver messages between nodes. It already implements the following features: encryption (optionally with ephemeral keys generated by the handshake module), luminosity control (full, partial or no disclosure of addresses of communicating nodes), RPC api and flood prevention. We still have a few tasks to do, mostly stress testing and benchmarking and we also have to merge back the code to go-ethereum master.
We are also working on the swap, swear and swindle incentivization system. We have a basic implementation of swindle, swap and chequebook in the Swarm code, and the other parts are described in the in-progress paper. Our goal is to finalize the paper and start to implement the incentive layer.
In our network testing and simulation project, we implemented a framework to create and run a simulation network of devp2p nodes. For the simulation we implemented node adapters which create a test environment for the nodes to run in ( in-process, executable and docker adapters). We also created a 3d visualization app to display the network structure and behavior.
We also started promising collaborative efforts with Wolk (to develop a database layer on top of Swarm), Livepeer (to implement live video streaming using Swarm) and Status (to implement light swarm nodes for mobile).
Version 6 of Whisper has started., Wwe hope to be done by the end of February. v6 offers nodes more control over the network load, explores the use of libp2p in the go codebase, and improves compatibility with the Parity version of whisper.