Do the first steps with this tutorial, on the Polkadot API, a powerful tool for interacting with the Polkadot network.

Welcome to the first interactive tutorial of the new Polkadot API.

This is a guided tutorial intended to teach readers how to set up, use and interact with Substrate based chains by using the new [Polkadot-API](https://github.com/polkadot-api/polkadot-api).


Introduction to the new Polkadot API

Polkadot API: An Introduction to multi-chain

Learn the entry level concepts to develop your app on Polkadot by building an NFT marketplace.

Welcome to the Substrate Collectables Workshop.

The goal of this tutorial is to **teach by experience** various entry level concepts around developing with the [Polkadot SDK](https://github.com/paritytech/polkadot-sdk).

This tutorial will walk you through the steps of building an NFT Marketplace, themed around collectable digital pets called Substrate Kitties!

Let's get started!


Introduction

Now that we have covered the basics of Pallets and gone through all of the template code, we can start writing some code ourselves.

In this section you will learn the basics of creating and using storage in your Pallet, including creating and using storage values and storage maps.


Storage Basics

Now that we have covered the basics of Pallet storage, we can look into more advance storage patterns.

In this section, you will learn how to store objects and use multiple storage items to work together to track data on your chain.


Storing Objects

Using all of the information we learned about Pallet storage, we have completed the logic needed to create new kitties.

In this section, we will create the logic that enables a marketplace, where you can: transfer, sell, and buy kitties.


Kitty Marketplace

Substrate Kitties: Build Your Own NFT Marketplace

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

Rust State Machine: Basic Concepts for Blockchain Development

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

Polkadot API: An Introduction to multi-chain

Substrate Kitties: Build Your Own NFT Marketplace

Rust State Machine: Basic Concepts for Blockchain Development

Build your own DEX (Decentralized Exchange)