## Deploying Your Smart Contract Beyond the Remix VM In previous steps, you likely deployed and tested your smart contract within the Remix IDE's simulated environment, often called the Remix VM. While excellent for initial development and quick checks, it doesn't fully replicate interacting with a real blockchain network. This lesson guides you through deploying your smart contract to a network environment that behaves like a real blockchain, using tools like MetaMask and introducing a powerful development tool: Tenderly Virtual Testnets. ## The Challenge of Public Testnets (Like Sepolia) Public testnets, such as Sepolia, are designed to mirror the functionality of main blockchain networks (like Ethereum Mainnet) but use test Ether (ETH) with no real-world value. They are crucial for final testing stages before deploying to mainnet. However, a significant practical hurdle often arises: acquiring test ETH. Faucets, the websites designed to distribute free test ETH, are notoriously difficult to use. They frequently have strict requirements (like holding a certain amount of mainnet ETH), impose severe rate limits, or simply run out of funds. This difficulty can severely slow down development and cause considerable frustration. **Important Development Philosophy:** Relying heavily on public testnets for *day-to-day development* is generally considered inefficient. Your primary testing loop should ideally be local (using Remix VM or other local blockchain simulators). Deployment to a public testnet should be one of the *later* steps in your process, perhaps just before a security audit or final pre-mainnet checks, rather than a frequent activity during initial coding and debugging. While interacting with a public testnet is valuable experience, the difficulties in obtaining test funds often make it impractical for learning and rapid iteration. Therefore, we'll pivot to a more developer-friendly solution. ## Connecting Remix to External Networks with MetaMask To deploy your contract outside the Remix VM, you need to connect Remix to a blockchain network via a wallet. MetaMask is the most common browser extension wallet for this purpose. 1. **Install MetaMask:** Ensure you have the MetaMask browser extension installed. If you just installed it, refresh your Remix IDE page. 2. **Compile Your Contract:** In Remix, navigate to your Vyper contract (e.g., `favorites.vy`) and compile it using the Vyper compiler tab. 3. **Clear Old Deployments:** Go to the "Deploy & Run Transactions" tab in Remix and clear any previously deployed contract instances from the Remix VM session. 4. **Change Remix Environment:** This is the crucial step. In the "Deploy & Run Transactions" tab, locate the "Environment" dropdown menu. It usually defaults to "Remix VM (e.g., Cancun)". Change this setting to **"Injected Provider - MetaMask"**. 5. **Connect MetaMask to Remix:** Selecting "Injected Provider" will likely trigger a MetaMask pop-up window asking for permission to connect your wallet to the Remix website. Approve this connection request. 6. **Select Network in MetaMask:** Open the MetaMask extension. Click the network dropdown at the top left. Initially, you might consider selecting a public testnet like **Sepolia**. * *Tip:* If you don't see Sepolia listed, go into your MetaMask settings, find the "Networks" or "Advanced" section, and ensure the option **"Show test networks"** is enabled. At this point, if you were proceeding with Sepolia, you'd face the faucet challenge mentioned earlier. Let's explore a better way for development using Tenderly. ## Introducing Tenderly Virtual Testnets: A Better Alternative Tenderly (`tenderly.co`) is a comprehensive blockchain development platform offering various tools, including debugging, simulation, and monitoring. One of its standout features for developers is **Virtual Testnets**. Virtual Testnets are private, on-demand simulations of blockchain networks. Crucially, you can *fork* an existing network (like Sepolia or even Ethereum Mainnet) at its current state, creating your own private copy. This environment provides the realism of interacting with a network state without the hassles of public testnet faucets. ## Setting Up Your Tenderly Virtual Testnet To use Tenderly Virtual Testnets, you'll need a Tenderly account. 1. **Sign Up for Tenderly (Special Offer):** * Use the specific sign-up link provided in the course materials (e.g., in the associated GitHub repository like `github.com/Cyfrin/moccasin-full-course-cu`). This link is part of a partnership. * After creating your account using that link, log in to Tenderly. * Open the chat widget (usually in the bottom right corner). * Send the message: **`CYFRIN2024`** * This code should activate an extended free trial (e.g., a full month), giving you ample time to explore Tenderly's features. Thanks to Tenderly for this offer! 2. **Create a Tenderly Project:** Once logged in, create a new project. Give it a relevant name (e.g., "My First DApp"). 3. **Create a Virtual TestNet:** * Navigate to the "Virtual TestNets" section within your Tenderly project. * Click "Create Virtual TestNet". * Configure your testnet: * **Parent Network:** Select **Sepolia**. This means your virtual testnet will start as a fork (a copy) of the current Sepolia blockchain state. * **Name:** Choose a descriptive name, for instance, **"My Dev Fork"**. * **Chain ID:** Select **Custom**. Public Sepolia has a Chain ID of `11155111`. To avoid potential conflicts with the real network in MetaMask, choose a *different*, unique custom ID. A simple approach is to add an extra digit, like **`111555111`**. You can quickly check sites like `chainlist.org` to ensure your chosen ID isn't already widely used. * **Public Explorer:** Set to **On**. This creates a web interface, similar to Etherscan, where you can view transactions and blocks on your private virtual testnet. * **Smart Contract Visibility:** Set to **Full**. This allows you to view details about deployed contracts later. * Click "Create". Your private, Sepolia-forked virtual testnet will be created almost instantly. ## Connecting MetaMask to Your Tenderly Virtual Testnet Now, you need to tell MetaMask how to communicate with your newly created Tenderly Virtual Testnet. 1. **Find RPC URL:** On your Tenderly Virtual Testnet's page, locate the **HTTPS RPC URL**. It will look something like `https://virtual.sepolia.rpc.tenderly.co/...<unique_identifier>`. Copy this URL. 2. **Add Custom Network in MetaMask:** * Open MetaMask and click the network selector dropdown. * Scroll to the bottom and click **"Add network"** or **"Add a custom network"**. * Fill in the details: * **Network Name:** Enter the name you gave your testnet in Tenderly (e.g., "My Dev Fork"). * **New RPC URL:** Paste the HTTPS RPC URL you copied from Tenderly. * **Chain ID:** Enter the **custom Chain ID** you set in Tenderly (e.g., 111555111). * **Currency Symbol:** Enter **ETH**. * **Block Explorer URL (Optional):** You can leave this blank for now or add the Public Explorer URL from Tenderly later if desired. * Click "Save". 3. **Switch Network:** MetaMask should prompt you to switch to the newly added network. If not, manually select "My Dev Fork" (or whatever you named it) from the network dropdown. Your MetaMask wallet is now connected to your private Tenderly Virtual Testnet. ## Funding Your Virtual Testnet Account (The Easy Way) Remember the pain of public testnet faucets? Tenderly makes funding trivial on its virtual testnets. 1. **Copy Your Address:** Open MetaMask, ensure you're on your Tenderly network ("My Dev Fork"), and copy your account address (usually displayed prominently at the top). 2. **Fund in Tenderly:** Go back to your Tenderly Virtual Testnet page. 3. Click the **"Fund Account"** button. 4. Paste your MetaMask account address into the provided field. 5. Leave the amount as the default (e.g., 1000 ETH) or adjust if desired. 6. Click "Fund". 7. **Check Balance:** Open MetaMask again. You should see the balance updated almost instantly to 1000 ETH (or the amount you requested). Note that any displayed USD value is based on the real ETH price and is purely illustrative; this virtual ETH has no monetary value. You now have ample "test" ETH on your private network, obtained in seconds! ## Deploying Your Smart Contract to Tenderly With Remix connected via MetaMask to your funded Tenderly Virtual Testnet, you're ready to deploy. **Potential Remix/Vyper/MetaMask Bug Workaround:** *As of the time of some recordings, a minor bug occasionally affects deploying Vyper contracts via MetaMask to custom networks unless a Solidity contract has also been compiled in the same Remix session.* If you encounter deployment issues: 1. Create a new file in Remix named `dummy.sol`. 2. Paste the following minimal Solidity code: ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.18; contract Dummy {} ``` 3. Go to the Solidity Compiler tab in Remix and compile `dummy.sol`. 4. Switch back to your `favorites.vy` file. 5. Go to the Vyper Compiler tab and re-compile `favorites.vy`. 6. Proceed to the "Deploy & Run Transactions" tab. **Deployment Steps:** 1. **Verify Setup:** * Ensure the Remix "Environment" is still set to "Injected Provider - MetaMask". * Confirm MetaMask is connected to your Tenderly network ("My Dev Fork"). * Select your compiled Vyper contract (`favorites - favorites.vy`) from the "Contract" dropdown in Remix. 2. **Deploy:** Click the orange **"Deploy"** button in Remix. 3. **Confirm in MetaMask:** MetaMask will pop up with a transaction confirmation request for *contract deployment*. * Review the details: It will likely show a negligible gas fee (as Tenderly handles this on virtual testnets), the nonce (should be 0 for your first transaction), and the **Hex Data**. This data represents your compiled contract bytecode. * Click **"Confirm"**. 4. **Verify Deployment:** * The Remix terminal should show output indicating the transaction was successful and provide the address of your newly deployed contract. * The contract instance will appear under the "Deployed Contracts" section in Remix. * If you check the "Transactions" tab or the Public Explorer link for your Virtual Testnet in Tenderly, you will see the contract creation transaction recorded. ## Interacting with Your Deployed Contract on Tenderly Now that your contract lives on your virtual testnet, you can interact with it just like you did in the Remix VM, but now involving MetaMask for state changes. 1. **Use Deployed Instance:** In Remix, under "Deployed Contracts", expand your deployed `favorites` contract instance. 2. **Read State (Read-Only Calls):** Click buttons corresponding to read-only functions or public state variables (e.g., `my_favorite_number`, `my_name`, `index`). These calls retrieve data directly from the network state (your Tenderly fork) and do *not* require a MetaMask transaction confirmation. The values should reflect the initial state of your contract. 3. **Write State (State-Changing Calls):** Call a function that modifies the contract's state, like `add_person`. Enter the required arguments (e.g., "Alice" for `_name`, 42 for `_fav_num`) and click the function's button. 4. **Confirm in MetaMask:** Because `add_person` changes the blockchain state, MetaMask will pop up again. * Review the details: It will show you're interacting with your deployed contract's address, the nonce (now likely 1), and the relevant hex data representing the function call and its arguments. * Click **"Confirm"**. 5. **Verify Interaction:** * Wait for the transaction to be confirmed (visible in the Remix terminal and Tenderly). * Now, perform read calls again (e.g., check `index` or use `name_to_favorite_number("Alice")`). The returned values should reflect the changes made by the `add_person` transaction. ## Conclusion: Your First Real Deployment Congratulations! You have successfully: * Configured MetaMask to connect to external networks. * Understood the limitations of public testnets for development. * Set up and funded a Tenderly Virtual Testnet – a powerful tool for developers. * Deployed a smart contract from Remix to a realistic, forked network environment using MetaMask. * Interacted with your deployed contract, performing both read and write operations. The process you just completed—using Remix, MetaMask (as an Injected Provider), and connecting to a network (in this case, Tenderly)—is fundamentally **the exact same workflow** you would use to deploy to *any* EVM-compatible blockchain, including Ethereum Mainnet, Polygon, Arbitrum, Optimism, Base, ZKsync, and many others. The only differences would be selecting the target network in MetaMask and ensuring you have the appropriate (real) currency to pay for gas fees. You've taken a significant step from simulated environments to real-world deployment practices. Feel proud of this accomplishment – you are well on your way to becoming a proficient smart contract developer. Take a break, celebrate this milestone, and perhaps share your progress! If you encountered any issues, remember to utilize resources like AI assistants (Claude, ChatGPT, Phind), check the course's GitHub Discussions page, or ask questions in the community forums. Keep building!

Deploying Your Smart Contract Beyond the Remix VM

In previous steps, you likely deployed and tested your smart contract within the Remix IDE's simulated environment, often called the Remix VM. While excellent for initial development and quick checks, it doesn't fully replicate interacting with a real blockchain network. This lesson guides you through deploying your smart contract to a network environment that behaves like a real blockchain, using tools like MetaMask and introducing a powerful development tool: Tenderly Virtual Testnets.

The Challenge of Public Testnets (Like Sepolia)

Public testnets, such as Sepolia, are designed to mirror the functionality of main blockchain networks (like Ethereum Mainnet) but use test Ether (ETH) with no real-world value. They are crucial for final testing stages before deploying to mainnet.

However, a significant practical hurdle often arises: acquiring test ETH. Faucets, the websites designed to distribute free test ETH, are notoriously difficult to use. They frequently have strict requirements (like holding a certain amount of mainnet ETH), impose severe rate limits, or simply run out of funds. This difficulty can severely slow down development and cause considerable frustration.

Important Development Philosophy: Relying heavily on public testnets for day-to-day development is generally considered inefficient. Your primary testing loop should ideally be local (using Remix VM or other local blockchain simulators). Deployment to a public testnet should be one of the later steps in your process, perhaps just before a security audit or final pre-mainnet checks, rather than a frequent activity during initial coding and debugging.

While interacting with a public testnet is valuable experience, the difficulties in obtaining test funds often make it impractical for learning and rapid iteration. Therefore, we'll pivot to a more developer-friendly solution.

Connecting Remix to External Networks with MetaMask

To deploy your contract outside the Remix VM, you need to connect Remix to a blockchain network via a wallet. MetaMask is the most common browser extension wallet for this purpose.

Install MetaMask: Ensure you have the MetaMask browser extension installed. If you just installed it, refresh your Remix IDE page.
Compile Your Contract: In Remix, navigate to your Vyper contract (e.g., favorites.vy) and compile it using the Vyper compiler tab.
Clear Old Deployments: Go to the "Deploy & Run Transactions" tab in Remix and clear any previously deployed contract instances from the Remix VM session.
Change Remix Environment: This is the crucial step. In the "Deploy & Run Transactions" tab, locate the "Environment" dropdown menu. It usually defaults to "Remix VM (e.g., Cancun)". Change this setting to "Injected Provider - MetaMask".
Connect MetaMask to Remix: Selecting "Injected Provider" will likely trigger a MetaMask pop-up window asking for permission to connect your wallet to the Remix website. Approve this connection request.
Select Network in MetaMask: Open the MetaMask extension. Click the network dropdown at the top left. Initially, you might consider selecting a public testnet like Sepolia.
- Tip: If you don't see Sepolia listed, go into your MetaMask settings, find the "Networks" or "Advanced" section, and ensure the option "Show test networks" is enabled.

At this point, if you were proceeding with Sepolia, you'd face the faucet challenge mentioned earlier. Let's explore a better way for development using Tenderly.

Introducing Tenderly Virtual Testnets: A Better Alternative

Tenderly (tenderly.co) is a comprehensive blockchain development platform offering various tools, including debugging, simulation, and monitoring. One of its standout features for developers is Virtual Testnets.

Virtual Testnets are private, on-demand simulations of blockchain networks. Crucially, you can fork an existing network (like Sepolia or even Ethereum Mainnet) at its current state, creating your own private copy. This environment provides the realism of interacting with a network state without the hassles of public testnet faucets.

Setting Up Your Tenderly Virtual Testnet

To use Tenderly Virtual Testnets, you'll need a Tenderly account.

Sign Up for Tenderly (Special Offer):
- Use the specific sign-up link provided in the course materials (e.g., in the associated GitHub repository like github.com/Cyfrin/moccasin-full-course-cu). This link is part of a partnership.
- After creating your account using that link, log in to Tenderly.
- Open the chat widget (usually in the bottom right corner).
- Send the message: CYFRIN2024
- This code should activate an extended free trial (e.g., a full month), giving you ample time to explore Tenderly's features. Thanks to Tenderly for this offer!
Create a Tenderly Project: Once logged in, create a new project. Give it a relevant name (e.g., "My First DApp").
Create a Virtual TestNet:
- Navigate to the "Virtual TestNets" section within your Tenderly project.
- Click "Create Virtual TestNet".
- Configure your testnet:
  - Parent Network: Select Sepolia. This means your virtual testnet will start as a fork (a copy) of the current Sepolia blockchain state.
  - Name: Choose a descriptive name, for instance, "My Dev Fork".
  - Chain ID: Select Custom. Public Sepolia has a Chain ID of 11155111. To avoid potential conflicts with the real network in MetaMask, choose a different, unique custom ID. A simple approach is to add an extra digit, like 111555111. You can quickly check sites like chainlist.org to ensure your chosen ID isn't already widely used.
  - Public Explorer: Set to On. This creates a web interface, similar to Etherscan, where you can view transactions and blocks on your private virtual testnet.
  - Smart Contract Visibility: Set to Full. This allows you to view details about deployed contracts later.
- Click "Create". Your private, Sepolia-forked virtual testnet will be created almost instantly.

Connecting MetaMask to Your Tenderly Virtual Testnet

Now, you need to tell MetaMask how to communicate with your newly created Tenderly Virtual Testnet.

Find RPC URL: On your Tenderly Virtual Testnet's page, locate the HTTPS RPC URL. It will look something like https://virtual.sepolia.rpc.tenderly.co/...<unique_identifier>. Copy this URL.
Add Custom Network in MetaMask:
- Open MetaMask and click the network selector dropdown.
- Scroll to the bottom and click "Add network" or "Add a custom network".
- Fill in the details:
  - Network Name: Enter the name you gave your testnet in Tenderly (e.g., "My Dev Fork").
  - New RPC URL: Paste the HTTPS RPC URL you copied from Tenderly.
  - Chain ID: Enter the custom Chain ID you set in Tenderly (e.g., 111555111).
  - Currency Symbol: Enter ETH.
  - Block Explorer URL (Optional): You can leave this blank for now or add the Public Explorer URL from Tenderly later if desired.
- Click "Save".
Switch Network: MetaMask should prompt you to switch to the newly added network. If not, manually select "My Dev Fork" (or whatever you named it) from the network dropdown.

Your MetaMask wallet is now connected to your private Tenderly Virtual Testnet.

Funding Your Virtual Testnet Account (The Easy Way)

Remember the pain of public testnet faucets? Tenderly makes funding trivial on its virtual testnets.

Copy Your Address: Open MetaMask, ensure you're on your Tenderly network ("My Dev Fork"), and copy your account address (usually displayed prominently at the top).
Fund in Tenderly: Go back to your Tenderly Virtual Testnet page.
Click the "Fund Account" button.
Paste your MetaMask account address into the provided field.
Leave the amount as the default (e.g., 1000 ETH) or adjust if desired.
Click "Fund".
Check Balance: Open MetaMask again. You should see the balance updated almost instantly to 1000 ETH (or the amount you requested). Note that any displayed USD value is based on the real ETH price and is purely illustrative; this virtual ETH has no monetary value.

You now have ample "test" ETH on your private network, obtained in seconds!

Deploying Your Smart Contract to Tenderly

With Remix connected via MetaMask to your funded Tenderly Virtual Testnet, you're ready to deploy.

Potential Remix/Vyper/MetaMask Bug Workaround:
As of the time of some recordings, a minor bug occasionally affects deploying Vyper contracts via MetaMask to custom networks unless a Solidity contract has also been compiled in the same Remix session. If you encounter deployment issues:

Create a new file in Remix named dummy.sol.
Paste the following minimal Solidity code:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
contract Dummy {}
Go to the Solidity Compiler tab in Remix and compile dummy.sol.
Switch back to your favorites.vy file.
Go to the Vyper Compiler tab and re-compile favorites.vy.
Proceed to the "Deploy & Run Transactions" tab.

Deployment Steps:

Verify Setup:
- Ensure the Remix "Environment" is still set to "Injected Provider - MetaMask".
- Confirm MetaMask is connected to your Tenderly network ("My Dev Fork").
- Select your compiled Vyper contract (favorites - favorites.vy) from the "Contract" dropdown in Remix.
Deploy: Click the orange "Deploy" button in Remix.
Confirm in MetaMask: MetaMask will pop up with a transaction confirmation request for contract deployment.
- Review the details: It will likely show a negligible gas fee (as Tenderly handles this on virtual testnets), the nonce (should be 0 for your first transaction), and the Hex Data. This data represents your compiled contract bytecode.
- Click "Confirm".
Verify Deployment:
- The Remix terminal should show output indicating the transaction was successful and provide the address of your newly deployed contract.
- The contract instance will appear under the "Deployed Contracts" section in Remix.
- If you check the "Transactions" tab or the Public Explorer link for your Virtual Testnet in Tenderly, you will see the contract creation transaction recorded.

Interacting with Your Deployed Contract on Tenderly

Now that your contract lives on your virtual testnet, you can interact with it just like you did in the Remix VM, but now involving MetaMask for state changes.

Use Deployed Instance: In Remix, under "Deployed Contracts", expand your deployed favorites contract instance.
Read State (Read-Only Calls): Click buttons corresponding to read-only functions or public state variables (e.g., my_favorite_number, my_name, index). These calls retrieve data directly from the network state (your Tenderly fork) and do not require a MetaMask transaction confirmation. The values should reflect the initial state of your contract.
Write State (State-Changing Calls): Call a function that modifies the contract's state, like add_person. Enter the required arguments (e.g., "Alice" for _name, 42 for _fav_num) and click the function's button.
Confirm in MetaMask: Because add_person changes the blockchain state, MetaMask will pop up again.
- Review the details: It will show you're interacting with your deployed contract's address, the nonce (now likely 1), and the relevant hex data representing the function call and its arguments.
- Click "Confirm".
Verify Interaction:
- Wait for the transaction to be confirmed (visible in the Remix terminal and Tenderly).
- Now, perform read calls again (e.g., check index or use name_to_favorite_number("Alice")). The returned values should reflect the changes made by the add_person transaction.

Conclusion: Your First Real Deployment

Congratulations! You have successfully:

Configured MetaMask to connect to external networks.
Understood the limitations of public testnets for development.
Set up and funded a Tenderly Virtual Testnet – a powerful tool for developers.
Deployed a smart contract from Remix to a realistic, forked network environment using MetaMask.
Interacted with your deployed contract, performing both read and write operations.

The process you just completed—using Remix, MetaMask (as an Injected Provider), and connecting to a network (in this case, Tenderly)—is fundamentally the exact same workflow you would use to deploy to any EVM-compatible blockchain, including Ethereum Mainnet, Polygon, Arbitrum, Optimism, Base, ZKsync, and many others. The only differences would be selecting the target network in MetaMask and ensuring you have the appropriate (real) currency to pay for gas fees.

You've taken a significant step from simulated environments to real-world deployment practices. Feel proud of this accomplishment – you are well on your way to becoming a proficient smart contract developer. Take a break, celebrate this milestone, and perhaps share your progress!

If you encountered any issues, remember to utilize resources like AI assistants (Claude, ChatGPT, Phind), check the course's GitHub Discussions page, or ask questions in the community forums. Keep building!

Tenderly

A hands-on walkthrough to Deploying Your Smart Contract Beyond the Remix VM - Master deploying smart contracts to realistic network environments using MetaMask, leveraging Tenderly Virtual Testnets to bypass public testnet limitations.

Course Overview

About the course

What you'll learn

The basics of blockchain transactions, how to send and receive money on a blockchain network.

How to write Python based smart contracts using Vyper.

How to read and understand Vyper smart contracts.

Vyper data structures, arrays, structs, hash maps.

How to build a smart contract application and deploy on ZKsync with Moccasin.

Course Description

Who is this course for?

Software engineers
Web3 developers
Fintech developers
AI developers
Everyone interested in learning Python and smart contracts

Potential Careers

Smart Contract Auditor

$100,000 - $200,000 (avg. salary)

On-chain Data Analyst

$59,000 - $139,000 (avg. salary)

DeFi Developer

$75,000 - $200,000 (avg. salary)

Smart Contract Engineer

$100,000 - $150,000 (avg. salary)

Web3 developer

$60,000 - $150,000 (avg. salary)

Web3 Developer Relations

$85,000 - $125,000 (avg. salary)

Meet your instructors

Patrick Collins

Patrick Collins

Founder at Cyfrin

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.

Last updated on June 11, 2025

Thanks for checking us out

Sign up for free to continue your blockchain learning!

Start learning for free

Start for free

Vyper Smart Contract Developer Introduction to Python and Vyper

Section 1: Favorites

Duration: 2h 08min

A comprehensive introduction to Ultimate Smart Contract Security Course: Python Edition - Explore why Python is pivotal for Web3, AI, and Finance, and begin learning Vyper, the secure, Pythonic language for smart contract development. Duration: 5min

2. Best Practices

An essential introduction to Getting Started: Best Practices for Success - Maximize your learning by understanding the benefits of the Updraft platform, leveraging key resources like GitHub, and adopting effective study strategies. Learn how to code along, pace yourself, ask good questions, and use AI critically. Duration: 8min

3. Mox Best Practices

An essential guide to Course Best Practices: Navigation, Resources, and Asking Questions - Learn how to navigate course materials and find code using the main and section-specific GitHub repositories. Discover the right way to ask questions via GitHub Discussions and the essential tools recommended for the course. Duration: 2min

A hands-on guide to Deploy Your First Vyper Smart Contract - Learn to write, compile, and deploy your first Vyper contract (`Favorites.vy`) using Remix IDE, reinforcing concepts through active, step-by-step coding. Duration: 1min

5. Welcome To Remix

An essential walkthrough to Setting Up Your Remix IDE for Vyper - Discover how to configure the Remix browser IDE for Vyper development, covering workspace cleanup, file management, Vyper compiler activation, and cautious interaction with the RemixAI assistant. Duration: 6min

6. Pragma Version

A foundational overview to Defining the Compiler Version in Vyper with Pragma - Learn the mandatory first step in Vyper: declaring the compiler version using `# pragma`. Understand its importance, syntax variations, and why specifying an exact version is best practice for production. Duration: 2min

Questions: 6

An essential overview to Working with Comments and Directives in Vyper - Discover how comments (`#`) improve Vyper code clarity and grasp the vital compiler instructions provided by `# pragma` directives. Duration: 1min

An essential overview to Declaring a Software License in Your Vyper Smart Contract - Learn why and how to declare a software license using `# @license <IDENTIFIER>` right after your pragma directive in Vyper. Understand the significance for legal clarity, compiler warnings, and embracing open-source principles with licenses like MIT. Duration: 1min

A fundamental introduction to Understanding the Vyper Compilation Process - Discover why Vyper needs translation to EVM bytecode, how to compile using Remix, and the roles of ABI and runtime bytecode. Learn to interpret compiler feedback to fix errors in your contracts. Duration: 2min

11. Contract Design

A foundational primer to Designing Your First Vyper Smart Contract: Planning and Requirements - Understand the crucial first step of defining clear contract goals using comments before writing any code. Learn about essential Vyper file setup like `pragma` and `license` directives. Duration: 1min

12. Vyper Types

A foundational primer to Understanding Basic Data Types in Vyper (v0.4.0) - Discover Vyper's fundamental value types like bool, uint256, and address, including their declaration syntax. Understand static typing and the key v0.4.0 constraint on initializing storage variables. Duration: 4min

13. Quiz 13 Quiz

Questions: 9

A practical guide to Vyper State Variables: Visibility and Remix VM Deployment - Explore Vyper state variables and the crucial difference between internal (default) and public visibility. Deploy a contract to the Remix VM to interact with auto-generated getter functions. Duration: 4min

An essential introduction to Defining Functions in Vyper with the `def` Keyword - Discover how to define functions using `def`, accept parameters, modify state variables via `self`, and control external access with `@external`. Understand why functions are key to altering contract data and how this differs from reading state. Duration: 5min

16. Func Visibility

A fundamental exploration to Understanding Visibility in Vyper - Learn how Vyper's `public`, `@external`, and `@internal` keywords control access to contract elements. Understand their impact on security, default behaviors, and how functions interact based on visibility. Duration: 2min

17. View And Pure

A fundamental guide to Vyper Functions: Reading vs. Modifying State with @view - Understand the crucial distinction between state-modifying transactions and read-only calls using the `@view` decorator in Vyper. Learn how `@view` optimizes gas costs for off-chain data retrieval and clarifies function intent. Duration: 9min

18. Quiz 18 Quiz

Questions: 7

19. Constructor

A core introduction to Initializing Vyper Contracts with `__init__` - Explore how Vyper's constructor sets up initial state variables at deployment, using `msg.sender`, parameters, and the crucial `@deploy` decorator. Duration: 5min

20. Advanced Funcs

An essential guide to Exploring Advanced Vyper Function Syntax - Master advanced Vyper function features, including decorators (`@external`, `@pure`) and the crucial floor division operator (`//`). Learn to handle placeholders with `pass` and return multiple values efficiently. Duration: 4min

A foundational introduction to Vyper Reference Types - Discover Vyper's powerful reference types: fixed-sized lists for ordered arrays, mappings for key-value storage, and structs for custom data structures. Grasp the key distinction between storage and memory when manipulating complex types. Duration: 8min

A practical guide to Overcoming Programming Hurdles with AI Tutors - Learn how to leverage AI assistants like Claude 3.5 to explain complex code snippets, illustrated with a Vyper example. Discover the effectiveness of asking follow-up questions and requesting concrete examples to deepen understanding. Duration: 3min

23. Arrays Lists

A practical guide to Working with Fixed-Size Lists in Vyper - Explore declaring, initializing, reading, and writing fixed-size lists in Vyper, covering zero-based indexing, public access, state updates, and boundary check reverts. Duration: 9min

24. Structs and Strings

An essential guide to Organizing Complex Data with Vyper Structs and Strings - Discover how to define custom data types with `struct` and store text using `String[MAX_SIZE]` in Vyper. Learn to create and manage arrays of these structs to organize complex information within smart contracts. Duration: 8min

25. Quiz 25 Quiz

Questions: 6

A hands-on exercise for the Vyper Contract Interaction Challenge - Discover how repeated function calls modify contract state, focusing on populating specific indices in Vyper mappings. Learn the mechanics of interacting with deployed Vyper contracts and manipulating structs. Duration: 1min

An essential introduction to Mastering Vyper HashMaps for Efficient Data Retrieval - Discover Vyper's `HashMap` structure for efficient key-value data storage and retrieval, contrasting it with index-based lists for direct lookups. Learn the syntax, implementation, and benefits of using meaningful keys over numerical indices. Duration: 4min

A concise recap to Recap: Building the Favorites Vyper Smart Contract - Revisit the core Vyper features used in the `favorites.vy` contract, including structs, state variables (arrays, mappings, `public`), the `__init__` constructor, and function types (`@external`, `@view`). Understand how these building blocks enable on-chain data storage and interaction before deployment. Duration: 2min

A hands-on walkthrough to Deploying Your Smart Contract Beyond the Remix VM - Master deploying smart contracts to realistic network environments using MetaMask, leveraging Tenderly Virtual Testnets to bypass public testnet limitations. Duration: 16min

A focused analysis to Attempting ZKVyper Deployment via Remix - Investigate deploying Vyper contracts to zkSync using Remix, revealing the ZKSYNC plugin's current Solidity-only limitation and the necessity of alternative toolchains. Duration: 0min

A simple walkthrough to Congratulations & Share Your Success! - Understand the value of announcing your first smart contract deployment and follow easy steps to share your achievement on X using a pre-filled link. Duration: 1min

A foundational overview to Understanding the Ethereum Virtual Machine (EVM) - Learn what the EVM is, how it executes compiled smart contract code via opcodes, and the meaning of EVM compatibility across blockchains. Understand why verifying contract behavior on specific target chains is crucial before deployment. Duration: 2min

33. Pure And View

A fundamental breakdown to Vyper Function Decorators: Pure vs. View Explained - Distinguish between `@pure` and `@view` decorators in Vyper based on their interaction with state and global variables. Learn why these read-only specifiers are key for efficient and secure smart contracts. Duration: 3min

34. Conditionals

A fundamental guide to Mastering Conditional Logic in Vyper: Using if, elif, and else - Learn how to control smart contract execution flow with `if`, `elif`, and `else` statements in Vyper, covering syntax, testing in Remix, and the `@pure` decorator. Duration: 2min

35. Workshop Pt. 2.

A hands-on workshop for Reinforce Your Vyper Skills - Apply Vyper concepts like state variables, functions, constructors, and structs through targeted exercises. Learn a structured workflow for effective practice, problem-solving, and utilizing resources like AI and community support. Duration: 3min

36. Quiz 36 Quiz

Questions: 9

A foundational review to Understanding Your First Vyper Smart Contract - `favorites.vy` - Revisit core Vyper elements like version pragmas, structs, state variables (types, arrays, maps), visibility, and the `__init__` constructor. Understand external vs. view functions and the use of `self` for interacting with contract state. Duration: 4min

Section 2: Remix Coffee

Duration: 2h 32min

Section 3: Ai

Duration: 24min

Course Overview

About the course

What you'll learn

The basics of blockchain transactions, how to send and receive money on a blockchain network.

How to write Python based smart contracts using Vyper.

How to read and understand Vyper smart contracts.

Vyper data structures, arrays, structs, hash maps.

How to build a smart contract application and deploy on ZKsync with Moccasin.

Course Description

Who is this course for?

Software engineers
Web3 developers
Fintech developers
AI developers
Everyone interested in learning Python and smart contracts

Potential Careers

Smart Contract Auditor

$100,000 - $200,000 (avg. salary)

On-chain Data Analyst

$59,000 - $139,000 (avg. salary)

DeFi Developer

$75,000 - $200,000 (avg. salary)

Smart Contract Engineer

$100,000 - $150,000 (avg. salary)

Web3 developer

$60,000 - $150,000 (avg. salary)

Web3 Developer Relations

$85,000 - $125,000 (avg. salary)

Meet your instructors

Patrick Collins

Patrick Collins

Founder at Cyfrin

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.

Last updated on June 11, 2025