A Message From Ankr
Learn more about Ankr @ https://www.ankr.com/.
Course Overview
About the course
What you'll learn
Advanced smart contract development
How to develop a stablecoin
How to develop a DeFi protocol
How to develop a DAO
Advanced smart contracts testing
Fuzz testing
Manual verification
Course Description
Who is this course for?
- Engineers
- Smart Contract Security researchers
Potential Careers
Web3 Developer Relations
$85,000 - $125,000 (avg. salary)
Web3 developer
$60,000 - $150,000 (avg. salary)
Smart Contract Engineer
$100,000 - $150,000 (avg. salary)
Smart Contract Auditor
$100,000 - $200,000 (avg. salary)
Security researcher
$49,999 - $120,000 (avg. salary)
Meet your instructors
Web3 engineer, educator, and Cyfrin co-founder. Patrick's smart contract development and security courses have helped hundreds of thousands of engineers kickstarting their careers into web3.
Guest lecturers:
Last updated on November 7, 2025
1. A Message From Ankr
Learn more about Ankr @ https://www.ankr.com/. Duration: 0min
2. Introduction
A comprehensive masterclass to Building Cross-Chain Rebase Tokens with Foundry and Chainlink CCIP - Learn to design, implement, and deploy interest-accruing rebase tokens across chains using Foundry and Chainlink CCIP. Covers burn-and-mint logic, advanced fork testing with local CCIP simulation, and automated deployment scripts. Duration: 3min
3. What Is a Rebase Token
An essential guide to Demystifying Rebase Tokens and Elastic Supply - Grasp how rebase tokens use an elastic supply to algorithmically alter your balance, demystifying unexpected changes in your crypto holdings. You'll explore their core mechanics, types, contrast with standard tokens, and see how Aave's aTokens work, including a peek into their smart contract logic. Duration: 2min
4. Rebase Token Code Structure
A strategic guide to Blueprinting Your Single-Chain Rebase Token - Initialize your Foundry project and establish a clean development environment for your smart contracts. Then, architect the core functionalities of a single-chain rebase token, defining its dynamic balance system and a unique, decreasing global interest rate model to incentivize early users. Duration: 9min
5. Writing the Rebase Token Contract
A conceptual guide to Writing Your First Rebase Token in Solidity - Discover how to build an ERC20-based Rebase Token in Solidity, allowing user balances to automatically grow via accrued interest. This lesson details setting up global and user-specific interest rates, overriding `balanceOf` for dynamic balance reflection, and minting new tokens as interest. Duration: 33min
6. mintInterest and burn Functions
A comprehensive deep-dive to Solidity Rebase Tokens: Managing Dynamic Balances and Interest - Explore how to implement `_mintAccruedInterest` to ensure accurate reflection of accrued interest in user balances before any token operations. You'll learn to build `mint` and `burn` functions for rebase tokens, incorporating `type(uint256).max` for full balance interactions and adhering to Solidity best practices. Duration: 9min
7. Finish Rebase Token Contract
An in-depth lesson to Completing Your Rebase Token Smart Contract - Finalize your custom RebaseToken by overriding OpenZeppelin ERC20 functions like `balanceOf` and `transfer` for accurate interest accrual. Explore the `totalSupply` trade-off, add new utility functions, and identify the next vital step: implementing robust access control. Duration: 16min
8. Access Control
An implementer's guide to Securing Your RebaseToken: Implementing Access Control in Solidity - Learn to fortify your `RebaseToken` by integrating OpenZeppelin's `Ownable` for simple owner control and `AccessControl` for fine-grained, role-based permissions. You'll implement `onlyOwner` and `onlyRole` modifiers, define custom roles, and manage their assignment for critical functions. Duration: 12min
9. Quiz 10
Questions: 9
10. Vault and Natspec
A practical guide to Building a Secure Rebase Vault with Effective Solidity Practices - Learn to construct a `Vault` contract managing ETH deposits and `RebaseToken` minting/burning, with secure interactions via Solidity interfaces and the CEI pattern. This lesson also covers vital Solidity practices: correct NatSpec comments, the `receive()` ETH function, and indexed event parameters for efficient tracking. Duration: 14min
11. Rebase Token Tests Part 1
A practical walkthrough to Foundry Test Environment Setup for Rebase Tokens - Configure your Foundry test environment to test `RebaseToken` and `Vault` contracts, focusing on the `setup` function for deployments, type casting, and role assignments using `vm.prank`. You'll also begin writing a fuzz test for linear interest, utilizing `bound` for inputs and `vm.deal` for user balances. Duration: 11min
12. Rebase Token Test Part 2
A strategic guide to Bulletproofing Rebase Tokens with Advanced Foundry Fuzzing - Explore advanced Foundry fuzz testing techniques to ensure rebase token robustness, covering input optimization with `bound`, rigorous testing of interest accrual, and validation of redeem/transfer logic. Learn to effectively debug common pitfalls like truncation and overflows, and enhance security through comprehensive access control tests and `forge coverage`. Duration: 43min
13. Vulnerabilities and Cross-chain Intro
A critical review to Rebase Token Vulnerabilities and Cross-Chain Token Primer with CCIP - Dissect design flaws in `RebaseToken.sol` such as interest rate manipulation and unintended compounding. Gain an overview of cross-chain token bridging and the Chainlink Cross-Chain Interoperability Protocol (CCIP). Duration: 6min
14. Quiz 11
Questions: 6
15. Bridging
An insightful journey into Understanding Blockchain Bridges: Connecting Isolated Networks - Discover how blockchain bridges serve as vital connectors between disparate networks, learn essential bridging terminology, and understand their necessity in Web3. You'll explore the mechanics behind asset transfers like lock-and-mint, differentiate between native/third-party and centralized/decentralized bridges, and grasp key security practices. Duration: 8min
16. CCIP
A practical guide to Unlocking Cross-Chain Communication with Chainlink CCIP - Learn to bridge blockchains using Chainlink CCIP, mastering its architecture for secure data and token transfers. You'll explore its multi-layered security, including the Risk Management Network, and send your first cross-chain message. Duration: 12min
17. The CCT Standard
An implementer's guide to Chainlink's CCT Standard & Foundry for Cross-Chain Tokens - Master Chainlink's Cross-Chain Token (CCT) Standard, enabling permissionless, developer-owned token pools with enhanced security and programmable transfers. This guide details deploying a Burn & Mint token on testnets using Foundry, from configuration to transfer. Duration: 13min
18. Quiz 26
Questions: 5
19. Bridge Function Test
A comprehensive walkthrough to Building a Reusable `bridgeTokens` Test for Chainlink CCIP in Foundry - Discover how to implement a flexible `bridgeTokens` test function in Foundry for validating cross-chain token movements with Chainlink CCIP. This lesson covers `EVM2AnyMessage` creation, fee handling via `CCIPLocalSimulatorFork`, and end-to-end transfer verification. Duration: 21min
20. Circle CCTP
An essential guide to Bridging Blockchains with Circle's CCTP - Understand how Circle's Cross-Chain Transfer Protocol (CCTP) enables seamless native USDC movement between networks using its burn-and-mint process, eliminating wrapped token vulnerabilities. You'll explore its architecture, standard vs. fast transfers, and a step-by-step Ethers.js implementation. Duration: 12min
21. Quiz 12
Questions: 9
22. Pool Contract
An in-depth walkthrough to Enabling Cross-Chain Rebase Tokens with Chainlink CCIP: A Custom Token Pool Guide - Learn to create a custom Chainlink CCIP token pool in Foundry for rebase tokens, enabling "Burn & Mint" cross-chain functionality. This guide details implementing `lockOrBurn` and `releaseOrMint` to preserve user-specific interest rates. Duration: 31min
23. Finish Pool Contract
A practical debugging walkthrough to Debugging and Finalizing Your RebaseTokenPool Contract - Resolve common Solidity compilation errors in your `RebaseTokenPool` contract and tests using `forge build`. You'll learn to fix incorrect import paths, update function argument calls, and correct the misuse of `abi.decode` for a successful compilation. Duration: 1min
24. Chainlink Local and Fork Tests
A developer's guide to Mastering Local CCIP Testing with Foundry and Chainlink Local - Set up Foundry to manage multiple local blockchain forks like Sepolia and Arbitrum Sepolia using RPC aliases and cheatcodes such as `vm.createSelectFork` and `vm.makePersistent`. You'll then bridge these forks by deploying Chainlink Local's `CCIPLocalSimulatorFork`, enabling seamless local testing of CCIP message relay. Duration: 11min
25. Deploy Token Test
A practical primer to Deploying Your First Cross-Chain Tokens with Chainlink CCIP in Foundry - Configure your Foundry test environment to simulate Sepolia and Arbitrum Sepolia, deploying `RebaseToken` on both and a `Vault` on the source chain for Chainlink CCIP. Learn to use `vm.createFork`, `vm.selectFork`, and `vm.startPrank` for these initial cross-chain contract deployments. Duration: 4min
26. CCIP Setup Test
An indispensable primer to Setting Up Your CCIP Test Environment in Foundry - Establish your Chainlink CCIP testing grounds in Foundry by deploying key contracts like RebaseToken and TokenPools on forked Sepolia and Arbitrum Sepolia networks. This guide covers troubleshooting type errors, using `CCIPLocalSimulatorFork` to get network specifics, and configuring token permissions and pool links. Duration: 11min
27. Configure Pool Test
An essential setup guide to Activating Cross-Chain CCIP Token Transfers via Pool Configuration - Learn the critical `applyChainUpdates` process to configure Chainlink CCIP Token Pools, enabling them for cross-chain burn & mint operations. This guide shows how to implement this in Foundry, managing local/remote chain settings and `ChainUpdate` structs. Duration: 10min
28. First Cross-chain Test
An in-depth guide to Testing Cross-Chain Rebase Token Bridging - Master the complexities of testing cross-chain rebase token bridging between Sepolia and Arbitrum Sepolia forks using Foundry and the Chainlink CCIP Local Simulator. You'll handle intricate setup, implement `bridgeTokens`, manage CCIP fees, and simulate message routing. Duration: 11min
29. Vault Deployment Script
A practical guide to Crafting Your Foundry Deployment Script for the Vault Contract - Learn to write a `VaultDeployer.s.sol` script using Foundry, covering essential imports, the `run()` function, and deployment with `vm.startBroadcast`. This lesson shows how to deploy a `Vault` contract, grant it token mint/burn roles, and return the deployed contract instance. Duration: 4min
30. Token and Pool Deployer
A streamlined deployment guide to Automating Token and Pool Deployment for Chainlink CCIP with Foundry - Learn to craft a `Deployer.s.sol` Foundry script for deploying a custom `RebaseToken` and its `RebaseTokenPool`. You'll also automate the essential Chainlink CCIP configurations to enable Burn & Mint token transfers in a local development environment. Duration: 9min
31. Pool Config Script
An essential tutorial to Crafting the `ConfigurePool.s.sol` Script for CCIP Token Pool Configuration - Master building a Foundry script (`ConfigurePool.s.sol`) to configure deployed `TokenPool` contracts for CCIP operations. You'll learn to use `applyChainUpdates`, prepare `ChainUpdate` structs with rate limiters, and ABI-encode addresses for robust cross-chain setup. Duration: 8min
32. Bridging Script
A comprehensive walkthrough to Crafting a Foundry Script for CCIP Token Bridging - Learn to create the `BridgeTokens.s.sol` script for sending ERC20 tokens cross-chain via Chainlink CCIP without data payloads. This guide details constructing the `EVM2AnyMessage`, handling fees, approving tokens, and executing `ccipSend`. Duration: 13min
33. Run Scripts on Testnet
A step-by-step deployment guide to Deploying Your Cross-Chain Application to Testnets - Deploy contracts to Ethereum Sepolia & ZKsync Sepolia testnets, covering testnet LINK acquisition and using bash scripts (`forge create`/`cast send`) for ZKsync due to Foundry script limitations. Configure your environment with `.env` and Foundry keystore, troubleshoot deployments, and verify cross-chain CCIP transactions. Duration: 15min
34. Outro
An architectural review of Mastering Cross-Chain Rebase Tokens: A Comprehensive Recap - Revisit the complete architecture of a cross-chain rebase token, including `RebaseToken` mechanics, `Vault` interactions, and CCIP integration. Discover how Foundry scripts automate deployment and testing, culminating in a live cross-chain transaction. Duration: 3min
35. Build Scripts
An in-depth walkthrough to Mastering Cross-Chain Foundry Deployments and `via_ir` Test Stability - Prepare your smart contracts for cross-chain deployment across testnets like Sepolia and zkSync, focusing on successful compilation and secure RPC setup. Dive into resolving the `via_ir` and `vm.warp()` testing conflict in Foundry to ensure your CI pipelines run smoothly with robust tests. Duration: 4min
36. Cross-chain Message Success
A detailed breakdown to Mastering Cross-Chain Token Transfers: A CCIP Case Study with Rebase Tokens (RBT) - Get a detailed breakdown of verifying a Rebase Token (RBT) cross-chain transfer via Chainlink CCIP from Ethereum Sepolia to ZKsync Sepolia. Master using the CCIP Explorer to interpret transaction details and confirm token receipt in Metamask on the ZKsync Sepolia network. Duration: 3min
37. Quiz 13
Questions: 9
Course Overview
About the course
What you'll learn
Advanced smart contract development
How to develop a stablecoin
How to develop a DeFi protocol
How to develop a DAO
Advanced smart contracts testing
Fuzz testing
Manual verification
Course Description
Who is this course for?
- Engineers
- Smart Contract Security researchers
Potential Careers
Web3 Developer Relations
$85,000 - $125,000 (avg. salary)
Web3 developer
$60,000 - $150,000 (avg. salary)
Smart Contract Engineer
$100,000 - $150,000 (avg. salary)
Smart Contract Auditor
$100,000 - $200,000 (avg. salary)
Security researcher
$49,999 - $120,000 (avg. salary)
Meet your instructors
Web3 engineer, educator, and Cyfrin co-founder. Patrick's smart contract development and security courses have helped hundreds of thousands of engineers kickstarting their careers into web3.
Guest lecturers:
Last updated on November 7, 2025