Advanced Solidity: Yul and Assembly

Name: Advanced Solidity: Yul and Assembly
Rating: 4.9 (407 reviews)

Understanding what solidity does behind the scenes

Highest Rated

Created byJeffrey Scholz

Last updated 9/2022

English

English [Auto],

What you'll learn

How to create Ethereum smart contracts in assembly
How to respect solidity's memory and function call conventions when using assembly
How smart contracts work on the bytecode level
How to create a smart contract entirely in Yul and assembly

Course content

4 sections • 26 lectures • 1h 47m total length

Introduction3:23
Types5:18
Basic Operations6:21
Explore basic operations in yul-style solidity, including for loops and if statements, a prime-check function using modulus on 32-byte words, and truthiness without booleans.
Storage Slots7:08
Master reading and writing storage with sload and sstore, explore slot and offset, and see how packing variables into the same slot affects access and security.
Storage Offsets and Bitshifting9:22
Storage of Arrays and Mappings6:32

Memory Operations4:43
Errata: The illustration at 2:37 should have the array finishing as 0x1c, 0x1d, 0x1f as it is in hex, not decimal.
How Solidity Uses Memory8:35
Dangers of Memory Misuse1:49
Return, Require, Tuples and Keccak2564:03
Explore how memory handles data larger than 32 bytes in youll, using explicit memory addressing to return and hash data with keccak256, including scratch space and free memory pointer.
Logs and Events2:55

Calldata3:48
Discover calldata in ethereum smart contracts, including function selectors and ABI-encoded arguments, how arbitrary transaction data is structured and gas costs are affected.
Calling other contracts7:11
Dynamic Length Arguments3:30
Transfer of value4:33
Receiving contract calls4:39
Learn to imitate a solidity contract in fuel using yul, handling call data, function selectors, and a switch statement, calling get two or get 99, with leave and return semantics.

100% Yul Contract2:35
Explore building a 100% Yul contract with an all-in constructor, using memory slots and data markers, compiling with yield, and interfacing for testing on remix.
Etherscan Issues3:07
Deploy to Rink B and inspect etherscan verification challenges when using yul versus solidity, and prefer writing in solidity with assembly only for small, gas-efficient functions.
Storing data in contract bytecode0:53
ERC20 Example Part 12:23
Illustrate an ERC-20 example showing constructor storage, function selectors, balance and total supply operations, and non-payable calls with memory and storage access and return behavior.
ERC20 Example Part 24:06
ERC20 Example Part 32:30
ERC20 Example Part 40:59
Explore how balanceOf loads a user's ERC20 balance by computing a storage offset from the address into a mapping, using hex 1000, and returning the balance.
ERC20 Example Part 51:56
ERC20 Example Part 63:28
Examine ERC20 approval via OpenZeppelin, detailing owner and spender allowances and transferFrom. See how storage slots, hashing, and memory choices influence gas efficiency and contract clarity.
What We Didn't Cover2:11
Explore rarely used signed arithmetic in yul and assembly, including signed division, modulus, comparisons, and signed shifts, with sign extension and EVM 32-byte word handling.

Requirements

Experience with Solidity

Description

If you've wondered what solidity is doing behind the scenes, this is the course to take. Perhaps you've head of assembly in Ethereum smart contracts and heard it can be efficient but dangerous. After you finish this course, you will have a ground-up understanding of what exactly happens when a smart contract receives a function call, how it encodes that data, where exactly it stores it, and how it updates the blockchain state. Even if you don't write contracts in assembly, you will have a much better understanding of solidity's design choices and previously cryptic error messages will make perfect sense.

We will learn how solidity represents various data types, and how we can come up with more efficient representations ourselves depending on the application. We will learn the assumptions solidity makes about memory layout and how to avoid violating those assumptions when we use low level instructions. We will learn what happens behind the scenes when smart contracts make function calls to each other, and how to implement that protocol by hand. And of course, we will build smart contracts from scratch in assembly.

Nobody can claim to be an expert in solidity without mastering assembly (also known as Yul). So if mastery is your goal, take this class!

Note: This class is not for beginners. You should be very comfortable with solidity before taking this course.

Who this course is for:

Advanced Solidity programmers looking to master the subject

Advanced Solidity: Yul and Assembly

What you'll learn

Explore related topics

Course content

Introduction6 lectures • 38min

Memory5 lectures • 22min

Inter-contract Calls5 lectures • 24min

Contracts Without Solidity10 lectures • 24min

Requirements

Description

Who this course is for: