Skip to content
This repository has been archived by the owner. It is now read-only.
Switch branches/tags

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time

Diamond Drops (diamond_drops)

Diamond Drops image

Twitter TravisCI License: Unlicense Average time to resolve an issue Percentage of issues still open Built with cargo-make codecov Gitter: DropsOfDiamond/Lobby Gitter: DropsOfDiamond/Development Gitter: sharding standard-readme compliant

WIP on sharding and Ethereum 2.0 with enshrined-in-consensus data availability and Rust: a fast, safe, concurrent and practical programming language.

This repo contains code that is implemented to a deprecated sharding specification (notaries and proposers with a sharding manager contract), as well as previous code for collators and proposers. The latest specification is not finalised. Currently as of July 31 2018 work is underway on the networking aspect, with gossipsub. Note also that for a more up-to-date, but still outdated, implementation of the first version of the shasper (sharding + Casper) specification, see

We were working on a sharding implementation for Ethereum with the Rust programming language, which is fast, safe and concurrent. See also this "Why Rust?" post by ParityTech and the Rust book, 2018 edition to learn Rust. Sharding plans to scale Ethereum, with the current goal of 100k TPS (see the latest spec above for details).

We're implementing sharding according to collaboration with Ethereum research at and other teams, which includes tasks outlined in the projects and issues. In the first phase of the roadmap, we only enshrine data availabilty, without execution, thus abstracting execution, and enabling faster and simpler implementation, with each phase being useful. For further information, please refer to our wiki, which includes an introductory video, background info, contributing info, and more. The plan is for this codebase to eventually be integrated into the Rust implementation of the EVM, Parity. diamond_drops is used as the name of the cargo crate for compatibility, and so the repo name also follows this.



For an introduction to Ethereum, see or For information on sharding and implementations, refer to here.


Install dependencies

  • Install Rust

  • Update Rust

    rustup update
  • Install Rust Formatter

    rustup component add rustfmt-preview
  • Install Cargo-make Task runner and build tool

    cargo install --force cargo-make
  • Execute specific task runner flow. Default is Makefile.toml

    cargo make --makefile tasks.toml <TASK_NAME>

Show help menus

  • Command help
cd ~/diamond_drops; # you may wish to rename this to dod for convenience
cargo run -- --help
  • Sub-command "mode" help
cargo run -- mode --help

Clone a fork of the repository

  • Fork the repository

  • Clone your fork of the repository (replace below with your Github username):

    git clone<USERNAME>/diamond_drops;
    cd diamond_drops
  • Add the "upstream" repository to your remotes and show your list of remotes verbosely

    git remote add upstream;
    git remote --verbose
  • Change from the "master" branch to the "develop" branch to see the latest features that are being integrated but are not officially ready for production

Follow us on Twitter for release updates

Click on the Twitter badge above.


Build and Run the code

  • Proposer Mode

    cargo make p
  • Notary Mode

    cargo make n
  • Both Proposer and Notary Modes

    cargo make b
  • All above

    cargo make all
  • All above with collation example

    cargo make all-with-collation

Unit and Integration Tests

  • Run all tests (unit and integration tests for main package and libraries)

    cargo make test-all
  • Watch all tests (polls continuously for code changes during development, automatically running tests, and reports issues)

    cargo make build;
    cargo install cargo-watch;
    cargo make watch;

Show Rust Docs

cargo make docs

View UML Diagram

  • View UML with Google Chrome, Mozilla Firefox, or Brave browser

    cargo make uml-default-recommended;
    # The below options will only work for Mac OS X, otherwise use the above.
    cargo make uml-chrome;
    cargo make uml-firefox;
    cargo make uml-brave;
    • On a Mac you can also use ls /Applications; open SVG-COMPATIBLE-APPLICATION ./diagrams/ml.svg.
    • Optionally create a Pull Request to update Makefile.toml or open the diagrams/ml.svg file manually after building with the graphviz dependency for MML or an alternative installed.

Contibuting guidelines

See this wiki article here.


This is WIP, pre-release software. It is planned to be integrated into Parity. There is a lot of research available on security alone; for example, CTRL+F "security" here or search in the pages here

Help support us

Send a donation to jamesray.eth. All contributors will be paid according to their contributions and timesheets, once funds are received. As an example, my timesheet is available here. A multisig will be used when other developers are contributing full-time. Funds are needed to pay researchers and developers a reasonable hourly rate or salary, which may fairly be quite high due to the time required to learn about Ethereum, sharding, etc.; and because of the scarcity of those interested and qualified to be able to contribute in the blockchain industry. For more details see this issue.<!omitting until other regular contributors are well established, although I still vouch that contributions will be paid for according to assessing hours on timesheets--our multi-sig wallet at 0x6D446f9545dBC380A6BBDde8A285A7A8030D4381-->

We're looking for more developers

See here for information. There is a lot of work to do in the sharding roadmap.

Why Rust?

After comparing languages such as Rust, C++, Go, Javascript and Python, as well as implementations (e.g. Parity, cppethereum, Go-ethereum, ethereumJS and Py-EVM), Rust is most preferable, while I haven't tried being a user much of other implementations, so I can't comment on a comparison. Rust has advantages such as safety, concurrency, practicality, better memory safety (thanks to its ownership rules), zero-cost abstractions, and support for functional and imperative-procedural paradigms.




WIP on sharding and Ethereum 2.0 with enshrined-in-consensus data availability and Rust: a fast, safe, concurrent and practical programming language





No packages published

Contributors 4