Learn the fundamentals of blockchain development by building your own Polkadot-like state machine from scratch.

Welcome to the Rust State Machine tutorial.

This is a guided tutorial intended to teach readers the basics of Rust, Blockchain, and eventually the inner workings of the Polkadot SDK.

The hardest part of building your first blockchain using the Polkadot SDK is navigating the advance Rust features used by Substrate, and understanding the underlying magic behind various macros which generate code for you.

This tutorial directly addresses this by having you build a completely vanilla Rust project which does all the same tricks as the Polkadot SDK, so you know first hand what is going on behind the scenes.

Introduction to the Rust State Machine

In this section, we will build the very first logic for our state machine: a Balances Pallet.

This Pallet will manage the balances of users and allow them to transfer tokens to one another.

Along the way, you will learn about safe math, options, error handling, and more.

By the end of this section, you will have designed the logic of a simple cryptocurrency.

The Balances Pallet

In this section, you will create the System Pallet, a low level Pallet for managing basic blockchain state.

Then you will integrate both the Balances Pallet and System Pallet into your state transition function, called the Runtime.

The System and Runtime

In this section, we will be harnessing the full power of Rust to create a generic and configurable Runtime.

There will be no real logical changes happening in the next steps.

Instead, we will be gradually abstracting away the concrete types defined in our Pallets, and instead structure our code to handle purely generic types.

At the end of the section, you will have a project whose structure exactly mirrors what is found in the Polkadot SDK and understand how all of it works.

Generic and Configurable Types

In this next section, you will construct the core pipeline used to interact with your state machine.

We will create the block structure which contains the transactions for your state transition function, and then the function dispatch pipeline to route those transactions to the appropriate function calls.

The goal of this section is to make your existing state machine resemble a blockchain that can be extended and upgraded.

Executing Blocks and Dispatching Calls

In this section, we will create a Proof of Existence Pallet.

We will take advantage of all the refactoring we have done so far to make it very simple to integrate this new Pallet into our existing Runtime.

There are no new concepts to learn in this section, however it will test that you understand and can reproduce all the steps and concepts learned in the previous sections.

The Proof of Existence Pallet

In this section, we will introduce Rust Macros to our project to reduce boilerplate code and automate implementations.

By the end of this section, you will see how Rust Macros can automatically generate the code we have been writing, and why the Polkadot SDK uses this technique to improve developer experience and output.

Rust Macros

This workshop teaches Polkadot SDK's XCM via hands-on experience. Learn XCM basics: locations, assets, filters, asset holding, XCM instructions, XCM Executor, and Pallet XCM. Use XCM Simulator for practical scenarios.

Students will first go through, learn, and use all the fundamental building blocks for XCM:

1. [Location / Topography](location.md)
	- Learn how to construct relative and absolute locations for common objects and types used in XCM.
2. Assets and Filters
	- Learn how to represent various types of assets like fungible tokens and non-fungible tokens.
	- Constructing asset filters to target pools of assets.
3. Asset Holding
	- Learn how we can manage multiple assets in memory using the `AssetsInHolding` abstraction.
4. Instructions
	- Construct common XCM messages through individual XCM instructions.
5. The XCM Executor
	- Learn how the XCM Executor actually functions, and loosely implement a few common instructions needed to complete end to end scenarios.
6. Pallet XCM
	- Learn how Pallet XCM provides a simple to access wrapper to the underlying XCM Executor to perform common tasks like send, execute, and teleport transfers.



XCM Workshop

The XCM Executor

Pallet XCM

Learn how to build your own custom DEX pallet using the Polkadot SDK with this comprehensive step-by-step tutorial.

This tutorial aims to provide a step-by-step approach, empowering you to create a custom DEX within the Polkadot ecosystem.

It is highly recommended that you complete the tutorial
on Rust State Machine before you begin this tutorial to get an understanding of the general features on Substrate.

Introduction to Building a Decentralized Exchange (DEX) Pallet with the Polkadot SDK

To implement the liquidity pool functionality, we'll learn how to store and manage liquidity pools on-chain. In Substrate, we can utilize the powerful storage capabilities provided by the framework to achieve this.

Using generic types, Substrate provides a powerful and flexible framework for blockchain development, enabling projects to adapt and innovate without being constrained by fixed type definitions.

Generic Types in Substrate

Substrate provides a powerful and flexible storage system that allows you to store and retrieve data on the blockchain.


Substrate Storage

Object-oriented design principles, such as encapsulation and modularity, are essential when building complex systems like a decentralized exchange (DEX) pallet in Substrate.

Object Oriented Design

In Substrate runtime pallet development, using safe math is crucial to ensure the stability and security of your
blockchain network. When dealing with arithmetic operations, especially those involving user input or storage values,
it's important to handle potential overflow or underflow situations gracefully.


Safe Math

Now that we have the `mint` and `burn` methods implemented, let's add the main functionality to swap tokens in our DEX. DEX exchanges, such as Uniswap V2.0 charged a 0.3% fee per swap, so we'll want to implement
it as well.


Floating Point Arithmetic

Now, that we have the necessary methods implemented in our `liquidity_pool`. Let's define pallet calls that will call
these methods.


Courses

Rust State Machine: Basic Concepts for Blockchain Development

XCM Workshop (Alpha)

Build your own DEX (Decentralized Exchange)