Ethereum (ETH) - POW/POS - Ethash
Ethereum Release Geth version 1.8.8 (Coffice)
Geth Coffice (v1.8.8) is a tiny biweekly release, containing countless code cleanup PRs from @kielbarry#16562).
- Fix crash when using an invalid private network genesis (#16682#16716).
- Handle Android signing keys flexibly, hopefully fixing Maven (#16696#16666).
- Support retrieving receipt status codes from the mobile libraries (#16598Geth 1.8.8 release milestone.
Binaries and mobile libraries are available on our download page.
The Swarm Team is pleased to announce the immediate release of Swarm client v0.3, the third proof-of-concept release (POC3) of the Ethereum Swarm client. The POC3 code is now merged into the official go-ethereum repository’s master branch.
Swarm 0.3 has been deployed to the public Testnet, and the Ethereum Foundation is running a 50-node strong cluster of Swarm nodes together with a public web gateway on https://swarm-gateways.net. We welcome everyone to try it out or commit to operate stable nodes.
The past year
It has been a year and a half since the first release of the POC2 series was deployed and the Swarm project launched its public alpha network. Two Swarm summits, two orange papers and forty thousand lines of code later, it is time to take stock.
In the past year the Swarm team has grown in size and is now on fire delivering the vision. We have been busy redesigning the network layer, rewriting the retrieval protocol using a stream abstraction, rewriting connectivity management and the overlay network code as well as developed a sophisticated network simulation framework to test algorithmic correctness, scalability and fault tolerance of various subsystems. POC3 code was finalised just in time for the Swarm Orange Summit in Ljubljana, where we had 80 participants and a very inspiring and creative week (watch this two-minute video hosted on Swarm) of talks and coding. It is inspiring to see a growing number of contributors and companies that want to build on swarm.
Swarm content storage is a lot more than just “bittorrent on steroids”. The technical details can be found in the chapter on architecture in the new and improved Swarm guide. You’ll find a more thorough academic presentation of Swarm’s components in the orange papers or learn more about Swarm through the recorded conference talks.
In an earlier blog post, we introduced the basics of Swarm storage and content distribution.
At its core, Swarm is a service that provides APIs to upload and download content to the cloud and through URL-based addressing offers virtual hosting of websites and decentralised applications (dapps) without webservers, using decentralised peer-to-peer distributed infrastructure. The vision is that of a new internet which is not only fault-tolerant, has zero downtime and offers censorship resistance but is also economically self-sustaining due to a built-in incentive system. By compensating nodes for contributing their bandwidth and disk space, these incentives aim to achieve reliable low-latency scalable retrieval of popular content on the one hand and guarantees persistence of important yet rarely accessed data like archives or backups on the other. For smooth delivery Swarm will use the SWAP protocol (planned for POC3.1) while for storage guarantees it will use a two-tiered insurance system (planned for POC4).
Beyond the basics of data storage and delivery, the POC 3 release includes some new and experimental features.
The online Windows XP simulator runs in a web browser and its operation imitates the operating system. You can use it to prank someone.
The same p2p connections that are used for data storage and delivery can also be used for node-to-node messaging. PSS combines Swarm routing (
bzz) with the Whisper (
shh) encrypted message format (
pss). In short, PSS is a messaging protocol with strong privacy features running on top of the Swarm network. This messaging infrastructure can be the foundation of a whole new system of internode communication services (the email, tweet, newsletter of the future), hence, can be referred to as Postal Service over Swarm.
PSS is fully featured yet experimental on the new POC3 network and dapps can interact with it using a JSON RPC API. We are collaborating closely with companies and projects that want to use pss to build second-layer infrastructure. Mainframe is building a slack-alternative collaborative group communications tool (Onyx) and their web3 SDK, and Status have expressed interest in building it into their mobile chat.
Another experimental new feature in POC3 is the Swarm Mutable Resource. Typical in p2p storage systems, content is addressed by its digital fingerprint (hash) and any changes to the content results in a change of this address. Users of the web, however, are accustomed to mutable resources: when visiting URLs we expect to see the most up-to-date version of the ‘site’. In order to make it easy to access changing content at permanent human-readable addresses, Swarm integrates with the Ethereum Name Service (ENS) on the Ethereum blockchain. This is what allows us to reference Swarm content by names like bzz://theswarm.eth.
Swarm POC3 adds another layer in the form of Mutable Resource Updates (MRU). These allow off-chain updates of content associated with an address at a potentially faster pace than ENS updates on the blockchain could support and without incurring the cost of on-chain transactions.
MRU is an experimental feature in current POC3 testnet and is still undergoing changes.
FUSE enables users to integrate Swarm data directly into their local file systems (only on Linux and Mac). Using this system, users can “mount a Swarm manifest” as if it were a regular directory. It supports file system read and write operations, in which all content is automatically synced with the Swarm. In future, combining FUSE with Swarm Mutable Resources, it should be possible, for example, to sync your entire home folder between devices - the backend to a decentralised storage with a Dropbox-like functionality.
Swarm 0.3 comes with built-in encryption allowing for secure uploads of private data. The way encryption works users can upload a directory privately and still ‘share’ a subdirectory with specific peers.
Access Control Trees (Swarm 0.3.2) will offer an API for users to manage access to content independently of publishing it. Granted access will work across versions of resources.
The year ahead
The year ahead will be both exciting and challenging. As part of the POC3 series we are planning to switch on a revamped SWAP accounting system (Swarm 0.3.1) and enable ‘light’ Swarm nodes (Swarm 0.3.2). Implementing erasure coding, proof of custody, insurance are also on the roadmap. We are on target delivering Swarm POC4 (production beta prerelease) in 2019.
We keep on building a community with our allies who champion the values of web3 and actively collaborate through working groups, building the foundational infrastructure, the backbone of second-layer services such as databases (http://wolk.com), private data management (http://datafund.io), rights and creative works licensing (http://jaak.io), decentralised version control (ethergit, http://epiclabs.io), video transcoding and streaming service (http://livepeer.org), communication and collaboration (https://mainframe.com) and the list is growing.
We welcome your feedback and contribution. Come find us in our gitter channelgithub repository.
We welcome your feedback and contribution. Come find us in our gitter channelgithub repository.
Tether (USDT) Brings Another 250 Million, Funds Flow into Ethereum
Ethereum Release Wallet and Mist Beta 0.11.0
The Mist team has been working hard on a solution to balance decentralization with user experience.
While running a full node is important to the health of the network, we all know the weight of doing so on a consumer machine. Amazing services, like Infura, can help you get connected immediately but introduces new risks.
From the beginning, Ethereum Wallet and Mist beta have prioritized running a local ethereum node, helping relay blocks and keep the pulse of the ethereum blockchain worldwide.
Today, we are introducing a hybrid solution that brings the swiftness of Infura with the power and security of running your own Geth node. After connecting immediately to a remote node, your local node takes over all subscriptions and filters once it's up to date.
Devcon4 Application Deadlines Coming Soon
Přátelé. Just a quick update today!
Applications for sponsorships, scholarships, student discounts and builder discounts will be up until 11:59PM PST on July 24th.
After that, there will no longer be a way to submit an application for these tracks. Please note that if you’ve already submitted an application or do so before the deadline, it will be processed and responded to by the Devcon team in short order!
As we continue to work toward providing everyone an opportunity to attend Devcon, we’re capping applications in preparation for future waves and to give the general public the chance to join us!
We look forward to receiving your applications soon, and to seeing you in Prague!
Ethereum Release Wallet and Mist Beta 0.11.1 - windows hotfix
We've identified an interface bug on Windows versions of Mist Browser and Ethereum Wallet v0.11.0 releases, leading to a blank screen after startup. This release fixes it.Checksum (SHA256) Ethereum-Wallet-installer-0-11-1.exe
Devcon4 Call for Participation!
When we asked many of you, “What are you most excited for at Devcon4?” most people replied: the people! This is the one time a year we all get together in one place. We don’t want to spend all of our time at Devcon sitting in a dark room, staring in silence at a person on a stage – we want to see, meet and talk with each other.
In that spirit, we’re designing the programming and environment of Devcon4 to provide the time and space for all of us to make new connections – between people and ideas. This is a chance for us to ask each other the most important questions and dive deep into the toughest challenges (and exciting opportunities!) facing Ethereum today.
So we’re going to experiment with more participatory programming at Devcon4 this year!
Here are three ways you can apply to participate in Devcon4:
- Give a presentation: This is self-explanatory. ;) Give a 5-minute lightning talk or a 20-minute presentation on the topic of your choice.
- Lead a workshop: Teach people to do something. Over the course of 2 hours, participants should “get their hands dirty,” whether writing code or learning to tell stories.
- Host a breakout room: Be creative and come up with your own programming for Devcon4! Host dapp design critiques, facilitate a conversation, do live security reviews, [enter your awesome idea here]
When you apply, we ask that you connect your session to one of six core themes:
- Scalability: How can we scale Ethereum in a secure, decentralized, and trustless manner in order to achieve mass adoption?
- Security: How can we ensure the safety of user data and funds?
- Privacy: How can we empower users to be in control of their own data?
- Developer Experience: How can we make developing for Ethereum simple, extensible, and fun?
- UX & Design: How can we create a more intuitive, usable and delightful experience for our users?
- Society & Systems: Why do we BUIDL? How will this technology change our societal systems, and the people within them? (To be clear: this is also a bit of a “catch all” theme for governance, cryptoeconomics, social impact, memes, etc.)
If you want to talk about your specific dapp or protocol, please do so in the context of one of these shared topics. How have you identified or solved a common problem? How can your work benefit the rest of our community?
With ~3000 participants and only so much time, we expect applications for participation to be highly competitive this year. Please buy your tickets ahead of time in the chance that your submission isn’t accepted so that you don’t miss out on getting a ticket to Devcon4! We will process a refund for anyone who purchases a ticket and then qualifies for a complimentary pass.
Please help us create a Devcon4 experience in the spirit of these values:
- Participatory: We are all creating the Ethereum ecosystem together and Devcon4 should reflect that. In addition to educational talks, Devcon4 should provide opportunities for participants to contribute to the broader conversation and share information with one another.
- Educational: As the only EF-hosted event, Devcon4 is a chance for our community to learn directly from the leaders of the Ethereum ecosystem. Participants should learn things they couldn’t learn anywhere else.
- Fun: The number one reason why people come to Devcon is to see one another! Let’s create a uniquely “Ethereum” family reunion for our community.
Visit https://devcon4.ethereum.org/c... to learn more and apply!
Ethereum Foundation Grants Update - Wave 3
Ethereum Foundation Grants Update
We’ve been hard at work getting to know so many amazing people and projects, and are extremely excited to announce the recipients of the Wave 3 of the Ethereum Foundation Grants Program!
We kicked off 2018 with a blog post to galvanize scalability research for first and second-layer solutions. Since then, we’ve committed over $11M to 52 projects dedicated to advancing the Ethereum ecosystem. Grants have funded multiple plasma and state channel implementations, diverse client research, enhanced developer frameworks, security audits, and so much more (find them all in the previous posts: Wave 1 & Wave 2)!
A Look into the Selection Process
Since the Grants Program has picked up, we’ve received feedback requesting greater transparency into our processes and a deeper look into the various types of projects considered. Here’s a funding snapshot and grant process update:
The EF Grant Program provided more than $11M in support to 52 projects since early 2018 (Waves 1, 2, and 3).
Our funding allocation remains true to the program’s original purpose, awarding nearly $7M to scalability projects. After this, security has been granted almost $2M, #buidl projects (projects that improve user experience) received $1.6M, and DevEx projects (projects that improve developer experience) received $744K. While dollar allocation remains heavily focused on scalability, the number of projects funded are more evenly distributed between categories.
Grants Process Update
The EF Grants program is constantly evolving. With this round, we’ve refined our internal processes to ensure timely fund disbursement. We understand how quickly the space moves and believe in the importance of expedient fund dispersal to the front line. Eventually, we aim to award grants on a rolling basis in order to provide more immediate support to the projects and teams leading the charge for decentralization and transparency.
Ideal applicants come with strong technical knowledge, project roadmap, and show a commitment to fostering collaboration within the ecosystem. For more information about applicant expectations and process workflow, please see our Applicant Expectations and FAQs.
With each round, the grants program evolves. Our goal is to effectively grease the wheels for projects building the critical infrastructure of our young community. There are many tracks to lay down before Ethereum “makes it” and it’s been incredible to see all the projects working to lay down these tracks.
The applicant pool for Wave 3 offered a record number of strong teams and innovative ideas. It’s fascinating and humbling to see the diversity of projects from around the world with a shared interest in fostering the development of Ethereum. These are folks spending their free time reading ethresear.ch, developing new libraries and wallet designs, and engaging in communities discussing the latest in DApp usability and security…and we love them for that.
Without further ado…
🎉 We are proud to announce our Wave 3 Finalists! 🎉
StarkWare – $4M with 6K ETH Performance-based Bounties. Development of standards report and production-quality software for optimized STARK-friendly hash functions and tooling
Force Move Game Framework – $300K. Force move games state channel framework
Harmony – $90K. Minimal sharding and random beacon chain
Kestrel Institute – $400K. Formal verification of cryptographic primitives
ICE Center at ETH Zurich – $185K. ICE Center research and tooling development
Pyramid – $30K. Smart contract language
Developer experience (DevEx grant)
Yakindu IDE – $95K. Eclipse-based IDE
Solidity Resolver Engine – $50K. Universal API tool
Etheratom – $45K. Atomized solidity IDE
Building for the end user (#buidl grant)
DappNode – $250K. Mass full node adoption
Uniswap – $100k. DEX framework
Nethermind – $50K. .NET client implementation
thaEth – $20K. Gnosis Safe UI Design
Cryptoeconomics.study – $35K. Buidling a textbook and coursework
Pseudo-randomly selected committees – $10K. Sharding R&D
Etherlinker – $10K. Unreal Engine 4 API for Ethereum
Scalability will continue to be a focus of EF grants, but we also look to fund other critical work. This includes better UX, new clients, high-level languages, better developer tools, and efforts to make Ethereum applications more secure. With Wave 3, we expanded into education and community efforts in order to help bring new talent into the ecosystem.
Want to #BUIDL with us? See the dev wishlist below and follow links to learn more. If you can imagine a project relating to the topics listed, submit an application and talk to us!
Wishlist for the next grant round
More payment and/or state channel implementations 💚💙💜
More plasma implementations 💚💙
More shasper implementations 🔥
A tokenless “Lightning Network” for Ethereum 💙
WebAssembly R&D 🔥
STARKS R&D 🔥
BLS12-381 implementations in new languages 🔥
libp2p Python implementation 🔥
Improve private key management and transacting in Ethereum 💚💙
Alternative wallet / client designs 💙💜
Standards and portability between wallets 💙
Tooling that improves developer experience 💚💙💜
Improved documentation & developer/user education videos 💚💙💜
Tokenless end user products 💜
More security focused high-level languages 💜
Solidity interpreter 🔥
Non-transferable ID tokens 🔥
Smart contract audits 💚💜
Specifically, audits for ERC20, ERC223, ERC721, multisig wallets, vaults 💜
Tooling that prevents vulnerable code 💚💙💜
IDE with a visual debugger 🔥
You already have a job (or school)? No problem! Suggest a problem you want to solve and we’re happy to fund a 10-week $10K externship for your spare-time working on Ethereum. 💚💙💜(Successful projects will be featured at a developer conference. We are also looking to hire and fund from this pool of side projects. If you’re looking for where to start, look at the list above.)
💚– Wave 1\ 💙– Wave 2\ 💜– Wave 3\ 🔥– New to wishlist
For more inspiration…
Read the original DevGrant post.
Read the post that kicked off the current program.
Grant Ops Contest!
With the growing number of applicants, we’ll be needing to create an official website for the Grants Program. Do you have any ideas on how to make the website fun, transparent, and useful to future grant applicants? (mmhmm) Great! Because we will be running a contest and crowdsourcing ideas from all of you. Selected ideas will receive some unicorn love and some ETH. Stay tuned for details on how to participate!
Solidity Bugfix Release
The latest version 0.4.25 release of Solidity fixes two important bugs. Another important bug has already been fixed in version 0.4.22 but it was only discovered recently that the bug existed.
Note that the Ethereum Foundation runs a bounty program for the code generator part of Solidity.
Cleanup of Exponent in Exponentiation
- Likelihood of occurrence: very low
- Exploitability: high
- Discoverability by tests: low
- Fixed in version: 0.4.25
Summary: Using short types in the exponent of an exponentiation operation can lead to invalid results.
The Solidity language allows integer types that are shorter than 256 bits, even though the Ethereum Virtual Machine only knows types of exactly 256 bits. Because of that, higher order bits need to be set to zero from time to time. For many operations, it is not relevant whether those bits are set to zero or not (addition is one example). Because of that, the Solidity compiler delays this cleanup until it is needed in order to save gas.
In the very special circumstance that the exponent of the
**operator has a type that is shorter than 256 bits, but not shorter than the type of the base and contains dirty higher order bits, this can lead to an incorrect result. Note that literal exponents like in
x ** 2as well as the case where the type of the base is
Note that a function parameter can have dirty higher order bits if called by a malicious entity, and the same is true for data returned from functions of contracts deployed by malicious entities.
After having screened a large number of contracts, we deem this bug to affect only a very tiny number of smart contracts, if any at all, because the regular uses of the exponentiation operator do not lead to the bug.
This bug was found by nweller.
Memory Corruption in Multi-Dimensional Array Decoder
- Likelihood of occurrence: low
- Exploitability: medium
- Discoverability by tests: high
- Introduced in version: 0.1.4
- Fixed in version: 0.4.22
Summary: Calling functions of other contracts that return multi-dimensional fixed-size arrays results in memory corruption.
If Solidity code calls a function that returns a multi-dimensional fixed-size array, the returned ABI-encoded data has to be converted to Solidity’s internal representation of arrays. In Solidity, multi-dimensional arrays are implemented as arrays of memory pointers, while in the ABI, the data is encoded inline. The decoder did not take this difference into account with the result that the returned elements are interpreted as memory pointers and thus can cause memory corruption if the return values are accessed. Calling functions with multi-dimensional fixed-size array arguments is unaffected as is returning fixed-size arrays from function calls if they are not used in a Solidity contract. The bug is only in the component that decodes a multi-dimensional fixed-size array that is returned from a function call from Solidity.
This bug was found by jmahhh.
Invalid Encoding of Structs in Events
- Likelihood of occurrence: low
- Exploitability: low
- Discoverability by tests: high
- Introduced in version: 0.4.17
- Fixed in version: 0.4.25
Summary: Structs as event parameters are not handled properly.
Structs were not meant to be supported as event parameters without the new ABI encoder. The compiler did accept them nevertheless, but encoded their memory address instead of their actual value. Even with the new ABI encoder, structs cannot be
Now, structs are properly disallowed for the old encoder and if they are indexed also for the new encoder.
Ethereum Foundation Grants Update - Wave IV
Greetings from the Ethereum Foundation Grants Team!
As we go full steam ahead to Devcon 4, we’re back to announce Wave 4 of the Grants Program! Thank you to all the fantastic community members that have applied with creative ideas on how to bolster our ecosystem. We would not exist without the time and energy that you put into Ethereum. While the program continues to grow, we will increasingly continue to involve more community members in the decision making process. The Grants Program today is vastly improved from just earlier this year, thanks to all the helpful feedback from the community, allowing us to provide better public tools and infrastructure.
Without further ado…
We are proud to announce our Wave 4 Grantees! 🎉
- Non-Custodial Payment Channel Hub – $420K. Payment upon delivery for the open source SDK release built by Spankchain, Kyokan, and Connext at Devcon 4
- Prototypal – $375K. Front-end state channel research and development.
- Finality Labs – $250K. Development of Forward-Time Locked Contracts (FTLC).
- Kyokan – $125K. Development of production ready mainnet Plasma Cash & Debit plugins.
- Atomic Cross-Chain Transactions – $65K. Research led by Maurice Herlihy of Brown University.
- EthSnarks – $40K. Development of a cross-compatible SDK for zkSNARKS to be viable on Ethereum.
- Flintstones – $120K. Further development of the Flint Language including a security focused IDE by Susan Eisenbach of Imperial College London.
- TrueBlocks – $120K. Open source block explorer.
- Gitcoin – $100K. Funding bounties on Gitcoin.
- VulcanizeDB – $75K. “Community sourced” block explorer.
- Buidler – $50K. Development of modular alternative to Truffle based on Ethers.js.
- Ethdoc – $25K. Open source tool for organization and interaction of smart contract codebases.
- Ethers.js – $25K. Support for ricmoo to continue development and maintenance of Ethers.js.
- Kauri – $25K. Funding documentation bounties on Kauri.
- Magic Money Tree (Dark Crystal) – $50K. Tool for securely storing and recovering keys and secrets through a multisig design by the Secure Scuttlebutt Team.
- Elizabeth Binks – $10K. Ring signature implementation with nine or more keys.
- Lindsey Gray – $10K. Development of C++ BLS-381 implementation.
- Sigma Prime – $150K. Lighthouse Eth 2.0 client in Rust.
- Prysmatic Labs – $500K. Eth 2.0 Prysm client.
- Status – $500K. Eth 2.0 client in Nim.
Want to #BUIDL with us? See the dev wishlist below and follow links to learn more. If you can imagine a project relating to the topics listed, submit an application and talk to us!
- More payment and/or state channel implementations 💚💙💜
- More plasma implementations 💚💙
- Improving efficiency of existing clients such as geth & parity 💚💙
- A tokenless “Lightning Network” for Ethereum 💙
- WebAssembly R&D 🔥
- libp2p Python implementation 🔥
- Plasma Cash implementations for fungible tokens utilizing defragmentation techniques found here and here 🔥
- Academic analysis of Casper 🔥
- Improve private key management and transacting in Ethereum 💚💙💛
- Alternative wallet / client designs 💙💜
- Standards and portability between wallets 💙
- Tooling that improves developer experience 💚💙💜💛
- Improved documentation & developer/user education videos 💚💙💜💛
- Tokenless end user products 💜
- Vyper development 💜
- More security focused high-level languages 💜
- Non-transferable ID tokens 🔥
- Establishing a spec and cross client test suite for the JSON-RPC API 🔥
- Analysis of and analytics for real world Ethereum transactions (application usage, gas / opcode usage, missed avenues for optimization, etc) 🔥
- Tooling that source-verifies contracts client-side, makes use of the metadata hash and shows NatSpec comments to the user for use in wallets 🔥
- Security audits for Vyper 💙💜
- Smart contract audits 💚💜
- Particularly, audits for ERC20, ERC223, ERC721, multisig wallets, vaults 💜
- Tooling that prevents vulnerable code 💚💙💜
- IDE with a visual debugger 🔥
- Privacy Solutions 🔥
- More in-depth network monitoring tools 🔥
- Community groups and conferences for underrepresented and underserved communities 🔥
- Translation of research, documentation, and specs into other languages 🔥
You already have a job (or school)? No problem! Suggest a problem you want to solve and we’re happy to fund a 10-week $10K externship for your spare-time working on Ethereum. 💚💙💜💛(Successful projects will be featured at a developer conference. We are also looking to hire and fund from this pool of side projects. If you’re looking for where to start, look at the list above.)
💚 – Wave I / 💙 – Wave II / 💜 – Wave III / 💛– Wave IV / 🔥 – New to wishlist
For more inspiration…
- Read the original DevGrant post.
- Read the post that kicked off the current program.
- Find the grantees from Wave I, Wave II, and Wave III.
How the Ethereum Foundation grants program makes decisions
Our goal on the grants team is to be faithful stewards of Ethereum community resources. As part of the Ethereum Foundation’s ongoing effort to diffuse power throughout our community, we give grants that we believe will return the highest impact on the Ethereum ecosystem over the long-term.
What is the scope of EF grants?
Funding is only for future work
Avoid playing favorites. We try not to advantage one team over others
Avoid grants at the application layer, though we do believe that projects and teams working at the application layer should apply when they are building open source tools applicable to the wider ecosystem
Avoid giving an Ethereum Foundation “stamp of approval.” EF Grants are not intended to be an endorsement of a particular project over others.
How do we evaluate applications?
We think about highest impact by asking ourselves:
- how important would this be to the ecosystem?
- how urgent is the problem?
- how many other people are working on this problem?
- how much value do we get by giving a grant compared to doing nothing?
We are favorably biased towards projects with reasonable paths towards sustainability. This helps ensure a long-term impact on the investment of community resources.
We look for applicants with relevant experience or proven ability to execute, commensurate with the grant amount
Alignment with Ethereum values
Note: because we are offering non-dilutive capital, we expect to pay a discount on your market rate
We realize that our decision making process will never be perfect, but we always do our best to continually improve the speed and quality of the decision making process.
Posted by Ethereum Team
Ethereum (ETH) Release solidity Version 0.5.1
This release improves the usability of interfaces, fixes some bugs, extends the SMT checker and provides an early preview of the Yul optimizer.
If you want to perform a source build, please only use solidity_0.5.1.tar.gz and not the zip provided by github directly.
- Allow mapping type for parameters and return variables of public and external library functions.
- Allow public functions to override external functions.
- Code generator: Do not perform redundant double cleanup on unsigned integers when loading from calldata.
- Commandline interface: Experimental
--optimizeoption for assembly mode (
- SMTChecker: SMTLib2 queries and responses passed via standard JSON compiler interface.
- SMTChecker: Support
- SMTChecker: Support
- SMTChecker: Support internal bound function calls.
- Yul: Support Yul objects in
- Assembly output: Do not mix in/out jump annotations with arguments.
- Commandline interface: Fix crash when using
--aston empty runtime code.
- Code Generator: Annotate jump from calldata decoder to function as "jump in".
- Code Generator: Fix internal error related to state variables of function type access via base contract name.
- Optimizer: Fix nondeterminism bug related to the boost version and constants representation. The bug only resulted in less optimal but still correct code because the generated routine is always verified to be correct.
- Type Checker: Properly detect different return types when overriding an external interface function with a public contract function.
- Type Checker: Disallow struct return types for getters of public state variables unless the new ABI encoder is active.
- Type Checker: Fix internal compiler error when a field of a struct used as a parameter in a function type has a non-existent type.
- Type Checker: Disallow functions
suicidealso without a function call.
- Type Checker: Fix internal compiler error with
superwhen base contract function is not implemented.
- Type Checker: Fixed internal error when trying to create abstract contract in some cases.
- Type Checker: Fixed internal error related to double declaration of events.
- Type Checker: Disallow inline arrays of mapping type.
- Type Checker: Consider abstract function to be implemented by public state variable.
- CMake: LLL is not built anymore by default. Must configure it with CMake as
- Docker: Includes both Scratch and Alpine images.
- Emscripten: Upgrade to Emscripten SDK 1.37.21 and boost 1.67.
- Fix handling of standard-json in the commandline executable.
- Remove support of nodejs 4.
We especially thank all the contributors that made this release possible:
Albert, Alex Beregszaszi, Anurag Dashputre, Chris Purta, Christian Parpart, Chris Ward, Daniel Kirchner, David Lozano Jarque, Erik Kundt, hydai, Javier Tarazaga, Justin Wilson, Lazaridis, Leonardo Alt, liangdzou, mordax, Robert Chung, William Entriken, Yet another codejunkie
Ethereum (ETH) Weekly News Updates
News and Links
- [Eth 1] Notes from the call on improving the current Ethereum chain
- [Eth 2] The latest What’s New in Eth2
- [Eth 2] Notes from latest Eth2 implementers call
- [Eth 2] Nimbus dev update
- [Eth 2] Eric Conner’s Eth2.0 economic primer
- [Eth 2] Vitalik: layer 2 computing model using optimistic state rootsELI5 version. Big if it works.
- [CBC Casper] Latest Casper standup call
- [CBC Casper] CBC Casper explanation by Vitalik
- Latest state channels call
- Explainer video for Raiden Network
- Minimum number of rounds required for plasma cash with rearrangeable transactions
Stuff for developers
- Solidity v0.5.1 “improves the usability of interfaces, fixes some bugs, extends the SMT checker and provides an early preview of the Yul optimizer”
- Embark 4.0.0-alpha.2
- web3j v4 out of alpha and in general relelase
- Rocketh test library with any web3 library and test runner
- Aragon: cheaper voting through EVM storage proofs
- dappboard: load chain data into PostgreSQL to analyze
- Securify academic paper
- An IPFS for devs explainer from Piñata
- a URL shortener live on Ropsten
- Using the iExec SDK
- How to use Quiknode to quickly start a dedicated node
- 0x Instant react.js component
- RuntimeVerification formally verifies the beacon chain in COQ and models RanDAO
- ConsenSys reorg from 1.0 to 2.013% layoffs.
- Alethio’s block explorerlinked data graph
- Curious Giraffe has some nice dapp analytics for Compound, Augur, ENS, etheroll, Kyber, AirSwap, and Cryptokitties.
- In 2019, Gnosis will give away up to 600k USD to build on Gnosis products through its ecosystem fund
- A list of Ethereum community calls from Trenton Van Epps
- More on AZTEC Protocol’s confidential transactions. Plus costs would go down to 200-300k gas with eip1108
Live on mainnet
- Gnosis’ slow.trade is live on mainnet; it builds on the DutchX protocol by Gnosis
- Havven launches stablecoins for EUR, JPY, AUD, KRW, and gold.
- FOAM Signaling live on mainnet
- SignatureBank to offer commercial clients 24/7 money transfer for free using a private Ethereum chain
Governance and Standards
- Latest core devs callnotes. Fork will be around Jan 16th. Working group updates. Dropping Ropsten/PoW testnets forever?
- ERC1633: Refungible token standard
- ERC1638: Gift vault standard
- 0x Instantideas to explore with 0x.
- dy/dx’s Antonio Juliano tweetstorm on state of 0x
- Cyrus Younessi’s overview of Uniswap Exchange
- A new and slick version of Maker Tools
- Status v0.9.32 with private group chats
- Funfair product update
- Imbrex open sources its real estate data exchange called Tegula
- OpenLaw and Rhombus build onchain derivatives
- 3Box spins out from uPort
- Livepeer’s Streamflow upgrade proposal with probabilistic micropayments
Interviews, Podcasts, Videos, Talks
- AZTEC Protocol’s Zach Williamson on Smartest Contract
- Video of local news report on Blockchains LLC fiber optic ring
- Curation markets community call
- John Lilic video interview
- Intro to Scaling on Into the Ether
- Numerai/Erasure’s Richard Craib AMA
Tokens / Business / Regulation
- Richard Craib on redesigning Numerai. Cutting supply by half, making it more useful with Erasure, and decentalizing it.
- Bonded curves for charity
- Brian Armstrong: adoption of cryptoassets will come through VR
- Video of NYT’s Sorkin interviews SEC Chairman Clayton
- Zaki Manian’s Cosmos and Polkadot comparison
- NEAR’s Alex Skidanov: Core ideas in blockchain sharding
- Update on ETC<>ETH peace relay
- Coinbase filed to trademark buidl, though Balaji pledges it will only be defensive.
Dates of Note
Upcoming dates of note (new in bold):
- Dec 9 - Neufund equity token offering (closes after a week)
- Jan 10 - Mobi Grand Challenge hackathon ends
- Jan ~16 - Constantinople hard fork at block 7080000
- Jan 29-30 - AraCon (Berlin)
- Feb 7-8 - Melonport’s M1 conf (Zug)
- Feb 15-17 - ETHDenver hackathon (ETHGlobal) next hacker application round closes December 31st
- Feb 23-25 - EthAustin hackathon (EthUniversal)
- Mar 5-7 - EthCC (Paris)
- Mar 27 - Infura end of legacy key support (Jan 23 begins Project ID prioritization)
If you appreciate this newsletter, thank ConsenSys
This newsletter is made possible by ConsenSys.
I own Week In Ethereum. Editorial control has always been 100% me. If you’re unhappy with editorial decisions or anything that I have written in this issue, feel free to tweet at me. [Although I can’t answer right now to due to censorship, see below.]
Capricious Twitter censorship
One of my best friends launched StoopAndroid/iOS newsletter reader. It uses a dedicated email and clean design experience to keep your information diet healthy. If you subscribe to newsletters, you will like it.
For reasons unknown, Twitter has locked my @evan_van_nessMailchimp arbitrarily banned me earlier this year, it’s sad to see web2.0 platforms making the case for their own demise. Web3 can’t come fast enough.
I’m sure that I missed things for this newsletter due to Twitter’s banhammer. Sorry!
Due to Twitter censorship, I won’t be able to tweet this link: http://www.weekinethereum.com/...
If you’re wondering “why didn’t my post make it into Week in Ethereum?”
Did you get forwarded this newsletter? Sign up to receive the weekly email
Ethereum Constantinople Upgrade Announcement
The Ethereum network will be undergoing a scheduled upgrade at block number 7,080,000, which is predicted to occur on Wednesday, January 16, 2019. The exact date is subject to change depending on block times between now and then and could be activated 1-2 days before or after. A countdown timer can be seen at https://amberdata.io/blocks/7080000. You can monitor the network upgrade in real time at http://forkmon.ethdevops.io/
What is Constantinople?
As an Ethereum user or ether holder is there anything I need to do?
If you use an exchange (such as Coinbase, Kraken, or Binance), a web wallet service (such as Metamask, MyCrypto, or MyEtherWallet), a mobile wallet service (such as Coinbase Wallet, Status.im, or Trust Wallet), or a hardware wallet (such as Ledger, Trezor, or KeepKey) you do not need to do anything unless you are informed to take additional steps by your exchange or wallet service.
As a node operator or miner, what do I need to do?
Download the latest version of your Ethereum client:
What happens if I am a miner or node operator and I do not participate in the upgrade?
If you are using an Ethereum client that is not updated to the latest version (listed above), your client will sync to the pre-fork blockchain once the upgrade occurs. You will be stuck on an incompatible chain following the old rules and you will be unable to send ether or operate on the post-upgrade Ethereum network.
What is a network upgrade in Ethereum-land?
A network upgrade is a change to the underlying Ethereum protocol, creating new rules to improve the system. The decentralized nature of blockchain systems makes a network upgrade more difficult. Network upgrades in a blockchain require cooperation and communication with the community, as well as with the developers of the various Ethereum clients in order for the transition to go smoothly.
What happens during a network upgrade?
After the community comes to an agreement concerning which changes should be included in the upgrade, changes to the protocol are written into the various Ethereum clients, such as geth, Parity, and Harmony. The protocol changes are activated at a specific block number. Any nodes that have not been upgraded to the new ruleset will be abandoned on the old chain where the previous rules continue to exist.
What changes are going into Constantinople?
Changes that are implemented in Constantinople are defined using EIPs. Ethereum Improvement Proposals (EIPs) describe standards for the Ethereum platform, including core protocol specifications, client APIs, and contract standards. The following EIPs will be implemented in Constantinople.
Provides native bitwise shifting with cost on par with other arithmetic operations.
EVM is lacking bitwise shifting operators, but supports other logical and arithmetic operators. Shift operations can be implemented via arithmetic operators, but that has a higher cost and requires more processing time. Implementing SHL and SHR using arithmetics cost each 35 gas, while these proposed instructions take 3 gas.
In short: This EIP adds native functionality to protocol so that it is cheaper & easier to do certain things on chain.
Adds a new opcode at 0xf5, which takes 4 stack arguments: endowment, memory_start, memory_length, salt. Behaves identically to CREATE, except using keccak256( 0xff ++ sender_address ++ salt ++ keccak256(init_code)))[12:] instead of keccak256(RLP(sender_address, nonce))[12:] as the address where the contract is initialized at.
This allows interactions to be made with addresses that do not exist yet on-chain but can be relied on to only possibly contain code eventually that has been created by a particular piece of init code.
Important for state-channel use cases that involve counterfactual interactions with contracts.
In short: This EIP makes it so you can interact with addresses that have yet to be created.
This EIP specifies a new opcode, which returns the keccak256 hash of a contract’s code.
Many contracts need to perform checks on a contract’s bytecode, but do not necessarily need the bytecode itself. For instance, a contract may want to check if another contract’s bytecode is one of a set of permitted implementations, or it may perform analyses on code and whitelist any contract with matching bytecode if the analysis passes.
Contracts can presently do this using the EXTCODECOPY opcode, but this is expensive, especially for large contracts, in cases where only the hash is required. As a result, a new opcode is being implemented called EXTCODEHASH which returns the keccak256 hash of a contract’s bytecode.
In short: This EIP makes it cheaper (less gas is needed) to do certain things on chain.
This EIP proposes net gas metering changes for SSTORE opcode, enabling new usages for contract storage, and reducing excessive gas costs where it doesn’t match how most implementation works.
In short: This EIP makes it cheaper (less gas is needed) to do certain things on chain, especially things that are currently “excessively” expensive.
The average block times are increasing due to the difficulty bomb (also known as the “ice age”) slowly accelerating. This EIP proposes to delay the difficulty bomb for approximately 12 months and to reduce the block rewards to adjust for the ice age delay.
In short: This EIP make sure we don’t freeze the blockchain before proof of stake is ready & implemented.
The Year in Ethereum
We started with a slightly smaller experiment: was it possible to launch a blockchain that could execute arbitrary programs? Over time, the Ethereum community began new experiments. Would developers find it interesting? What applications are actually useful? The community learned from its successes and failures, and iterated on their work. New people joined the community and started running their own experiments.
In 2018, the Ethereum community ran more experiments than ever before. What did we learn? This summary of the year in Ethereum is our attempt to identify the most important developments — the things that we’ll say mattered, 10 years out.
These developments took place at every level of the Ethereum “stack”. This includes the core protocol and the clients that implement it, commonly referred to as “Layer 1”. It includes the supporting developer tools & infrastructure, that make engineering on Ethereum possible. It includes “off chain” technologies, that let developers build fast and performant applications. And it includes the products and businesses built on Ethereum.
Keeping track of everything in this ecosystem is becoming more and more difficult every week. There are competing implementations of many infrastructure technologies — including two clients with ~50% (Geth) and ~40% (Parity) of the network. There are multiple competing off-chain technology stacks being built, multiple ETH 2.0 clients under development, and most markets have multiple competing businesses. It feels messy and chaotic — the Ethereum ecosystem is a bazaar, not a cathedral. While this can make it hard to follow, it’s a credit to the community: we’re too big to measure with simple tools.
Our goal is to help you sort through that noise and see the bigger picture. In our view, here are the most important developments in 2018:
- 1. More people started using Ethereum, for more things — but we’re still far from mass adoption.
- 2. Decentralized Finance (DeFi) and stablecoins — a new class of applications that saw many product launches and some breakout successes.
- 3. The year of #BUIDL — it became radically easier to build applications on Ethereum. Our development and security tooling improved significantly, we got better at sharing best practices, and hackathons became a trend.
- 4. Layer 2 scaling — multiple “layer 2” applications launched, and we made critical progress towards making these scaling solutions easy to use for developers.
- 5. Zero knowledge technology — this year it felt like every technical conversation in Ethereum was “We can do it this way right now, but of course once we have good zkSTARKs…”
- 6. ETH 2.0 / Serenity — the roadmap solidified, and it moved from a research project to an engineering effort.
This graph shows the utilization of the Ethereum blockchain at different points in time. Specifically, it is a measure of the total gas used divided by the gas limit. When the line approaches 1, it means the Ethereum blockchain is being used at nearly 100% capacity.
Yes, the graph above is encouraging — people are paying to use the Ethereum blockchain. But it means we started asking harder questions: we’re near 100% capacity even with such a small user base? What would happen to fees if we on-boarded millions of users, when the total capacity of the network is so low? How many people actually use Ethereum? What are they using it for? And what are the right metrics to measure growth?
Measuring “use” of Ethereum isn’t easy. For instance, we can get a basic picture using raw on-chain statistics, like the number of transactions on the network:Source: https://etherscan.io/chart/tx
But this doesn’t tell the whole story. If Ethereum was being used near full capacity, how can the number of transactions be declining? The composition of transactions on Ethereum shifted from a large number of simple ones, to a smaller number of complex ones. For instance, token transfers (~50K gas) or opening up a MakerDAO CDP (up to 900K gas) both “take up” more of the network’s capacity than a simple ETH transfer (21K gas).
As Ethereum’s app layer continues to grow, we should expect the transaction count to decline while the chain operates at full capacity. And as more activity moves into side chains, state channels, or plasma chains (see Layer 2), measuring on-chain transactions increasingly only tell part of the story.
What are people using the network for?
Many significant and long-awaited applications went live in 2018, and appear to be attracting users.
Users of MakerDAO have locked more than 1.7% of all ether into smart-contracts that serve as collateral for the Dai stablecoin. As of December 31st, the value of that ether was over $275 million. We discuss MakerDAO, and other “decentralized finance” applications, in detail in the next section.
Augur, a decentralized prediction market under development since 2015, launched in July 2018 and has seen open interest (the amount of value currently “bet” on the system) grow to a high over over $2.96m in November 2018. However, the total number of users has remained low.
Many more applications launched in 2018, including many in the “decentralized finance” category (see next section). Many others were games like Gods Unchained (beta, November 2018), or gambling services like FunFair (mainnet, September 2018). There are hundreds of other applications that use the Ethereum blockchain, which you can find listed here or here.
Overall, consumer use of applications on Ethereum remains low. When we use measurements like daily active users who interact with a dapp’s smart-contract on the blockchain, we see an average of between 10,000–15,000 users on any given day in 2018.
However, note that this is a measurement of on-chain transactions and does not include, for example, someone opening an app and browsing their collectibles, or opening Veil (alpha, September 2018, mainnet January 15 2019) to view their open predictions on Augur.
User adoption of new technology moves in phases. Users come to applications, creating demand for better infrastructure, and applications then build on that infrastructure to meet the expectations of users. We can analogize from web development that there is a reinforcing loop of app and infrastructure development.
By the end of 2017, we had learned that there was demand from people who wanted to build applications on Ethereum. In 2018, the community shipped apps that were useful without scaling upgrades, and built infrastructure that will make it possible for the next wave of applications to work at a larger scale.
What should we be measuring, anyways?
Is “daily active on-chain transactions” the right measurement to quantify user adoption? This year, people started thinking (and tweeting) about what metrics we should use to gauge Ethereum’s success.
The answer, surely, is that it depends on what counts as success. Some businesses require large numbers of users (like consumer apps or games), while others seek high volumes of value (like some financial services).
As layer 2 scaling technologies are adopted, more user activity will move “off-chain” where it is more difficult to measure. This already influences the data used to measure Ethereum’s adoption. For instance, DappRadar does not currently include statistics on games that use Loom’s Dappchains, nor does it list activity in Spankchain’s payment channels.
But this isn’t a bug, it’s a feature. We want to build web 3 — an internet that, among other things, respects user’s privacy instead of spying on them. That means giving users the option to keep their business to themselves, off-chain, where it isn’t easy to measure and incorporate into statistics.Source: https://mikemcdonald.github.io/eth-defi/
The above graph hides MakerDAO by default, in order to let us see other applications. If we include MakerDAO, the graph looks like this:
The most successful DeFi protocol — and the most successful application on Ethereum in 2018 — is MakerDAO.
Over the last year Dai survived a 94% fall in the value of its underlying collateral. The system was battle-tested in the first few months of its launch, and appears to have functioned as intended. It has quickly became a core piece of infrastructure for many Ethereum applications.
Within the community of people that actually use Ethereum apps on a regular basis, it’s hard to overstate the impact of having an easy to use, decentralized stablecoin. If you work in this ecosystem, you will remember that 12 months ago you probably sometimes paid, and were paid, in ETH. Today, everyone uses Dai — for contract payments, for event sponsorships, for petty cash.
MakerDAO is not just Dai, though that is the most outward-facing product. It also includes a system of “Collateralized Debt Positions” (CDPs), which allows anyone to lock up ETH as collateral and receive a “loan” in DAI. This system facilitates the collateral backing that makes Dai possible, while also being a lending product in its own right that can be used for, among other things, leveraged trading.
Dai is not the only stablecoin built on Ethereum — though it is the only one of significant size that is “decentralized” in the sense that it is backed by digital assets in an automated collateral system, rather than off-chain assets like dollars held in fiat bank accounts. Other Ethereum-based stablecoins include TrueUSD (mainnet March 2018), Paxos (mainnet October 2018), Gemini Dollar (mainnet October 2018), USD Coin (mainnet October 2018), and sUSD (mainnet June 2018).
Collectively, all stablecoins built on Ethereum had a marketcap of ~770 million at the end of the year, large enough that as a group they would have ranked as the 14th largest cryptocurrency on Dec 31.https://stablecoinindex.com
In the last 10 days of 2018, these stablecoins had an average daily trading volume of ~$200 million.https://stablecoinindex.com
While significant and growing, this volume is still dwarfed by trading volume in Tether, which during the same period saw a daily average of around $5 billion USD.
Within the broader category of DeFi, decentralized exchanges (DEXs) are the next most significant. In 2018, this ecosystem grew and matured. There are not just multiple competing DEXs, but multiple types of DEXs now live in production. However, volume remains low compared to any centralized exchange.
There are now several DEXs that use the 0x protocol. Radar Relay launched their beta in August 2017, raised a series A in July 2018, and released v2 of their product a few months ago in September. Paradex launched October 2017, and was acquired by Coinbase in May 2018. DDEX launched their open beta on January 9 2018, became the leading 0x relayer by volume, and recently announced that they are forking the 0x protocol to create a competing protocol called Hydro.
This year saw an expansion of the type of DEXs built on Ethereum. Kyber, which launched in March 2018, does away with the order book and simply lets users receive a quote, and instantly swap one asset for another. Airswap, which launched in April 2018, similarly provides a simple “token swap” service. Uniswap, which implements a novel automated market-making feature inspired by a reddit post from a few years back, launched in November 2018. It operates entirely on-chain, and makes markets itself using a deterministic algorithm. Gnosis’ DutchX protocol went live on mainnet in October 2018, with a user-interface to the protocol called slow.trade that went live in December. StarkWare started working on zero-knowledge technology that will help scale DEXs and is expecting to launch on testnet in Q1 2019.
Why did DeFi take off in 2018? One reason is that many of these applications are useful today, even before critical scaling technologies are in place. Basic financial use-cases like lending and borrowing do not require high transaction throughput — they simply require a secure programmable base layer blockchain. Ethereum’s simplest use-case is the creation, exchange, and use of digital assets like ETH. One way of looking at DeFi is that it is simply building the basic financial infrastructure to use those digital assets.
Year In Ethereum Cont. from last page
Developer tools & frameworks
In 2018 developer tooling continued to improve. It’s still not easy to build on Ethereum, and there’s a long way to go — but it’s much better than it was in December 2017.
One notable trend is that we saw alternatives and competitors to popular tools start to emerge. In 2018 ethers.js saw wider adoption as a web3.js alternative, blockscout launched as an open-source alternative to etherscan, the new Goerli testnet launched, and several Truffle competitors emerged like embark, etherlime (based on ethers.js), and buidler.Truffle monthly downloads since 2015 (https://www.truffleframework.com/dashboard)
Vyper — a security-oriented development language that serves as an alternative to solidity — saw significant progress in 2018. In 2017 it was not production ready and still not that easy to get started with it. Today it is being used in production by Uniswap.
We also made progress on important patterns and development frameworks for smart-contracts, like the Proxy Upgrade pattern maintained by Open Zeppelin which is widely used across the ecosystem. Aragon, a framework for creating Decentralized Autonomous Organizations (DAOs) launched on mainnet this year.Open Zeppelin weekly downloads since 2016
At the end of 2017, security tooling & best practices were on everyone’s mind. Multiple high profile hacks and security failures forced the Ethereum community to improve best practices, and invest more resources in security audits and tooling.
In 2018, the Ethereum security community improved. New security tools became available that made it easier to build secure applications. Trail of Bits released several tools in March 2018 (who also maintain a useful list of resources here), including static analysis tools, fuzzing tools, and more. Securify, an automated security scanner for Ethereum smart contracts, was released in July 2018. Mythril, a security analysis tool initially released in 2017, became a platform and re-branded to MythX.
The Ethereum security community made progress towards “best practices”, though the community doesn’t always agree on all of them. Valuable resources like the Smart Contract Weakness registry helped the industry share best practices and common anti-patterns. Notable “traditional” security researchers began working in the Ethereum space, including Trail of Bits and Sigma Prime, adding to the stable of high-quality auditing firms already working in the space.
Despite this progress, there’s still significant work required. In particular better formal verification frameworks and tooling, which is a consistent complaint from developers building on Ethereum.
Ethereum’s primary clients — Geth and Parity — continued to be improved and refined, thanks to essential work by their development teams. New clients were released, like Pantheon in Java and Nethermind in .NET Core.
There has long been an understanding that Ethereum needs to diversify the node infrastructure available to application developers. This market has long been dominated by Infura, but in 2018 many teams began working on alternatives.
Dappnode, a project to make it cheap & easy to run a personal Ethereum node, launched in July (you can even buy a pre-configured one). VIP node, a service that allows users to “subscribe” to node access thereby creating an incentive for more full nodes, went live this year. Denode, a project that similarly seeks to provide market incentives for more decentralized node infrastructure, received a grant from the Ethereum Foundation in September. Other projects — like LightJS by Parity, released in November — make it easier for developers to build dapps that don’t need to rely on full nodes.
Decentralized storage solutions like IPFS and Swarm continued to make progress. Swarm POC3 was released in June, and now includes a messaging layer. The Ethereum Name Service (ENS), a decentralized service that lets people use human-readable names (like alice.eth) in place of Ethereum addresses, launched a mainnet integration with the .xyz domain registry (September 2018), and announced a planned integration with .luxe.
Developer collaboration across the ecosystem improved
The global community of Ethereum researchers & developers got better at working with each other in 2018. The primary forum for cryptoeconomic research on Ethereum — ethresear.ch — only launched in August 2017, and was not widely used until early 2018. Today it is the de-facto R&D hub for Ethereum, and an essential technical resource for everything from plasma to sharding.
The very first Plasma researcher’s call didn’t happen until January 2018, and the first state channels researcher calls weren’t until August 2018. There are now many public calls related to Ethereum development, ranging from core development of the protocol, to layer 2 tech, to individual areas like curation markets or product management.
The ETHSecurity community formed in mid 2018 to try and share best practices and shared learnings. The fellowship of Ethereum magicians — a community of Ethereum developers aimed at producing better EIPs and improving Ethereum’s technical maintenance — launched in early 2018.
Gitcoin, a project that facilitates bounties for open-source development, launched their pilot in November 2017. In 2018, their platform was used to pay out ~$500,000 in bounties and grants to more than 700 developers.
Hackathons became a big deal
In October 2017 ETHWaterloo set a record as the largest Ethereum hackathon ever, which was quickly beaten by ETHDenver in February 2018. Over the rest of the year, there were 6 more ETHGlobal hackathons that served more than 5,800 developers, as well as other events like ETHMemphis and two hackathons held by Status.
In 2018 it was finally practical to run an Ethereum hackathon — there were enough developers who wanted to learn how to build on this tech, the ecosystem was varied enough that they had many interesting projects to work on, and the tools were mature enough that it was actually feasible to build a working demo in 36 hours. Many of the individual projects mentioned above — including the Goerli testnet, Set protocol, Denode, and Cryptokitties were conceived or launched at ETHGlobal events.
State & Payment Channels
State channels are the most basic layer 2 technique. At the start of 2018, there were several custom-built channels applications still under development. Today, many of those projects have launched to main-chain, and critical infrastructure has been built that will soon radically shorten the development cycle for channelized solutions.
Spankchain (micropayments through payment channels) launched their beta in April, and have been live in production ever since. Funfair (casino games running in state channels) launched to mainnet in September. Connext (payment channel hubs for micropayments) launched their first non-custodial hub on mainnet in September in collaboration with Spankchain. Celer Network (a state channel network & liquidity solution) launched their testnet & demo apps in October. Raiden, the long-anticipated ERC20 payment channel network, launched their alpha release running live on mainnet in December.
The number of live projects using channels will only increase as the technology becomes easier for developers to use. Counterfactual (a framework that makes it easier to build a channelized application) published their work on generalized state channels in June, open-sourced all their code in November, and is launching a full demo environment in January 2019. Magmo, a framework for a specific subset of channelizable applications (“force move games”) using state channels, released a demo application at DevconIV.
Plasma is a scaling technique where operations are moved off-chain into a secondary blockchain, where they can be performed faster and at lower cost.
The idea is based on “sidechains”, originally a proposal to scale bitcoin dating back to 2014. Plasma introduced a novel improvement: unlike on a sidechain, a user of a Plasma chain would always have a guarantee that they can withdraw their assets to main-chain, even if the operator of that Plasma chain tried to censor or steal from them.
Plasma research has made large strides since the paper release in August 2017, though the technology remains further from production than state channels. The year began with only a few teams actively working on Plasma, as the research community began to explore various tradeoff and design choices within a family of related techniques derived from the original paper.
The majority of these designs have focused on the simplest use case: payments. These designs include Plasma MVP (introduced by Vitalik in January 2018) and Plasma Cash (introduced by Vitalik & Karl in March, and the subject of continuing formal work). More recently, researchers have begun exploring zero-knowledge-proof based Plasma-like designs like the “Rollup” (introduced by Barry Whitehat in September).
Each of these can be augmented to mitigate their shortcomings, while minimizing tradeoffs. This unfortunately resulted in a “naming meme”, where each new tweak on an existing design was given a unique name, leading to significant confusion for anyone not deeply involved in the research community. Useful taxonomies that divide up the design space are a work in progress.
At the same time, research continued into expanding Plasma beyond payments. While this work continues, current consensus among researchers is that an optimized “full EVM” plasma (which could run any smart contract) is a complex challenge.
This broad exploration of a large design space has been productive for researchers, but practical implementations are still mostly theoretical or in early stages. One exception is the Plasma Cash implementation built by Loom, released in June 2018.
Thanks to Georgios Konstantopoulos, Jeff Coleman, Spencer Noon, Alex Wade, Xuanji Li, Danny Ryan, Heather Davidson, Gregor Zavcer, Mike McDonald, Corey Petty, Ameen Soleimani, Jens Frid, and others who took time to answer questions and contribute to the creation of this article.
[LIVE] Ethereum Core Devs Meeting #53 [2019-01-18]
Ethereum 2.0 Development Update #20 — Prysmatic Labs
Building Ethereum 2.0 client at Prysmatic Labs @Prylabs
Our biweekly updates written by the entire Prysmatic Labs team on the Ethereum 2.0 Serenity roadmap
Phase 0 Validator Client Responsibilities
Now that many of the client implementation teams are working on the validator clients, Danny Ryan from Ethereum Research has put together a preliminary document to outline the role of an honest validator. The document covers the workflow from joining the validator pool to proposing and attesting to new Ethereum 2.0 blocks. Here’s a brief summary of the information:
Becoming a validator involves:
- Generating a BLS public key used for signing as a validator
- Generating BLS withdrawal key, a “cold storage” key used for withdrawals
- Creating a RANDAO commitment used in block proposals
- Creating custody commitment used for proof of custody in phase 1+ (we are still on phase 0)
- Sending a 32 ETH deposit to the deposit contract on the ETH 1.x chain with the validator initialization parameters
After some amount of time has passed (defined as ENTRY_EXIT_DELAY ~= 25.6 minutes), a validator is active in the ETH 2.0 system and will be assigned slots to act as a proposer or attestor.
Validator beacon block proposals are expected to happen at the beginning of any assignment slot. The validator applies the fork choice rule to select the parent block as the head of the chain then creates a block with the following information:
Beacon block header:
- Slot number
- Parent root, the hash of the parent block)
- State root, the hash of the resulting state of parent -> block state transition
- RANDAO reveal, a data as part of the validators commitment
- Deposit root, the most recent root found in the ETH 1.x deposit contract.
- Signature, the validators signature on the block
Beacon block body:
- Proposer slashings, slashings to apply when a validator proposes two or more conflicting blocks for the same slot
- Casper slashings, slashings to apply when a validator casts two or more conflicting votes in the same slot
- Attestations, any attestations that have not been included yet from slots within the current epoch or the previous epoch
- Deposits, deposit logs from the ETH 1.x deposit contract to be processed
- Exits, validators that initiated the withdraw process in this slot
When selected to attest to beacon blocks, the validator should wait until halfway through their assigned slot to construct their attestation.
- Slot number
- Shard number
- Beacon block root, the hash of the head block of the beacon chain
- Epoch boundary root, the hash of the block at the most recent epoch boundary
- Shard block root, the hash of the head block of the shard chain
- Latest crosslink root, the hash of the most recent crosslink
- Justified slot, the slot number of last justified slot
- Justified block root, the hash of block in justified slot
The validator will construct the attestation with the above data with their signature, custody bitfield (in phase 1), and the participation bitfield.
So far the current specification outlines the responsibilities for validator assignment on the beacon chain. Assignments on shard chains will differ and their definitions solidify in future phases.
Merged Code, Pull Requests, and Issues
State Transition Block Processing E2E Testing Complete
We now have the ability to fully test out block processing state transitions for the beacon chain by using a YAML format configuration! This means anyone can write up a test that specifies block events happening throughout state transitions a final state based on the results of these transitions. For example, we have created a sample yaml test here for testing a basic workflow of validators being added through deposits, validators voluntarily exiting the set, and validators getting penalized throughout an epoch:
The code above can trigger deposits happening at certain slots and checking the size of the validator set increased. We can also check if applying valid penalties at certain slots penalized certain validators. We believe this format will be increasingly useful as the beacon chain evolves and more complex scenarios can be modeled. As we integrate epoch processing tests soon, we will be able to test for Casper FFG finality and more granular Proof of Stake details.
State Transition Epoch Processing Integration Complete
We recently finished integrating the entire epoch processing pipeline as defined in the specification into our state transition function. This marks a milestone of completely wrapping up the state transition function for Ethereum Serenity Phase 0 within the Prysm repo. The epoch processing consists of processing various beacon state and validator structure fields. After the last slot of the epoch, the beacon node will proceed to update validator balances, justify and finalize checkpoints, and cross linking shard checkpoints back to beacon chain. The reason we don’t want to process those fields for every slot because they are computational intensive hence we only want to do it once at the end of the epoch.
Implementing Deposit Listener For the Validator Deposit Contract
The validator deposit contract is the main bridge between the ETH 1.0 PoW chain and the beacon-chain. Future validators will deposit 32 ETH into the deposit contract and the beacon node will listen to Deposit Contract for the logs emitted. Using these emitted logs we can ascertain which validator has deposited on the POW chain then add them to the validator registry on the beacon-chain. Block proposal mechanism by the validator client also requires validator client to be aware of the most recent receipt root in the deposit contract, which would mean that this cached deposit trie would have to be constantly updated till the time comes for a validator to propose. This has been implemented in this PR.
Implementer Validator Deposits Trie
Validator deposits for Ethereum Serenity will happen through a smart contract on the PoW chain. Users who currently hold Ether and wish to become validators will deposit Ether into the contract, and the deposit data will be kept within a Merkle trie in the contract’s state for easy generation of Merkle proofs and verification once such validator runs a beacon node. Although the contract contains useful utilities to fetch Merkle branches on the fly, we also believe it will be useful for nodes to keep track of a cached local trie to participate in the voting period of deposit roots. We have implemented a simple Merkle trie in Go that matches the tracking deposits in the PoW deposit contract. This trie can be stored in persistent storage in the Prysm node and can be used by other runtime services in Prysm for deposit verification.
See more in the PR here.
GHOST Fork-Choice Rule for the Ethereum Beacon Chain
The fork-choice rule for Ethereum Serenity is officially called Latest Message Driven, GHOST (Greediest Heaviest Observed Sub-Tree). It is based on combining details of Proof of Stake finality and justification into selecting the next fork in the chain. At its core, it is a block-vote weighted function that relies on the “latest” attestation messages seen by the active validator registry, treating those latest messages as votes to cast decisions on a potential beacon chain head.
Python code for LMD GHOST can be seen: https://gist.github.com/terenc3t/417454395d48d1fbdd85770fab86b9c4
Naive GHOST is known to be quite slow, as it performs many nested looping operations to determine the correct head. Our most naive implementation runs at around 800ms for 100,000 active validators in the state to select the next beacon block head. There is, however, a whole suite of LMD GHOST optimizations that we believe can improve its efficiency more than 10x, including the way we store votes for blocks, how we compute ancestor blocks for vote checking, and how we iterate to determine the best child. Our aim is to reach 25–50ms for GHOST with 100,000 active validators through the next few PRs, with some ideas already implemented by Vitalik in the Ethereum Research repository here.
Full End-to-End Testing of Beacon Chain With Validator Deposits
Currently, we allow users to run a local demo of Prysm which simulates a real runtime by having an initial validator set and a simulator of beacon blocks being published to the beacon node. The problem with this demo is it is not quite realistic, as it does not truly model validator behavior. It also does not model how the chain or node will evolve at scale and only serves the purpose of being a visualization for a basic runtime with validator shuffling.
Instead, we want to allow users to run a full end-to-end test of a beacon chain in a way that allows for better understanding of what is happening underneath the hood, with the ability to simulate more real scenarios in which byzantine actors can exist. We will now be deprecating our beacon block simulator in favor of end-to-end YAML tests, as they will give us more confidence our system will work as part of a cluster of nodes in a test net rather than a simple, local simulation. As such, we will be leveraging our YAML test suite to attempt the following:
- Simulate a validator deposit contract being deployed on a PoW chain
- Simulate incoming deposits into the contract
- Begin the beacon chain once the deposit threshold is reached
- Perform N state transitions, with events being simulated at random slots within the simulation
- Display the user the result on the state, validator registry, and latest block information based on the progression of the N transitions
This will give us high confidence our runtime is effective, especially if we leverage the real function used by the runtime itself.
Deprecating Our Solidity Contract to Vyper
Our Validator Deposit Contract was written in Solidity whereas the official contract in the spec is written in Vyper. We made the decision to follow the spec as close as possible so as to deprecate the solidity contract for one written in Vyper. This came about as testing on Deposit and ChainStart logs gave different results from what we were expecting due to minor changes between our contract and the Vyper contract.
Creating the Beacon Chain’s Transactions Pool
The expectation of a full validator node is to track latest attestation vote from each validator. If that node was only listening for blocks, then that would be their sole source of this information. The expectation of a validator is to run a node that is listening for attestations on the wire as well as those from blocks. The default behavior of a full node should be to support listening to attestations on the wire and reacting to this information, if it’s not supported then it can not be used by a validator. Receiving a block is a trigger for fork choice calculations so is receiving new attestations outside of a block. In design, the beacon node needs an attestation pool to track each validator’s attestation and use those data to apply fork choice. We started off with a mapping of public key to attestation data and found deficiency where we could just use mapping of participation bitfield to attestation data. The later mapping avoids duplication because in an optimal case, most validators in a committee should point to the same attestation data.
Refactor Validator Client
As much of the beacon chain specification as settled down, we can return to work on the Prysm validator client. We had deferred work in this area while we update the beacon chain node to match much of the fast-moving changes and, as a result, the validator client has decayed slightly. We also think our implementation can be less fragmented into a simple routine: validator waits for assignment slot, then performs the role.
Validator Client Private Key Management and Other Secrets
It is critical for a validator client to keep safe control of a variety of secrets, including a RANDAO reveal, a BLS private key, and information about proof of custody of shard data. We are doing more work on structuring the responsibilities of our validator client and how a validator should interact with wallets to prevent unnecessary data leak to the world. Given the document created by Danny here, there is more work getting done to further clarify what a validator client should be responsible for.
Ethereum 2.0 Implementers Call Jan 17, 2019
We just finished the ETH2.0 implementers call, it was one productive call filled with lots of great discussions on the latest researches and implementers updates. Take a listen if you haven’t yet! Agenda and Recording.
Blog Post on Ethereum 2.0
This week, James Prestwich published a fantastic post explaining the Ethereum 2.0 roadmap objectively along with its challenges and current progress. We highly encourage anyone following the project to read through the document, as it serves as a useful reference at an introductory to intermediate technical level of understanding.
Interested in Contributing?
We are always looking for devs interested in helping us out. If you know Go or Solidity and want to contribute to the forefront of research on Ethereum, please drop us a line and we’d be more than happy to help onboard you :).
Official, Prysmatic Labs Ether Donation Address
Official, Prysmatic Labs ENS Name
Ethereum (ETH) Release solidity Version 0.5.4
This release adds support for calldata structs and packed encoding with ABIEncoderV2. We also introduced some changes to the C API and added support for continuous fuzzing via Google oss-fuzz. In addition to that, we added a new commandline option for improved (colorized) diagnostics formatting.
- Allow calldata structs without dynamically encoded members with ABIEncoderV2.
- ABIEncoderV2: Implement packed encoding.
- C API (
solidity_freemethod which releases all internal buffers to save memory.
- Commandline Interface: Adds new option
--new-reporterfor improved diagnostics formatting along with
--no-colorfor colorized output to be forced (or explicitly disabled).
- Code Generator: Defensively pad allocation of creationCode and runtimeCode to multiples of 32 bytes.
- Commandline Interface: Allow yul optimizer only for strict assembly.
- Parser: Disallow empty import statements.
- Type Checker: Disallow mappings with data locations other than
- Type Checker: Fix internal error when a struct array index does not fit into a uint256.
- Type System: Properly report packed encoded size for arrays and structs (mostly unused until now).
- Add support for continuous fuzzing via Google oss-fuzz
- SMT: If using Z3, require version 4.6.0 or newer.
- Soltest: Add parser that is used in the file-based unit test environment.
- Ubuntu PPA Packages: Use CVC4 as SMT solver instead of Z3
We especially thank all the contributors that made this release possible:
Alex Beregszaszi, Bhargava Shastry, Christian Reitwiessner, Christian Parpart, Chris Ward, Daniel Kirchner, Erik Kundt, Leo Arias, Leonardo Alt, Mathias Baumann, Mudit Gupta, Shelly Grossman
Ethereum Release eth2.0-specs v0.3.0 - Let There Be Liquidity
This is the second of weekly Friday releases in February -- Let There Be Liquidity.
This release includes a number of small feature additions/modifications, clarifications, and minor bug fixes. The most significant features added were (1) enforced ordering of eth1 deposits (to avoid replay attacks) and (2) enabling transfers from "withdrawable" validator accounts (to open up liquidity options for validators before phase 2).
The core of the phase 1 spec is currently being built, but the exact particulars should be considered unstable and not yet targeted for production development.
Outside of this immediate release, progress continues to be made on the cross-client testing, and much progress have been made around network specifications (#593) and discovery protocol.
PR showing full diff can be found here: #631
Phase 0 spec
Phase 0 validator
- variable name changes (#630#629)
- merkleize container elements (#595)
No changes, but we expect some coming as we standardize BLS12-381 across blockchains
Phase 1 spec (warning: not stable)
- modify shard-chain fork choice to use both crosslink and shard chain attestations (#586#579, #617#578, #604#630)