diff --git a/Lessons/English/L_EARN/CryptoCurrencies/Polkadot/LCP2:What_Is_Substrate.md b/Lessons/English/L_EARN/CryptoCurrencies/Polkadot/LCP2:What_Is_Substrate.md new file mode 100644 index 00000000..9440e513 --- /dev/null +++ b/Lessons/English/L_EARN/CryptoCurrencies/Polkadot/LCP2:What_Is_Substrate.md @@ -0,0 +1,138 @@ +# Lesson 2: What is Substrate? + +In this lesson you will learn about Substrate: the next generation framework for building blockchains. +At the end of this lesson, you can submit a request and get tested on your knowledge for a reward. +This lesson has 4 main sections and a practice section. + +The lesson is designed to point you to various resources that will help you understand some fundamental concepts in Substrate. +The contents in these resources contain a lot more information than the write-up of this lesson. +You are expected to explore these by following each hyperlink and reading the required reading before moving onto the next section. + +## High level and architecture + +> Required reading: +> +> - [**Using Substrate**](https://docs.substrate.io/v3/getting-started/overview/#usage) +> - [**Node architecture**](https://docs.substrate.io/v3/getting-started/architecture/) + +At a high level, [Substrate](https://substrate.io/) gives developers the ability to build application specific blockchains. +By design, these blockchains can become parachains or parathreads to [the Polkadot relay chain](https://polkadot.js.org/apps/#/explorer). +However, some blockchain implementations may prefer to be standalone chains (or "solo-chains") with their own relay chain implementation. + +### Network layers + +It helps to think about the types of network layers we're talking about when looking at what Substrate can enable in terms of building "Polkadot-like networks". + +- **Layer 0** - Relay chain blockchains like Polkadot are considered as "layer-zero" blockchains. + That's because they provide the networking and consensus protocols designed to connect and secure application specific blockchains that want to benefit from sitting ontop of. + +- **Layer 1** - Application specific blockchains that are connected to an underlying network layer. + For example, [Polkadot currently has Statemint](https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fpolkadot.api.onfinality.io%2Fpublic-ws#/parachains) as its first parachain. + This parachain's sole application domain is to provide a layer for anyone to mint fungible and non-fungible assets. Check it's source code [here](https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fpolkadot.api.onfinality.io%2Fpublic-ws#/parachains). + +- **Layer 2** - Business logic ontop of the application specific blockchain. + This could be the additional pallets or smart contracts of a chain. + +Each of these layers can be built using Substrate. This implies: + +- Substrate allows customizing logic on the Node and client level (core libraries). +- Substrate provides ways to customize on-chain governance and lower-level consensus mechanisms (consensus libraries). +- Substrate can be used to write a blockchain's application business logic and smart contracts (FRAME libraries). + +This gives developers building with Substrate (or "runtime engineers") a lot of freedom in terms of extending low level blockchain capabilities or customizing higher-order logic. + +For any of these layers, developers can use FRAME: a crate system that make it easy to write pallets for Substrate blockchains. +For smart contract logic, developers can use ink!: an [eDSL](https://wiki.haskell.org/Embedded_domain_specific_language) to write smart contracts in Rust for blockchains built with [Substrate](https://github.com/paritytech/substrate). +There are lots of other efforts that enable to write smart contracts and smart contracting tooling for Substrate chains. + +## What are Pallets? + +> Required reading: +> +> - [**FRAME primitives**](https://docs.substrate.io/v3/concepts/runtime/#frame-primitives) +> - [**Section on FRAME and Pallets**](https://docs.substrate.io/v3/runtime/frame/#pallets) + +All the capabilities of a Substrate node's runtime comes from various "pallets", each of which is designed to fullfill a set of tasks. +For example, Polkadot has [46 pallets at the time of writing](https://polkadot.subscan.io/runtime). +A pallet can perform highly customizable logic designed to execute according to the rules of the blockchain. +[FRAME](https://docs.substrate.io/v3/runtime/frame/) makes it easy for developers to build the application specific logic of their runtime. + +## What's the difference between a Smart Contract and Pallet? + +> Required reading: +> +> - [**Smart contract toolkits**](https://docs.substrate.io/v3/runtime/smart-contracts/) +> - [**ink! vs. Solidity**](https://paritytech.github.io/ink-docs/ink-vs-solidity) + +There is common confusion around whether to build a smart contract or a pallet; a dApp or a blockchain. +The material in the required reading section will help you get a better understanding of the tradeoffs and advantages of choosing one over the other — even though they are not mutually exclusive! + +## Why Rust ? + +> Required reading: +> +> - [**Cargo and crates.io**](https://doc.rust-lang.org/book/ch14-00-more-about-cargo.html) +> - [**Rust blog post**](https://thenewstack.io/rust-by-the-numbers-the-rust-programming-language-in-2021/) +> - [**Why Rust for smart contracts?**](https://paritytech.github.io/ink-docs/why-rust-for-smart-contracts) +> - ***All** of the hyperlinks in this section* + +Beyond the fact that Rust provides high performance, type safety and memory efficiency, it provides Substrate with unique characteristics. Generally speaking, these are: + +- [**Cargo**](https://doc.rust-lang.org/cargo/guide/why-cargo-exists.html). This is Rust's package management tool, also containing CLI tools for running tests, building documentation, benchmarks and more. + +- [**Crates.io**](https://crates.io/). This is Rust's community managed package registry. +Any Rust developer can publish their crates there for others to use in their projects. +This is useful to make Substrate accessible to developers and for developers to reuse existing modules in their projects. + +- [**Types, traits and generics**](https://doc.rust-lang.org/book/ch10-00-generics.html). Rust has a sophisticated [trait system](https://doc.rust-lang.org/book/ch19-03-advanced-traits.html) that helps developers make use of Substrate's many layers of abstraction. + +- [**Metaprogramming**](https://doc.rust-lang.org/book/ch19-06-macros.html). Substrate uses macros to introduce the concept of "metaprogramming" to its codebase, i.e. writing code that writes code. +For example, [FRAME uses macros](https://docs.substrate.io/v3/runtime/macros/) to alleviate the need to write the heavy lifting code that is required for a pallet to integrate into a runtime. +Similarly, [ink!](https://paritytech.github.io/ink-docs/) uses macros to handle common type creations and functions. + +- [**Webassembly**](https://webassembly.org/). Rust compiles to executable Wasm (Webassembly) byte code, enabling Substrate runtimes to also compile to Wasm. +Beyond beign a powerful "next-generation web" technology, for Substrate, having Wasm at the core of its design means a few very specific things: + - **Upgradability**. First and foremost, Wasm is a key piece of technology for [forkless runtime upgrades](https://docs.substrate.io/v3/runtime/upgrades/). + - **Portability**. Wasm has use cases in selecting validators in cross chain consensus between relay-chain and parachains. + - **Smart contract compatibility**. Any Smart Contract that compiles to Wasm can be executed by a compatible Substrate node. See a [list of key advantages of having Wasm smart contracts](https://paritytech.github.io/ink-docs/why-webassembly-for-smart-contracts). + - **Light-client ready**. Wasm is also a key piece in how all Substrate chains are [light-client ready out of the box](https://paritytech.github.io/substrate-connect/#wasm-light-clients). + +## Practice + +### Install cargo + +Complete this [guide on getting started with Cargo](https://doc.rust-lang.org/cargo/getting-started/first-steps.html). + +### Clone a copy of Substrate + +1. Get a local copy of the [Substrate](https://github.com/paritytech/substrate) codebase. +1. Under the [FRAME folder](https://github.com/paritytech/substrate/tree/master/frame), pick a pallet that interests you, `cd` into it and look through its code. +1. Run the tests for that pallet using `cargo test`. +1. Build and open the docs using `cargo doc --open`. + + +## Testing + +After completing this lesson, let us know when you are ready to take the test. +The tester will ask you questions about the material and gauge whether you pass the test or not based on your understanding of the material in this lesson. +You will also be asked to show what you learned from completing the [practice section](#Practice). +The reward for passing is 0.2 DOT. + +## Resources + +* [Substrate developer hub](https://docs.substrate.io/) +* [Rust book](https://doc.rust-lang.org/book/) +* [Subtsrate codebase](https://github.com/paritytech/substrate) + +------------------------------------------ + +*Are you contributing here as an author for this L_EARN resource? +Make sure to add your name, the commit hash of your contribution and your DOT or ETH tipping address below so that others can spread their love ❤️.* + +| Author | Tip Jar Address | Commit | +|----------|:---------------:| -------:| +| Sacha | 1wBg4LZz2rALV9z2awLnrUQLGmfjhx2Fa6F6nGGd46m2q3K | [`1238`][contributor-commit-1]| + + + +[contributor-commit-1]: https://github.com/BlockDevsUnited/learn-and-earn/commit/12388d51a204bfceebc85c676def44604168aafb \ No newline at end of file diff --git a/Lessons/English/L_EARN/CryptoCurrencies/Polkadot/LCP3:Kitty_Frontend_Hacking.md b/Lessons/English/L_EARN/CryptoCurrencies/Polkadot/LCP3:Kitty_Frontend_Hacking.md new file mode 100644 index 00000000..0f6fe785 --- /dev/null +++ b/Lessons/English/L_EARN/CryptoCurrencies/Polkadot/LCP3:Kitty_Frontend_Hacking.md @@ -0,0 +1,27 @@ +# Lesson 3: Kitty Frontend Hacking + +In this lesson, you will learn all the basics of Substrate and FRAME and writing a custom pallet. +You will build a Substrate node, run it and connect it to a front end running in your browser. + +## Build the Substrate Kitties node + +Complete the [Kitties tutorial](https://docs.substrate.io/tutorials/v3/kitties/pt1/). +There's a lot of good material there that will teach you how to build a pallet from scratch. +Make sure you understand what the code is doing before moving from one section to the next. + +## Launch the Kitty front end + +Complete [this tutorial](https://docs.substrate.io/tutorials/v3/kitties/pt2/) to learn how to create React components for the Substrate Kitties chain you built. + +## Task + +1. Rename your Substrate Kitties node and pallet functions. We want to see that your blockchain was built by you and not just copy pasted from the solution. +Find places that you can customize to make it more you. +1. Write logic in the `KittyCards.js` component that adds a button to allow a user to breed two Kitties. +1. Add some other customization of your choice (for example, a new layout, different UI components, different avatars..). + +## Testing + +After completing this lesson, let us know when you are ready to take the test. +The tester will verify the tasks you've completed and ask you questions. +The reward for passing is 0.4 DOT.