Solidity Bootcamp

After teaching hundreds of developers, we’ve seen that some knowledge gaps in the Solidity language are surprisingly common. For example, we’ve seen a lot of developers don’t know the exact mechanics behind low-level calls and interface calls or how exactly try catch works. This part of the course focuses on aspects of Solidity that seem to not be covered well in existing online materials. If you have gaps in your understanding of Solidity, you will have a harder time reading production codebases and understanding how DeFi protocols work.

A good Solidity developer must be able to code an ERC-20 from scratch from memory and be fluent in creating fundamental token mechanisms such as tracking staking rewards, conducting an auction, or splitting up tokens among multiple parties. We’ve found that many Solidity devs take several minutes to write token routines that ought to be second nature. This part of the course ensures that token mechanics become second nature. Why? Tokens are everywhere in DeFi, even “token-like” mechanics recur frequently. However, not all tokens behave exactly the same way. It must be second nature for a developer to know how a token should behave and where there may be some variation in the behavior.

Math is fundamental to DeFi (finance and math go together!) but few learn how to use Solidity math properly. For example, one might compute the “average” of x, y, and z by computing (x + y + z) / 3, but this fails because the code will revert for some inputs (cases where x + y + z overflows). Similarly, how does one go about computing an exponent of Euler’s constant e (which appears in several financial formulas)? What is the difference between a fixed-point number and a Q-number? Students must master these subjects through repeated hands-on application as without knowing how math is done in Solidity, reading and writing production codebases in DeFi will be extremely challenging.

Any non-trivial DeFi application needs a way to track which depositors are owed what based on when they deposited and how much the protocol has gained or lost. It isn’t feasible to loop through each account and update each one. Optimizations that allow all accounts to be updated simultaneously have subtle gotchas that must be understood fully to develop safe code. Additionally, understanding vaults makes understanding rebase tokens (another common accounting mechanism) far easier. Almost every DeFi protocol has a vault or vault-like mechanism built in. If you don’t deeply understand vaults, you will struggle to read large codebases.

A flash loan is the simplest possible mechanism for traders to “use” the liquidity provided by investors. Therefore, we use this as the starting point for showing how liquidity is “used” and how profits ought to be distributed. We teach the ERC-3156, but also the way other protocols implement flash loans, notably Uniswap V2.

Uniswap V2 has been forked into over 600 protocols—more than any other DeFi protocol. It is not possible to understand Uniswap V3 without understanding Uniswap V2—and Uniswap V3 has been forked into over a hundred protocols. By deeply understanding Uniswap V2, you are positioned to quickly learn hundreds of other protocols. The knowledge gained will serve you many times over. Someone who deeply understands Uniswap V2 can immediately understand hundreds of other codebases. As you can see, we want to get you to a point of NOT being intimidated by large DeFi codebases, but rather to understand the recurring patterns they rely on so you can read DeFi codebases in “chunks” rather than try to reverse-engineer them line-by-line. It is not possible to understand a moderately complex DeFi protocol without having a strong mastery of the subjects above—it’s like trying to learn calculus while having major knowledge gaps with algebra. Consider that the Uniswap V2 codebase depends on the following topics (and more!): - Fee-On-Transfer Tokens - Rebasing Tokens - The Safetransfer Pattern - Fixed-Point Numbers And Fixed-Point Arithmetic - Accumulator Accounting - LP Tokens And Vault Design Patterns - Fee-By-Dilution - Flash Loans - Factory Pattern And Create2 If you try to learn Uniswap V2 without mastering those topics first, the design choices of Uniswap V2 will seem random. If you deeply understand the topics above—and you will if you do the assignments leading up to the Uniswap V2 section of the course—then the Uniswap V2 codebase will feel easy and obvious.

Although oracles are critical to DeFi, there is not much to learn about them, and the documentation provided by oracle providers is already very good. Everything you need to know contained, or linked to, in our oracle tutorial. Learning how an oracle works does not “unlock” further skills. It’s one and done.

Proxies can be learned passively if one has the correct foundations and the explanation is clear. Interested students can read our Book of Proxy Patterns which is far more extensive than any other resource on the topic. We’ve seen from experience that developers and auditors have no trouble understanding upgradeable contracts even if they haven’t coded a proxy before, provided they studied the underlying mechanics.

Governance is similar to proxies; it can be learned passively if one has the correct foundations and a good explanation. Furthermore, excellent tooling for implementing governance protocols exists, so reinventing the wheel is usually not the right choice. See our Solidity governance tutorial if interested. Governance matters in the sense that protocols use it, but protocols do not depend on it. Governance is essentially a more decentralized version of a multisignature wallet, so when trying to understand DeFi protocols, developers and auditors can frequently treat governance and DAOs as an abstraction.

Thorough unit testing is rather straightforward nowadays with A.I. While obviously developers should not blindly trust the output of a chat bot, A.I. is very good at “boilerplate” code which unit tests tend to be. If you are unfamiliar with unit testing in Solidity, our article on Foundry Unit Tests is an industry classic. Furthermore, our exercises come with professionally crafted unit tests, so you’ll learn by exposure the best way to write them, as opposed to writing tests with delayed feedback on whether you did it correctly or not.

Invariant testing is important! However, we’ve found it counterproductive to teach invariant testing before the student has strong mastery of at least one DeFi protocol. Otherwise, they don’t know how to come up with invariants, and invariants become more of an academic exercise for the student. By mastering the topics in this course, you will be better equipped to use invariant testing to its full potential. Again, we have an invariant testing tutorial for those interested.

The NFT market is quite dead! Besides, anyone launching an NFT doesn’t need a developer to do it, as there is robust tooling to accomplish this. A developer who wishes to integrate with an NFT can learn everything they need to know in our ERC-721 tutorial and ERC-721 Enumerable tutorial. Additionally, anyone who has mastered ERC-20s to degree this bootcamp trains, ERC-721 will be a walk in the park. With few exceptions, NFTs tend to exist in isolation. So “mastering” NFTs does not set the student up for mastering further topics, as very few topics depend on understanding NFTs. However, picking the right topics to study is only the first step - the second step is making sure you actually learn these topics.