مسترکلاس توسعه بلاکچین سولانا با زبان Rust

0. Introducing Rust & Its Features

1. Getting Started

1.1 Installation

1.2 “Hello, World!”

1.3 “Hello, Cargo!”

2. Common Programming Concepts

2.1 Variables & Mutability

2.2 Data Types

2.3 Functions

2.4 Control Flow

3. Understanding Ownership

3.1 What’s Ownership?

3.2 References & Borrowing

3.3 The Slice Type

4. Using Structs

4.1 Defining & Instantiating

4.2 An Example

4.3 Method Syntax

5. Enums & Pattern Matching

5.1 Defining an enum

5.2 The match Construct

5.3 if let

6. Packages, Crates & Modules

6.1 Packages vs. Crates

6.2 Defining Modules

6.3 Paths & Bringing into Scope

6.4 Separating Modules

7. Common Collections

7.1 Vectors & Lists

7.2 UTF-8 Strings

7.3 HashMaps & Keys

8. Error Handling

8.1 panic!

8.2 Recoverable Errors

8.3 When (Not) to panic!

9. Generic Types

9.1 Removing Duplication

9.2 Generic Data Types

9.3 Traits

9.4 Validating References

10. Writing Automated Tests & Debugging

10.1 Advanced Rust Testing (unit, integration, mocks, fixtures)

10.2 On-Chain Debugging (solana-test-validator, LLDB/GDB)

11. Iterators & Closures

11.1 Closures

12.2 Iterator Adapters & Consumers

12. More about Cargo & crates.io

12.1 Customizing Builds

12.2 Publishing a Crate

12.3 Cargo Workspaces

12.4 Installing Binaries

12.5 Extending Cargo

13. Smart Pointers

13.1 Box<T>

13.2 Testing Smart Pointers

14.3 The Drop Trait

13.4 Rc<T> & Reference Counting

13.5 Interior Mutability

13.6 Reference Cycles

14. Fearless Concurrency

14.1 Threads

14.2 Message Passing

14.3 Shared-State Concurrency

14.4 Extensible Concurrency

15. Object-Oriented Programming in Rust

15.1 OOP Characteristics

15.2 Trait Objects

15.3 Implementing a Design Pattern

16. Patterns Everywhere

16.1 Where Patterns Can Be Used

16.2 Pattern Syntax & “Reputability”

17. Advanced Rust Features

17.1 unsafe Rust

17.2 Advanced Traits

17.3 Advanced Types

17.4 Advanced Functions

17.5 Macros

18. Project: Building a Multi-Threaded Web Server

19. Project: Creating a REST Web Service

20. Building a Custom Blockchain

20.1 Technical Requirements

20.2 Project Planning

20.3 Creating the Genesis Block

20.4 Helper Functions

21. Adding More Blockchain Features

21.1 Connecting Blocks

21.2 Starting a Node Server

22. Finishing Up the Blockchain

22.1 Memory Pools

22.2 Transactions

22.3 Wallets

22.4 Configuration & Usage

23. Live Workshop: End-to-End NFT Mint + Marketplace

23.1 SPL-Token/NFT mint program in Rust

23.2 React UI + Phantom integration

24. Using Foundry

24.1 Introducing Foundry

24.2 Exploring the Tooling

24.3 Testing & Deployment

24.4 Mini Project

25. Solana Foundations

25.1 Proof-of-History & Tower BFT

25.2 Runtime & Accounts Model

25.3 Transaction Lifecycle & Logging

26. Anchor Framework Deep Dive

26.1 IDLs & Codegen

26.2 Program-Derived Addresses (PDAs)

26.3 Cross-Program Invocations

26.4 Anchor’s Testing Harness

27. Workshop: Anchor Testing Clinic

27.1 Spin up anchor test-validator

27.2 Write TypeScript integration tests

28. Cryptography & Token Standards

28.1 Ed25519 Keypairs & Signing

28.2 SPL Token Program (mint, burn, multisig)

28.3 Metaplex NFT Standard Basics

29. Client-Side Integration & Tooling

29.1 @solana/web3.js Usage

29.2 Wallet Adapter (Phantom, Solflare…)

29.3 React/Next.js dApp Patterns

30. Workshop: Performance Profiling & Optimization

30.1 cargo bench-sbf walkthrough

30.2 Struct packing & compute-unit tuning

31. Async Rust & Runtime Performance

31.1 async/await in no_std

31.2 Compute & Memory Profiling

31.3 Minimizing Fees & Instruction Costs

32. Performance Tuning & Optimization

32.1 Instruction-count Benchmarks

32.2 BPF Memory Footprint Analysis

32.3 Data-Layout & Allocation Strategies

33. Security Best Practices & Auditing

33.1 Common Pitfalls (overflows, missing checks)

33.2 Fuzzing & Static Analysis (clippy, cargo-fuzz)

33.3 Replay Protection & Nonces

34. Workshop: Security Audit Clinic

34.1 Pentest a toy lending protocol

34.2 Apply static/fuzzing tools

35. CI/CD, Deployment & DevOps

35.1 GitHub Actions: lint, build, test, deploy

35.2 Dockerized Local Validators

35.3 Release Management & Versioning

36. Advanced dApp Patterns

36.1 On-Chain Governance & DAOs

36.2 Bridges & Cross-Chain (Wormhole)

36.3 Oracles & Data Feeds

37. Self-Paced Practice Project: DAO Voting Module

37.1 Proposals, voting, tallying on-chain

38. Self-Paced Practice Project: Cross-Chain Bridge Stub

38.1 Solana + another chain + Rust relayer

39. Building a dApp on Solana

39.1 Environment Setup

39.2 Boilerplate & Frameworks

39.3 Accounts, Instructions & Logic

39.4 Tests & Local Validator Runs

40. Building a dApp on NEAR

40.1 Fundamentals & Advanced Concepts

40.2 First Project

41. Integrating Blockchain with Other Technologies

41.1 IPFS/Arweave for Storage

41.2 GraphQL/REST Backends

41.3 WebSockets for Real-Time Updates

42. Industry Case Studies & Real-World Examples

42.1 Anatomy of a Solana DeFi Protocol

42.2 NFT Marketplace Deep Dive

42.3 DAO Governance Rollouts

43. Self-Paced Practice Project: Real-Time On-Chain Chat

43.1 WebSockets + @solana/web3.js

44. Self-Paced Practice Project: Indexed DeFi Dashboard

44.1 Deploy AMM, GraphQL indexer, React dashboard

45. Deep-Dive Seminar: Zero-Knowledge Proofs on Solana

45.1 Circom integration, ZK-SNARK primer

46. Deep-Dive Seminar: Wormhole & Cross-Chain Internals

46.1 VAA, guardians, minimal relay component

47. Deep-Dive Seminar: Advanced Token-Economics Design

47.1 ve-token models, incentive workshop

48. Deep-Dive Seminar: In-Depth Substrate Pallet Development

48.1 Custom pallet, local node integration

49. Deep-Dive Seminar: IPFS/Arweave for Web3 Storage

49.1 Content addressing deep dive, hands-on pinning

50. Exploring Polkadot, Kusama & Substrate

50.1 Polkadot Core Concepts

50.2 Kusama Overview

50.3 Substrate Deep Dive

51. Hands-On with Substrate

51.1 Building Your Own Blockchain

51.2 Simulating a Network

52. Deep-Dive Seminar: Token-Relayer Meta-Transaction Pattern

52.1 Gasless tx pattern, relayer security

53. Deep-Dive Seminar: GraphQL Indexing with The Graph

53.1 Schema design, subgraph deploy, queries

54. Future of Rust & Web3

54.1 Emerging Rust Web3 Projects

54.2 The Road Ahead for Blockchains