substrate-developer-hub / hacktoberfest

Hacktoberfest 2019 @ Parity

(Old) Substrate Developer Hub (ARCHIVED)

THIS SITE IS ARCHIVED.

• New site: https://docs.substrate.io/
• Source available: https://github.com/substrate-developer-hub/substrate-docs/

This repository houses documentation for the Substrate blockchain framework.

The docs are written in markdown, processed by Docusaurus, and hosted at the Substrate Developer Hub.

Contributing

Thank you for your interest in contributing to the Developer Hub and to the larger Substrate community! Please review our contributor guidelines prior to any contribution. If you have any further questions, don't hesitate to reach out on our substrate technical community channel.

Directory Structure

This repository is structured as a Docusaurus project with the markdown files organized in the /docs directory. Images and other assets are in the /docs/assets/ directory. The /website directory is a Yarn Docusaurus project with many helpful scripts (e.g. yarn build, yarn start) for working with this codebase.  In the /website directory you will find sidebars.json and siteConfig.js, which are important Docusaurus files. You will find the source code for some top-level pages in /website/pages/en. Follow our contribution guidelines.

Adding a new document

To add a new markdown document:

• Create your markdown document in a suitable directory inside /docs.
• If you have images in your document, put them in the /docs/assets/ directory.
• Documentation should follow our contribution guidelines.
• If you want your document to appear in the sidebar, add its reference in the /website/sidebar.json file under the   corresponding section.

Rename an existing document

To rename an existing document:

• Change the name or path of the document.
• After the change has been merged, go to the Crowdin project,   make sure the translation is already migrated to the new file automatically for all the target languages.
• Then go to Crowdin project settings, remove the   old source file in Files tab.
• If you don't have access to the Crowdin project, please send email to [email protected] with the   file information you want to remove.

Local Testing

• cd into the /website directory.
• Execute yarn install and then yarn start.

The Substrate Developer Hub website should open in a browser window.

Link Checker

Once the website is running, you should use the included Yarn script (yarn check-links) to ensure that your changes do not introduce any broken links and to check for any links that have broken since the last time the check was executed. Please ensure all links are fixed before submitting any changes; if you have questions about broken links that you did not introduce, please create an Issue.

Once you are done with your changes, feel free to submit a PR.

Updates

There is a helper script that can be used to update substrate.dev/rustdocs links in the docs/knowledgebase directory.

# This examples demonstrates updating links from v2.0.0-rc3 to v2.0.0-rc4
OLD_VERSION=v2.0.0-rc3 NEW_VERSION=v2.0.0-rc4 ./scripts/update-kb-rustdocs

Production Deployment

Our production site is at substrate.dev. To deploy to production, merge your update into the source branch. This triggers the CI to build the website AND also pull in multilingual translation from our Crowdin project. The final built static site is then pushed to the master branch and hosted on GitHub Pages.

Staging Deployment

We have a staging deployment at devhub-maindocs.herokuapp.com, which is hosted on Heroku. Please check with the devhub team for the username and password to access the staging site.

To deploy to staging, you could push to the staging-source branch in the repository. This will trigger the CI to build the website, pull in multilingual translations from crowdin, and have the final built static site being pushed to staging branch. This in turn triggers Heroku to pick up the latest commit from staging branch and deploy to the staging site.

License

Substrate documentation is licenced under the Apache 2 license.

hacktoberfest's Issues

Detection of cargo-web during compilation.

The most important problem or a part we can say it to detect cargo-web during the compilation so this is the way we can detect cargo-web during compilation:
If during compilation you'd like to detect that your project is being built with cargo-web you can check the COMPILING_UNDER_CARGO_WEB environment variable, which will be set to 1.

##Label_hacktoberfest

[PoC] < 1 Sec Blocks Blockchain with Substrate

Investigate blockchain systems with less than 1 second block times with the Substrate blockchain framework.

---

Low block time blockchains have a number of practical usecases in research and development of these decentralized systems. For example, gaming platforms build on blockchain systems are dependent on low latency responses from user to the blockchain system to provide an immersive gaming experience.

As far as I know, experimentation around low block time blockchains on Substrate has not really been done.

This project would involve a user playing with the various settings of Substrate like block time, block weight, transaction queue, etc... to see how a live network is able to handle these changes.

It would require to create a virtual network, spawning multiple nodes around the world, and saturating the network with transactions to understand what is possible, and the effects of such a low block time blockchain.

Benchmarking around what kinds of logic is able to run on such a blockchain is also a good thing to research with such a network.

Ultimately, this is a hack and learn project, to just investigate what is possible and how we may be able to push substrate to the extreme.

For mentoring this issue please contact: me, @shawntabrizi

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Raise a PR against this Repository, adding your profile info under participants
• Raise a PR containing fixes #24 with your submission under /submissions against this repository - this can also be a git submodule to a different open github repo.

[Runtime Module] App-Market

Think like the Apple AppStore or Google Play for (external) Apps / Features / Downloads / Smart Contracts

A runtime module to be used as a central registry for an app-store like market, where users could submit their own additions to the market, send updates and others browse, discover and run or install from. This should probably use the existing Account system to allow for updates of specific items. Further more each item might have extra metadata (like name, icon, screenshots, whatever else) that should be stored off chain but reference from it - maybe via IPFS or external storage mechanism. Might be related to #20 .

Extra points if you make this generic not only over the metadata and its storage mechanism but also allow multiple instances of the different markets to run within the same runtime.

For mentoring this issue please contact: me, @gnunicorn.

Proof of done

• Create a new project by copying the contents from our runtime module template
• Don't forget to add an OpenSource License !
• Implement the specific module
• Once done, submit a PR either of the module in a subfolder under submissions or as a git submodule under subfolder

[Networking] rust-bitswap - IPFS's data exchange protocol in rust

Implement IPFSs data exchange protocol on rust-libp2p.

Bitswap is the underlying protobuf-based libp2p protocol used to exchange the actual data packages in IPFS. It should be pretty straight forward - the go and js client can be used to develop against.

For mentoring this issue please contact: me @gnunicorn.

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Create an external crate for the bitswap-protocol implemented on top of rust-libp2
• be sure to include an example on how to use that protocol
• best if the encoding layer was generic enough to replace protobuf with a different way to encode the messages
• Raise a PR against this Repository, adding your profile info under participants
• Raise a PR containing fixes #15 with your submission under /submissions against this repository with a git submodule to your open github repo.

[Runtime Module] Oracle for cryptocurrency real-time value

srml_oracle provides function api for other runtime modules to consume real time cryptocurrency price.

What provide in srml_oracle:

• Using OffChain worker to trigger a goup of https requests to get online cryptocurrency prices
• Authoritor can config the resources (eg. Coindesk BTC/USD api)
• Public storage value like priceValue for external api consuming real-time cryptocurrency price
• Data averaging with multiple sources (at least 3 sources at the moment), will filter invalid values and make sure the final result is effective
• Send the unsignedTransaction with signed payload and verify the result before submit the transaction

Detail features

For mentoring this issue please contact: @huanday @CaiYiLiang

Proof of done

• Create a new project by copying the contents from our runtime module template
• Don't forget to add an OpenSource License !
• Implement the specific module
• Once done, submit a PR either of the module in a subfolder under submissions or as a git submodule under subfolder
• (optionally) publish if on crates.io

[ecosystem] `no_std` libraries!

It may be that none of these other more specific projects called out to you, but you still want to contribute! Runtime Development and Substrate in general really needs more no_std compatible libraries!

The Substrate Runtime compiles to Wasm, and as a result, we ensure that the runtime code is free from the Rust standard library.

However, many common libraries use STD, even in situations where they would not need to! All of these libraries immediately become incompatible with Substrate runtime development.

This issue is to allow users to pick useful Rust libraries which currently do not exist or do not support no_std, and write them with this feature!

Some ideas are:

• Common cryptographic libraries
• Hash Functions
• BigInt / BigNum libraries
• Sorting Algorithms
• etc...

For mentoring this issue please contact: me, @shawntabrizi

[Runtime Module] Decentralized Prediction Market

Think Augur, but for Substrate.

---

Getting external data on chain is a difficult task for any blockchain system. Substrate provides the off-chain worker apis, but that is not the only solution.

Teams like Augur have shown that prediction markets can incentivize external parties to submit truthful outside data to the blockchain, which can then be used as a decentralized oracle system.

The goal of this project would be to build a proof of concept of such a prediction market using the Substrate runtime module system.

This would require research into Augur and other competing prediction market systems. Investigating how best to implement such a project on Substrate, and establishing a reasonable MVP to show that this is a viable proof of concept.

For mentoring this issue please contact: me, @shawntabrizi

Proof of done

• Create a new project by copying the contents from our runtime module template
• Don't forget to add an OpenSource License !
• Implement the specific module
• Once done, submit a PR either of the module in a subfolder under submissions or as a git submodule under subfolder
• (optionally) publish if on crates.io

update substrate package link

it lives here now: https://github.com/substrate-developer-hub/substrate-package and the runtime module lives in https://github.com/substrate-developer-hub/substrate-module-template

Finalize Readme/Website

• confirm date and times of events, see #12
• upload customized logo - delayed
• link registration form
• confirm swag, update FAQ - delayed
• revise FAQ, add missing items (listed below)
• add FAQ section on copyright/licensing

[PoC] co-signing offchain-workers

Create a proof of concept how multi-sign patterns could be used for offchain workers.

For a few weeks we now offchain worker capability in substrate. An obvious use case is for them to fetch external, maybe even paywalled, data and put that on-chain. However, it would be great if the chain wouldn't just accept that information to be provided by any offchain worker but instead would require multiple offchain-workers to agree and sign them off before accepting them.

There are multiple ways this could be addressed: it might be that offchain workers coordinate offchain and the chain only accepts a multi-sign over a certain threshold or the offchain worker could use the chain as an intermediary coordination layer, where one or many might propose new data entry and others sign off and the chain only reacts once enough signed off. Because there being multiple valid approaches and this being a proof of concept project, multiple people can work on it regardless.

For mentoring this issue please contact: @gnunicorn

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Raise a PR against this Repository, adding your profile info under participants
• Raise a PR containing refs #18 with your submission as a submodule to an open github repo under /submissions against this repository

[Tooling] Cross-Compiler

Cross-compilation tool for porting Substrate into different architectures

Create your own cross-compilation tool or modify an existing one like "cross".

For questions and help ask your mentor @riusricardo.

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Raise a PR against this Repository, adding your profile info under participants

• It needs to build a Substrate binary for the most common Tier 2 or ARM architectures.

• aarch64-unknown-linux-gnu

• arm-unknown-linux-gnueabihf

• arm-unknown-linux-gnueabi

• Outline what challenges you had to overcome to make it happen.

[Embedded] Raspistrate

Port substrate to run on a raspberry pi

Take substrate-node and try to get a full node running on a raspberry pi (ARM). Submit a PR for the changes necessary to substrate for it to work.

For questions and help ask your mentor @riusricardo.

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Raise a PR against this Repository, adding your profile info under participants
• Get substrate-node to run on a raspberry pi (you might want to cross-compile from a different system)
• Outline what challenges you had to overcome to make it happen, either in some documentation or a personal blog post

Should This Repository Be Archived?

[Runtime Extension] Redis-Style Data Storage & Commands

Add extended data structure and allow redis-style data manipulation on them.

We have rudimentary storage access available in the runtime, including some complex data types like linked_list, maps and you can also store Vec<T:Codec>. However, this is a) by far not all the data structures a runtime engineer might need and b) manipulation is often tricky to ugly UX. It would be great to implement further data structures and allow similar access and mutation patterns as shown by the redis command reference.

There is multiple ways in which that could be achieved: by adding further features to the existing storage helpers, by providing macros on top (data_append!(<T as Storage>::Key, item)) or as an external module implementing these features. Obviously the set of final data types and commands is pretty vast and it might make sense to create a general pattern/framework first and then allow additional data types and commands to be implemented over time.

For mentoring this issue please contact: me, @gnunicorn

Proof of done

• Once done, submit a PR either of the module in a subfolder under submissions or as a git submodule under submissions

[Consensus] Implement Grin's Cuckoo Cycle proof of work on substrate

Since3473 substrate has a tunable (classical) Proof-of-Work authoring engine for consensus. However, it comes with the known issues of PoW system - problems further research in the field attempted to address. For example MimbleWimble's Grin, a rust implementation of Cuckoo Cycle Proofs. It would be awesome to have a grin-like authoring engine in substrate.

For mentoring this issue please contact: me, @gnunicorn

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Raise a PR against this Repository, adding your profile info under participants
• Raise a PR against substrate with the new consensus engine (look at the PoW PR for an example, how to integrate)

Cargo command to add modules to a runtime

A Cargo command allowing to easily add modules to a runtime

Substrate runtimes are composed of modules. This cargo command makes all necessary changes to add an existing module in your runtime by just providing its name.
Details about adding a module can be found here. It involves:

• modifying Cargo.toml
• modifying some rust source files

cargo-edit can be a source of inspiration.

For mentoring this issue please contact: me, @jeluard

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Raise a PR against this Repository, adding your profile info under participants
• Link to an existing github repo implementing the cargo command

Publish Substrate Runtime Library Modules v1.0 to crates.io

Required steps:

• Raise a PR against the substrate 1.0 branch that:
  • clean up dependency tree of sr- and srml-modules (see cargo tree)
  • Updates the license, description and other missing fields for each module (see cargo package warnings)
  • pins down versions of locally used dependencies
• Publish (this can only be done by a Parity employee):
  • publish all srml-, sr- and dependent crates on crates.io (see cargo publish)
  • make sure paritytech:core-devs is one of the owners of the package on crates.io (see cargo owner)
• Raise a PR against the templates repository, replacing all published crates with version numbers

Translate the documents in Substrate developer hub

Multi-language support in Substrate developer hub is important for blockchain developers to start building their business on Substrate easily and friendly.

The hub now accepts translations of Chinese, Japanese, Korean, Brazilian Portuguese, and Russian (ping me if your language is not in the list). We'd like to encourage community members to contribute more translations for all the available languages. Follow this guide to start contribute.

For mentoring this issue please contact: me, @kaichaosun

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Go through the site and have a basic feeling about the translation style and terms.
• Pick a document that is high-priority (with a gray ⬆️) and has not been translated in Crowdin. If the document has been partially translated but is less than 50%, it's also ready to pick.
• Add reasonable translations for the documents that you picked.
• Send the document title, link and words count that has been translated to me.

[Runtime Module] Confidential Transactions / Private Balances Module

Implement MimbleWimble like Confidential Transactions as a substrate module.

Since the development from Bitcoin, other, more privacy focused balance management systems have been proposed. MimbleWimble is a rust project implementing a Confidential Transaction based idea. It would be amazing to implement that transaction system as a substrate module to provide privacy-first balance management.

For mentoring this issue please contact: me, @gnunicorn

Proof of done

• Create a new project by copying the contents from our runtime module template
• Don't forget to add an OpenSource License !
• Implement the specific module
• Once done, submit a PR either of the module in a subfolder under submissions or as a git submodule under subfolder

[Runtime Module Extension] Object Permission Control

Allow modules to have more advanced user permission control through an ACL-like extension.

Right now, every module has to implement its own object permission control flow and enforce it when the user sends an extrinsic. This is tedious, hence they are often lacking features. It would be great to provide a generic extension or module to manage AccountID + Permission on Object relationships and thus implement more complex permission control. In its basic function this should allow a module to grant a T::AccountId one or many custom permissions (e.g. write, update, delete) on a specific object it can somehow uniquely identify. Essentially the module should implement an interface similar to:

trait PermissionControl<T: system::Trait, O, P> {
   fn has_permission(who: T::AccountId, permission: P, on: O) -> Bool;
   fn ensure_permission(who: T::AccountId, permission: P, on: O) -> Result;
   fn grant_permission(who: T::AccountId, permission: P, on: O);
   fn revoke_permission(who: T::AccountId, permission: P, on: O);
}

For mentoring this issue please contact: me, @gnunicorn

Proof of done

• Create a new project by copying the contents from our runtime module template
• Don't forget to add an OpenSource License !
• Implement the specific module
• Once done, submit a PR either of the module in a subfolder under submissions or as a git submodule under subfolder

[Runtime Module] Quadratic Coinvoting Democracy

This runtime module would allow users of a Substrate blockchain to vote on proposals using their tokens in a quadratic voting system.

---

The goal of this module is to provide alternative governance mechanisms to what the SRML provides. Right now, Substrate has a "lock weighted" voting mechanism, but it is worth considering a quadratic coin voting system.

To do this task, it would require you do a bit of research on quadratic voting, and understand if it makes sense in the context of Substrate/blockchains. There may be different implementation details between papers, so you will have to pick one which makes sense to you.

Ideally, this module will expose the same traits as the existing Democracy module, thus allowing it to simply be swapped into any Substrate runtime which currently uses the SRML Democracy module.

However, I think any working proof of concept may be a good starting point for the context of "hacktoberfest".

For mentoring this issue please contact: me, @shawntabrizi

Proof of done

• Create a new project by copying the contents from our runtime module template
• Don't forget to add an OpenSource License !
• Implement the specific module
• Once done, submit a PR either of the module in a subfolder under submissions or as a git submodule under subfolder
• (optionally) publish if on crates.io

VSCode support for substrate macros

Building a substrate module involves using a number of macros with specific syntax.
This VSCode plugin should provide proper syntax highlighting and potentially completion to ease module development.

Details about relevant macros:

• some context 123
• construct-runtime!
• decl-event!
• decl-module!
• decl-storage!

For mentoring this issue please contact: me, @jeluard

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Raise a PR against this Repository, adding your profile info under participants
• Link to a github repo containing the relevant VSCode plugin implementation

mentors aren't rendered

for some reason the readme-mentors section doesn't show up. it should state the name of each individual and include a link to their rendered page with name, social and matrix usernames/ways to access them and the description they've put up.

[PoC] Decentralized Identity SideTree protocol implementation on Substrate

The SideTree protocol, developed by the Decentralized Identity Foundation, is a layer-2 protocol for anchoring and tracking DID Documents across a blockchain, a system also know as decentralized PKI network. Identifiers and PKI metadata in the protocol are expressed via the emerging Decentralized Identifiers standard, and implementations of the protocol can be codified as their own distinct DID Methods.

The central design idea involves batching multiple DID Document operations into a single blockchain transaction. This allows SideTree to inherit the immutability and verifiability guarantees of blockchain without being limited by its transaction rate.

As of today, there exist two standard implementations that anchor DID operations onto the Bitcoin (project ION) or Ethereum Blockchain (project Element).
This task involves creating an implementation of the SideTree protocol using Substrate.

Several alternative designs could be envisaged:

• Follow the original design as a layer-2 protocol, with transaction aggregating a batch of DID operations, and mostly leveraging Substrate as an alternate chain to Ethereum. Most of the work would revolve around creating a Ledger adapter component for Substrate, to record SideTree-encoded transactions. This design could be battle-tested using Polkadot’s canary testnet, Kusama.
• Deviate from the original design, and implement the protocol as layer-1 by leveraging Substrate’s unique features such as Runtime Modules, Offchain Workers & storage, and tuning the node for fast block time. The Substrate node would therefore act as DID resolver & DID cache, beyond simply recording DID operations on-chain.

For mentoring this issue please contact: me, @stiiifff

Happy Decentralized Identity hacking !

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Raise a PR against this Repository, adding your profile info under participants
• Raise a PR containing fixes #27 with your submission under /submissions against this repository - this can also be a git submodule to a different open github repo.

[Networking] Bittorrent over libp2p (in rust)

Implement the bittorrent data exchange protocol as a rust-libp2p-protocol.

For mentoring this issue please contact: me @gnunicorn

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Create an external crate for the libp2p-bittorrent-protocol implemented on top of rust-libp2
• be sure to include an example on how to use that protocol
• Raise a PR against this Repository, adding your profile info under participants
• Raise a PR containing fixes #16 with your submission under /submissions against this repository with a git submodule to your open github repo.

[Runtime Module] Name Registry

Often one needs a globally unique registry to map names to values - for example for DNS. Implementing that as a generic runtime module with different access control flows would be great.

This module should be generic over the value each entry stores and it would be great if it would come with facilities to allow for different claim and update mechanism. For example a domain might be auctioned off at the beginning and only the winner can write and update that entry. Aside from a few common installments the repo should only show them and allow for other strategies to be implemented.

For mentoring this issue please contact: me, @gnunicorn

Proof of done

• Create a new project by copying the contents from our runtime module template
• Don't forget to add an OpenSource License !
• Implement the specific module
• Once done, submit a PR with your module published on openly on github as a git submodule under submissions

[Runtime Module] SRML-based Substrate node for ERC-721 Non-Fungible Token Standard implementation

Substrate ERC-721 Non-Fungible Token Standard implementation

SRML-based Substrate node for ERC-721 Non-Fungible Token Standard implementation.
It should be abstracted as an SRML interface and can be used by other modules.

We've created a project to that SubstrateOrg/substrate-nft

For mentoring this issue please contact: me, @_ZhiGuang

Proof of done

• Create a new project by copying the contents from our runtime module template
• Don't forget to add an OpenSource License !
• Implement the specific module
• Once done, submit a PR either of the module in a subfolder under submissions or as a git submodule under subfolder
• (optionally) publish if on crates.io

[Tooling] Submitting custom runtime extrinsics with rust via JSON-RPC

It would be great to have an example in the node-template for the custom extrinsics.

Using substrate-subtxt (as a dev-dependency) it should now be possible to have a rust-example in the node-template that submits an extrinsic to that locally defined custom runtime via the JSON-RPC interface. It would be great if the client user doesn't have to make any further implementation but the client could be directly linked to an existing runtime and figure out the RPC calls and methods to expose from there statically.

For mentoring this issue please contact: me, @gnunicorn

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Raise a PR against this Repository, adding your profile info under participants
• Raise a PR against substrate adding the example for the locally defined custom runtime

Go public

• finish up website, #4
• create summary blog post
• put bannner / link into main substrate-dev-hub
• publish blog post
• social media publication about it

UI for rapidly starting Substrate project by composing SRML modules

One of Substrate's value propositions is that users can create a blockchain quickly by using pre-existing runtime modules. Currently that is done by writing rust code. The process could be faster, less mistake-prone, and more beginner-friendly by providing a GUI for that process.

Details

The current process for creating a blockchain from SRML modules is the fork the node-template, and make edits to the code in runtime/Cargo.toml, runtime/src/lib/rs, and src/chain_spec.rs. When no custom modules are being written, the edits to these files are entirely straightforward. By changing only these three files, users can explore these features of Substrate

• Add modules
• Remove modules
• Change genesis configuration of installed modules
• Change module dependencies (eg many modules depend on some notion of Currency which Balances provides)

The GUI should allow the users to quickly select their modules, enter their genesis configurations, and satisfy their dependencies without writing any (or perhaps very very little) rust code. The UI should also be smart enough to prevent users from building blockchains that won't compile. For example the user should not be able to satisfy a dependency on the "Currency" trait with a module like Sudo because Sudo does not implement the currency trait. When the user is finished they can click the generate button. At minimum, they should be presented with the three files and instructions for how to copy them over the existing node template. A nicer workflow would be to use their github credentials to have the node template forked for them, and a commit with the newly-generated files added.

For mentoring this issue please contact: Joshy Orndorff, @JoshOrndorff

UI Ideas

There UI design is largely up to you, but it should be modern, intuitive, and more convenient than writing code. One idea I had (that is admittedly pretty advanced) is based on the digital logic learning tool at https://logic.ly/demo

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Raise a PR against this Repository, adding your profile info under participants
• Raise a PR containing fixes #26 with your submission under /submissions against this repository - this can also be a git submodule to a different open github repo.
• Record a short screencast (~1-3 minutes) demonstrating how to get started with your GUI tool

[PoC] PoW Wasm Contracts Chain

Build a Proof-of-Work Wasm Contracts Chain example. Then explain how it works and how to interact with it.

For mentoring this issue please contact: me, @gnunicorn

Proof of done

These following tasks must have been completed in order for this to be considered done:

• Raise a PR against this Repository, adding your profile info under participants
• Raise a PR containing fixes #43 with your submission under /submissions against this repository - this can also be a git submodule to a different open GitHub repo.
• Publish a Blog post describing, what you did, how the chain works and how to interact with it