DEV Community: Matej Yangwao

How we are rewarding contributors to open-source NFT marketplace?

Matej Yangwao — Wed, 23 Mar 2022 10:50:29 +0000

Foreword

Once upon time, we wanted to build public good, bit different and with shared ownership on top, from our craft between those who are contributing to our wholesome piece of work and helping us to render our vision true.

We've thought it would be way different, if we build our craft best as open source. As we believe in positive sum games, shared wisdom, collaborative work and collaborative intelligence we highly appreciate if we can be together on path with common shared goals.

Collaborative intelligence is a term used in several disciplines. In business it describes heterogeneous networks of people interacting to produce intelligent outcomes.

Paolo Soleri's "hyperstructure" in ground-level view. The figure to the right is the Empire State Building at the same scale.

We strongly believe providing something as public good would multiply our efforts and impact future for others, who come over and can build something really nice and help them be the next entrepreneur over weekend. That easy.

Thanks to Github, we've enabled networked human groups to efficiently combine their knowledge, wisdom, insights, and intuitions into an emergent intelligence. This might be often referenced as hive mind.

Open source development could be started by anyone and anytime. What's make difference is cause, funding and coordination, in nutshell governance of development to drive without less friction and codebase evolution happen in particular pace.

How it evolved

Yet our biggest pain issue was coordination and how people are rewarded. We identified this early and realised would be really great give people liquid reward -- money. Fast as possible to drive positive reinforcement loop to come back and contribute again in short-time.

That's seems has worked pretty well. Once we've started crossing 100+ pull-requests on monthly basis on average, we've hit over 230 pull-requests merged in one month. Simple superior effort, all 16 people involved in 30 days.

In retrospect, we've designed policy and rulesets. Crafted our Contributing Guidelines with standardised process how we do payouts. Sounds simple. On side line, delivering product with small revenue, traction and user base.

Steep Achievement

Seems innocent tactic results in steep adoption from open-source developers. In short we've opened flood gates for gig economy en masse. Hitting 160+ forks, 222 stars and over 70+ contributors in few weeks.

How this happened that quickly? Consistence, dedication and compounding effect.
At start, it was quite slow and it has required to make room people to contribute. We done lots of brain dump, like created 1k+ issues in our repository which we've found would be superior to have so developers has inspiration and they can go through loop of contributing, to bring their creativity. This flywheel of contribution made it working, it just took to pimp to it's best and being efficient.

Flywheel of contribution

Discovery

From perspective of newcomer, easy mode. Developer will find issues in our KodaDot repository, which has bounty levels from $100 ($) up to $1k ($$$$$) plus we have labels based on priority.

That helps a lot developer to gauge their interest whats is urgency for particular issue. Thats for brief start and issue discovery once developer has estimated their experience delivering fixed issue. Often is great for developer to ask to clarify what's needs to be done, so there is right alignment contribution made between those who created issue and who comes with resolved issue.

Life of pull-request

Once pull-request is made against our main branch, it's good to request code review from helpful folks, who are longer period around our KodaDot codebase and seniors in code-quality to check on your code. Requirement of this is to see what have you contributed meets best code practice. Once you receive review, there are two frequent options. Either you receive feedback with code suggestion -- what you could done better which isn't inherently bad, yet it's different perspective, which most of cases drives higher code quality for others and other new comers

Another option is simple approval, which there is higher chance you receive, once you are familiar with our code base.

Once someone made approval and done sort of static code analysis including our bunch of helpful dog robots and intelligence which reviews your code if you did not accidentally break something

you are entering very last stage of receiving reward for your amazing contribution paid to your wallet.

That's pretty much breakdown of stages how you can receive quick reward through contributing to open source. What's best on top, you are automatically eligible to be part of internal circle, which opens doors to level up your coding skills, fill your GitHub track record with legitimate open source web3 project, participate in less-public discussions and on top accrue reputation reward. That's our slow paced reward for those you are really like what we are doing and what opportunities we are giving away for others.

Leaderboard

To create trust for incoming developers and show proof we've sent fair amounts of payments out there, over 20k$ in pull-requests and another 70k$ on side with on-chain proofs, we've realised it would be amazing show super easy chart.

To easy see, we sorted our rank by rewards received. On side columns we've added amount per merged pull-requests, number of pull requests vs merged pull requests and charts goes on.

Best takeaway, you can see yourself that prachi00 as women developer, she is on the top of our chart. This brings KodaDot open-source repository is not only dominated by males.

LEADERBOARD.md

Flexibility of contributing

Best of all, we don't hold anyone as contractor around to helping us on this. Anytime you can come and go, withdraw yourself anytime. You are pretty free.
We even break down potential thoughts what we guess developers keeps on coming.

Few notable reasons are

size of reward - ranging from $50 up to $1k
Flexibility - whenever you are available, you do PR.
Belonging - Squad goals, we craft something unique together
Challenging Puzzles - pushes you to learn something new and get reward
Proof of Contribution to OSS - Whenever you will be looking for your next job, companies already referring to us
Bug hunting - infinite challenges helping real-world codebase

How we nurture connections between developers

Now we are in stage, where coordination aka all-hands developer community calls happens on bi-weekly basis and people can drive development with their insights to make it better. We welcome everyone improving opinion as it contribute to wider wisdom and better market fit of codebase one is making. We've found it as infinite universe what we can improve and we always enjoy what for one can be obvious solution, for other could be blind spot. Maintaining peer-admiration and raising awareness in respectful way is key we build our ethos and soul.

This open doors for anyone to participate from outside and making codebase improved by their perspective. We are trying to have warm, welcoming and inclusive culture, that's we are high on ethics.

Okay what we are building

You might question why we are doing this. We've realised hence our biggest goal is to driving experimental NFT landscape, we can actually dog food ourselves with one experiment at a time. That's how we making this developer incentives real and it's sort of our case to demonstrate it is already possible. To further extend KodaDot experiment, we are building it as scaffolding interface for others builders out there, who would like to build something on MetaPrime way faster with help of others. It's just matter of time, inspiration and experience gathering around to drive better NFT dapps further.

Conclusion

More KodaDot is getting mature, more complex problems arising. That's at some point we will getting someone making out of bounties which will act as their continuous payroll. With one detail, pay as you go. Once more these kind of people is onboard, more autonomy KodaDot as project will receive from it own founders.

In retrospect, having our async culture helps us a lot. To drive our iterative evolution, we have lot of issues, really tons of issues, we've crossed issue total count 2500, even mental issues after those issues (jk).

We add there bounties to cover development of this monstrous machinery. We have over 50k$ in bounties right now. We've managed to capture and create long contributing.md thanks to 70+ contributors as acts as our soft-smart-contract for contributing.

If you are considering to contribute, best is to pick small and easy issue, join our Discord and let's chat further, there is lot of interesting puzzle you can help us to crack and being rewarded in form of money, experience and reputation.

You can take peak on our bi-weekly development digest we've called Meta_Hours which is often recorded and we are posting agenda ahead of event so anyone having question can well prepare.

Our end game is goal that KodaDot will be where we are going is that being builders-owned marketplace engine which will connects multi-chain future of NFTs ecosystems.

Participate

How you can engage and participate in our builders owned economy?

Participate in Discussions with impactful suggestions
Help with coordinating issues and bi-linking them.
Create pull-requests and get paid
Help with Code reviews (our current bottleneck)

Follow-up

Follow on Twitter @KodaDot
Read on Medium KodaDot
join our Discord

Developing smart contracts with ink!

Matej Yangwao — Wed, 16 Dec 2020 15:15:39 +0000

A little about my crypto journey.

Back in early 2011, were having lectures about Bitcoin in our hackerspace Progressbar. Since then, I've gotten more interested in Bitcoin and more broadly blockchain tech. Later on, I followed the development of Ethereum. I was interested in the EVM which was invented with its own programming language called Solidity. Fast-forward, in 2017, Gavin Wood announced a project called Polkadot along with Substrate, a framework for building application-specific chains. But that's just tech, you need soul to bring ecosystem, working around a common, shared goal. In Q2 2019, Edgeware decided to build a smart contract blockchain using Substrate, seeding the community with a lockdrop. In effect, the team exited to the community from day one. Most of the tokens were given to the community, which developed a great culture from the start—the community includes artists, builders, DAOs, DeFi and game developers. That's one thing that got me interested in Edgeware.

Disclaimer, I'm chain-contractor for Edgeware and a member of Edgeware Builders Guild.

Thanks to Edgeware Lockdrop, the chain have distribution among its believers.

Introducing Ink!

Today, I'll be walking through ink!, a Rust-based embedded domain-specific language (eDSL) for writing Wasm smart contracts. I'm a smart contract developer at heart and this is just one piece of smart contract tooling that Edgeware provides.

Because Substrate implements nearly all the code necessary to launch a working blockchain, including libp2p networking and PBFT consensus, Edgeware core developers get to focus on building create tooling for smart contract developers. They're working on C/C++/Rust smart contracts that can be compiled to WebAssembly (WASM). (Oh, you can also run Solidity-based smart contracts for the Ethereum Virtual Machine (EVM). I'll write about that later.) Onto the guts of ink!

ink! Contract Components

ink! should feel familiar to developers who have programmed using other modern smart contract languages. The skeleton of a contract has all of the same components that you might expect:

Events
Storage
Deployment (Constructor) Function
Public Functions
Internal functions

In ink!, mutability and visibility are explicitly defined per contract function. In these functions, you gain access to a number of common Substrate types like AccountId, Balances, Hash, etc. Additionally, you gain access to commonly used environment variable like the caller, and more!

Design

The main goals of ink! are correctness, conciseness, and efficiency.

ink! is designed to be as close to the Rust programming language as possible. The language uses attribute macros to tag standard Rust structures into understandable contract components.

#[ink(...)]
Copy

Because ink! follows Rust standards, tools like rustfmt and rust-analyzer already work out of the box.

Overflow Safety

Being written in Rust, ink! can provide compile-time overflow/underflow safety. Using a Rust compiler configuration, you can specify whether you want to support overflowing math, or if you want contract execution to panic when overflows occur. No need to continually import "Safe Math" libraries, although Rust also provides integrated checked, wrapped, and saturated math functions.

Test Environment

ink! provides a built in test environment that can be used to perform off-chain unit testing with the Rust framework. This makes it simple and easy to ensure that your contract code functions as expected, without the need for third party testing platforms.

ink! vs Solidity

Rust is an ideal smart contract language. It is type safe, memory safe, and free of undefined behaviors. It generates small binaries because it doesn’t include extra bloat, like a garbage collector, and advanced optimizations and tree shaking remove dead code. Through compiler flags, Rust can automatically protect against integer overflow.

ink! chooses not to invent a new programming language, but rather adapt a subset of Rust to serve this purpose. As a result, you gain from all of the tooling and support available to the Rust ecosystem for free. In addition, as the language develops, ink! will automatically gain access to new features and functionality, improving how you can write smart contracts in the future.

Here is a brief comparison of features between ink! and Solidity:

Virtual Machine	Any Wasm VM	EVM
Encoding	Wasm	EVM Byte Code
Language	Rust	Standalone
Overflow Protection	Enabled by default	None
Constructor Functions	Multiple	Single
Tooling	Anything that supports Rust	Custom
Versioning	Semantic	Semantic
Has Metadata?	Yes	Yes
Multi-File Project	Planned	Yes
Storage Entries	Variable	256 bits
Supported Types	Docs	Docs
Has Interfaces?	Planned (Rust Traits)	Yes

Basic ink! contract - Flipper

The ink CLI automatically generates the source code for the "Flipper" contract, which is about the simplest "smart" contract you can build. You can take a sneak peak as to what will come by looking at the source code here:

#![cfg_attr(not(feature = "std"), no_std)]

use ink_lang as ink;

#[ink::trait_definition]
pub trait Flip {
    /// Creates a new flipper smart contract initialized with the given value.
    #[ink(constructor)]
    fn new(init_value: bool) -> Self;

    /// Flips the current value of the Flipper's bool.
    #[ink(message)]
    fn flip(&mut self);

    /// Returns the current value of the Flipper's bool.
    #[ink(message)]
    fn get(&self) -> bool;
}

#[ink::contract]
pub mod flipper {
    use super::Flip;

    #[ink(storage)]
    pub struct Flipper {
        value: bool,
    }

    impl Flipper {
        /// Creates a new flipper smart contract initialized to `false`.
        #[ink(constructor)]
        pub fn default() -> Self {
            Self::new(Default::default())
        }
    }

    impl Flip for Flipper {
        #[ink(constructor)]
        fn new(init_value: bool) -> Self {
            Self { value: init_value }
        }

        #[ink(message)]
        fn flip(&mut self) {
            self.value = !self.value;
        }

        #[ink(message)]
        fn get(&self) -> bool {
            self.value
        }
    }

    #[cfg(test)]
    mod tests {
        use super::*;

        #[test]
        fn default_works() {
            let flipper = Flipper::default();
            assert_eq!(flipper.get(), false);
        }

        #[test]
        fn it_works() {
            let mut flipper = Flipper::new(false);
            // Can call using universal call syntax using the trait.
            assert_eq!(<Flipper as Flip>::get(&flipper), false);
            <Flipper as Flip>::flip(&mut flipper);
            // Normal call syntax possible to as long as the trait is in scope.
            assert_eq!(flipper.get(), true);
        }
    }
}

The Flipper contract is nothing more than a bool which gets flipped from true to false through the flip() function.

Different Smart Contract Deployment

Smart contract deployment on Edgeware is a little different than on traditional smart contract blockchains.

Whereas a completely new blob of smart contract source code is deployed each time you push a contract on other platforms, Substrate optimizes this behavior. For example, the standard ERC20 token has been deployed to Ethereum thousands of times, sometimes only with changes to the initial configuration (through the Solidity constructor function). Each of these instances takes up space on the blockchain equivalent to the contract source code size, even though no code was actually changed.

In Edgeware, the contract deployment process is split into two halves:

Putting your code on the blockchain
Creating an instance of your contract

With this pattern, contract code like the ERC20 standard can be put on the blockchain a single time, but instantiated any number of times. No need to continually upload the same source code over and waste space on the blockchain.

Treasury Funding - Construction Projects

As part of Edgeware Builders Guild, we want to nurture healthy community builders and give opportunity to thrive through on-chain governance. If you're a builder, your project can be funded in various ways. The main way is through treasury funding through construction projects. Here, we are looking for particular interests like user interfaces, software development, system integration and research. The max amount of funding for technical grants is $100,000. Teams shouldn't seek to cover 100% of their early-stage funding via Edgeware grants alone.

Teams can apply for grants more than once, but they need to complete the previous project (as described in their application) before receiving additional funds. You can learn about process how to apply here. After your grant gets your project off the ground, you can apply to BuildDAO an on-chain incubator. Apply with an idea, get $50k to seed your startup or protocol on Edgeware.

You can review Edgeware Developer Deck, chat with guild members at Telegram and follow recent events among Edgeware community developers

Conclusion

Edgeware offers numerous opportunities to learn new language - ink!, brew your own idea and get initial funding to grow along with Edgeware community builders guild. If you are Solidity developer, it's worth noting that Edgeware supports EVM as well so you can apply with your existing dApp in Solidity for funding too! Come over and if you are curious to ask us questions at chat and let us know what you want to build and we can guide you through process to get funded.

References

https://docs.edgewa.re

https://contracts.edgewa.re

https://github.com/edgeware-builders/construction-projects

https://substrate.dev/docs/en/knowledgebase/smart-contracts

https://linktr.ee/edg_developers