Trees & Tries

Introduction to tries

Radix/Patricia trees

Implement a Patricia tree

RLP encoding

Merkle Patricia Trees

Implement a Merkle Patricia Tree

Tries in the EVM

Account types

Account structure & Storage Tries

Build an Account Storage Trie

World State Tries

Build a World State Trie

Transaction Tries

Build a Transaction Trie

Transaction Receipt Tries

Build a Transaction Receipt Trie

Blocks in the EVM

EVM block structure

Define an EVM block header

Abstract Machines

Build a stack machine

Build a machine with linear memory

Build an EVM-like state machine

Opcodes & Bytecode

Compute gas cost from opcodes

Interpret EVM bytecode

Introduction

Introduction to Programming Embedded Financial Systems

Solidity

Solidity classes and syntax

Solidity functions

Build a "Hello World" contract

Simple Data Types

Solidity's primitive data types

Math and operations in Solidity

State, local, and global variables

Build a basic calculator

Arrays in Solidity

Strings in Solidity

Addresses in Solidity

Language Constructs

Constructors in Solidity

Contract creation

`view` and `pure` functions

Immutability and constants

Getters and setters

Conditionals and loops

Number storage contract

Advanced Data Types

Mappings in Solidity

"Points" on the blockchain

Enums in Solidity

Structs in Solidity

Rock-Paper-Scissors game

Optimization

Data locations for local variables

Optimizing contracts to save gas

Gas-optimize a simple contract

Time

Time in Solidity

Create an on-chain forum ("EVM Reddit")

Events & Errors

Emitting events

Abstract contracts with access control

Error types

Error handling & assertions

Try/catch

Modifiers

Function modifiers

Cool-down time modifier

Money

`fallback` and `receive` functions

Money units in Solidity

Moving money

Donation wallet

Practical Products

Escrow contracts

Build an escrow contract

Lottery smart contracts

Build a lottery game

Multi-sig wallets

Build a multi-sig wallet

Randomness

Hashing with `keccak256`

Pseudo-random number generation

"Jackpot" game

Inheritance

Inheritance in Solidity

"Owned" contracts

Parent functions & multiple inheritance

Interfaces & abstract contracts

Libraries

Libraries in Solidity

Create an iterable mapping

Importing other Solidity files

Useful imports

Using OpenZeppelin's utilities

Application Binary Interfaces

ABIs for function calls

Write a function-call ABI encoder

Cross-Contract Invocation

High- and low-level calls

Make low-level calls

`delegatecall` and `staticcall`

Multi-`delegatecall`

Assembly

Inline assembly

Using `ecrecover`

Verifying off-chain signatures

`selfdestruct`

`selfdestruct` and why not to use it

"Guess the hash" game

Proxy Patterns

Proxy contracts

Minimal proxy contracts

Testing & Deployment

Introduction to Hardhat

Write test cases with Mocha and Chai

Smart contract testing

Fuzz and vulnerability testing

Deploying smart contracts

Conclusion

Introduction

Introduction to Applications of Decentralized Technologies

Tokens

ERC-20 tokens

Create an ERC-20 token

ERC-721 tokens

Create an ERC-721 token

ERC-721 extensions

Image-based NFTs

Token Extensions

Creating ERC-20 tokens with OpenZeppelin

"TaxCoin" with OpenZeppelin

ERC-721a

DAO Tooling

Introduction to DAOs

Juicebox

Crowdfunding contracts

Snapshot & off-chain governance

Multi-sig wallets for DAOs

Create a vesting contract ("Carta for DAOs")

Value-locked contracts

Oracles

Introduction to oracles

Double-or-Nothing with true randomness

Decentralized Finance

Introduction to DeFi

Stablecoins

ETH-based algorithmic stablecoins

DeFi staking & yield farming

Staking tokens with rebasing

Liquid staking

Build a liquid staking coin

DEXes

AMMs & liquidity pools

Collateralized debt positions (CDPs)

Conclusion

Conclusion to Applications of Decentralized Technologies