Solidity

Learn Solidity Advanced

This course is built for readers who already write working contracts and want to know what separates a working contract from a trustworthy one. Every lesson keeps the same shape as the earlier Solidity courses: a short definition, small examples with outputs produced by the real toolchain, and one closing example that pulls the pieces together. Nothing here runs on a real chain or touches real funds. Every pool, feed, bridge, and ballot is a small hand-written toy that runs on a local test chain, so each claim can be checked exactly.

The course moves in a deliberate order. It opens with review: how to audit a contract in passes, how to name what each actor must never be able to do, and how to prove a property holds after every call sequence rather than after one lucky test. Then it turns to the forces that act on a live contract from outside: transaction ordering, signature tricks, and upgrade pressure. Only after those come the systems a contract lives inside: lending pools, price feeds, bridges, votes, and token supplies.

By the end you will have built three full projects from scratch: a lending protocol with interest and liquidation, a governance treasury that only pays out through voted and time-locked proposals, and a yield vault that splits gains fairly between early and late depositors. Each one is tested the same way the small examples are, with exact balances and exact outcomes.

What you will learn

The forty-five lessons cover ten areas, each one ending in code you can run and check:

• Audit and formal methods: review passes, threat models, denial-of-service defenses, formal properties, deeper invariant testing, and a survey of common vulnerability pairs.
• MEV and frontrunning: how transaction order changes trade prices, minimum-out and deadline defenses, and commit-reveal schemes that hide intentions until they cannot be copied.
• Signatures and accounts: ECDSA recovery with the standard message prefix, replay protection with nonces, meta-transactions submitted by relayers, and contract accounts at a first look.
• Advanced upgradeability: UUPS upgrades in depth, transparent versus UUPS routing, storage gaps that keep upgrades from corrupting state, the diamond pattern, and beacon proxies.
• Assembly and gas mastery: Yul at a first look, inline assembly with memory and storage operations, manual bit-packing, calldata techniques, and reading real gas figures from captured runs.
• Advanced DeFi: constant-product swap math with fees, flash loans that must repay inside one transaction, oracle design with staleness checks, TWAP and median defenses against price manipulation, liquidation, and lending design.
• Cross-chain concepts: lock-and-mint bridges, message passing with replay protection, wrapped assets, and the relayer-quorum rules that keep a bridge from minting tokens nobody locked.
• Governance in depth: vote weighting, quorum and thresholds, delegation of voting power, timelocks that delay execution, and the full proposal lifecycle from vote to payout.
• Tokenomics design: vesting schedules with cliffs, emission rates with caps, fixed and percentage fee models, and a comparison of the three levers side by side.
• Three projects: a lending protocol, a governance treasury, and a yield vault, each assembled from the patterns taught earlier in the course.

Who this Solidity Advanced course is for

This course expects the intermediate course behind you, whether you took it here or learned the same material elsewhere. It is also for readers who already write contracts with inheritance, proxies, tokens, and tests and want the expert layer on top. If terms like delegatecall, allowance, and linearisation are already comfortable, you are ready. If they are not, the intermediate course teaches them first and this course assumes them without re-teaching.

It suits developers who review other people’s contracts, builders preparing a protocol for real users, and curious readers who want to understand why headlines about drained pools and hijacked upgrades keep happening. The lessons explain each failure mode with a small contract that shows it, then a fixed version that proves the repair.

It is not a course about trading, investing, or picking tokens. Prices here are toy numbers set by a mock feed, pools hold toy tokens, and no lesson claims anything about any real asset, chain, or market.

How this course works

Each lesson is short, most taking three or four minutes. You read a plain-words definition, then two or three focused examples, then one closing program that combines the lesson’s ideas. Every example’s stated output was produced by running the code through Foundry with solc 0.8.30, twice, and comparing the runs byte for byte. The outputs on the page are the real run outputs, including their gas figures, captured rather than predicted.

Exercises close every lesson with four options and exactly one correct answer, plus a short explanation of why. The correct position moves from lesson to lesson, so reading beats guessing. Short sentences and one idea per sentence carry over from the earlier courses, and every new term is defined in plain words where it first appears.

Work through the lessons in order. Later lessons reuse earlier ones without apology: the lending project leans on liquidation and interest, the treasury leans on delegation and timelocks, and the vault leans on share math and fees. Skipping ahead works only if you already know the pattern being reused.

Frequently asked questions

Is this Solidity Advanced course free?

Yes. Reading every lesson costs nothing, and following along needs no account, wallet, or payment.

Do I need the intermediate course first?

You need its knowledge, whether you got it here or elsewhere. This course uses inheritance, proxies, token standards, reentrancy guards, and Foundry tests from the first lesson onward and does not re-teach them. Readers who are unsure should take the intermediate course first.

Does anything here spend real ether or touch a live chain?

No. Everything runs on a local test chain with toy tokens and mock price feeds. No lesson sends a real transaction, names a real token or price, or asks you to connect a wallet.

What is a flash loan, in one paragraph?

A flash loan is a loan that must be borrowed, used, and repaid, plus a fee, inside a single transaction. If the repayment does not arrive before the transaction ends, the whole transaction reverts as if it never happened. The course proves both halves on a toy pool: a good receiver repays and keeps a margin, and a bad receiver makes the outer call revert with the pool unchanged.

How much time does this Solidity Advanced course take?

The lessons add up to 164 minutes, about two and three-quarter hours of reading and working through examples. Most lessons take three or four minutes, and the three projects take six or seven minutes each.

What should I learn after Solidity Advanced?

System Design Advanced fits naturally next: it plans the servers, queues, and data stores a contract sits inside once real users arrive. Python Advanced is handy for the off-chain scripts that probe, deploy, and watch contracts. And the intermediate Solidity course stays worth re-reading, since its patterns read differently once you know what the expert layer does with them.

Next steps

• System Design Advanced ❯ — Planning the product around the contract: servers, queues, caches, and data stores, and how load and failure move through them once real users arrive.
• Python Advanced ❯ — A sharper scripting language for the off-chain side of contract work: probing ideas, shaping data, and automating the checks around a deployment.
• Solidity Intermediate ❯ — The foundation this course stands on. Its inheritance, security, gas, token, and DeFi patterns read differently once you know the expert layer built above them.