Support

## ZK Sync Contract Deployment ZK Sync contract deployment is a little different than Ethereum deployments. Instead of having a blank to address, ZK Sync has a to address that's actually another contract, the Contract Deployer contract. This is the contract we used to send our contract to. We can find the Contract Deployer's address under the "to" field on the Block Explorer, which we can verify by searching for the address in our MetaMask Wallet. The address we found in our MetaMask Wallet is `0x0000000000000000000000000000000000000006`. The Contract Deployer contract is actually written in Solidity, and we can find the code using the block explorer. Here's an example of how to write the code to call the `ContractDeployer` contract: ```python contract_deployer_contract = ContractDeployer.at("0x0000000000000000000000000000000000000006") contract_deployer_contract.create(bytes_salt, bytes_bytecodeHash, bytes_input) ``` The code above shows the necessary parameters to call the `ContractDeployer` contract's `create` function, and the `bytes_salt`, `bytes_bytecodeHash` and `bytes_input` parameters are ones that we would have to convert our Vyper code to. The `ContractDeployer` contract will handle this conversion for us, under the hood.

ZK Sync Contract Deployment

ZK Sync contract deployment is a little different than Ethereum deployments. Instead of having a blank to address, ZK Sync has a to address that's actually another contract, the Contract Deployer contract. This is the contract we used to send our contract to.

We can find the Contract Deployer's address under the "to" field on the Block Explorer, which we can verify by searching for the address in our MetaMask Wallet.

The address we found in our MetaMask Wallet is 0x0000000000000000000000000000000000000006.

The Contract Deployer contract is actually written in Solidity, and we can find the code using the block explorer.

Here's an example of how to write the code to call the ContractDeployer contract:

contract_deployer_contract = ContractDeployer.at("0x0000000000000000000000000000000000000006")

contract_deployer_contract.create(bytes_salt, bytes_bytecodeHash, bytes_input)

The code above shows the necessary parameters to call the ContractDeployer contract's create function, and the bytes_salt, bytes_bytecodeHash and bytes_input parameters are ones that we would have to convert our Vyper code to. The ContractDeployer contract will handle this conversion for us, under the hood.

Zksync Contract Deployment

A comprehensive guide to understanding ZkSync smart contract deployment - This lesson explains how ZkSync deployment differs from standard Ethereum deployment, highlighting the role of the ContractDeployer contract and the unique way ZkSync handles contract creation through function calls.

Course Overview

About the course

What you'll learn

Python basics

Introduction to Web3.py

Introduction to Titanoboa

Introduction to Moccasin

How to create an ERC-20

How to test Python code and Vyper smart contract

How to deploy Vyper smart contracts on ZKsync using Moccasin

Course Description

Who is this course for?

Software engineers
Web3 developers
Finance 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

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 10, 2025

Thanks for checking us out

Start learning for free

Start for free

Vyper Smart Contract Developer Intermediate Python and Vyper

Section 1: Python In Updraft

Duration: 2h 20min

Section 2: Web3py

Duration: 1h 51min

Section 3: Boa Favs

Duration: 58min

Section 4: Mox Favs

Duration: 2h 23min

1. Intro

A comprehensive guide to the Moccasin smart contract development framework - The lesson covers deploying, testing, and writing professional code using Moccasin, along with how to utilize its built-in tools for verification. Duration: 9min

2. Install Mox

A comprehensive guide to installing the Mocassin smart contract development framework. This lesson covers the various installation methods, including using the uv tool and exploring the Mocassin documentation. Duration: 3min

3. Create Mox

A detailed guide to creating a Moccasin project - The lesson explains how to create a new Moccasin project, exploring its various files and folders, including the .vscode settings, the lib directory, and the README.md file. It also covers the process of deploying a counter contract, including how to use the deploy keyword and the increment function. Duration: 6min

4. Mox Something

A simple guide to compiling Vyper projects using Mocassin. Learn how to compile a single Vyper contract or an entire project and view the generated output files, which contain valuable details about the compiled code. Duration: 2min

5. Mox Script

A comprehensive guide to deploying a Vyper smart contract using the Mocassin CLI. The lesson covers the steps to create a deployment script, define a `mocassin_main` function, import the smart contract, use the `deploy` command, and retrieve the contract's starting number. Duration: 6min

6. Other Net

A comprehensive guide to deploying a Vyper smart contract to a different network using the Mocassin framework. The lesson covers setting up a custom network configuration, managing private keys, and avoiding common deployment errors. Duration: 6min

7. Encrypt Key

A comprehensive guide to encrypting a private key using the Moccasin wallet command-line interface. The lesson covers importing a private key into an encrypted keystore, viewing the JSON of a keystore file, and listing the accounts in the keystore directory. Duration: 3min

8. Shell

A crucial security tip on protecting your private keys - Shell history. This lesson explains why storing your private keys in the command line can be dangerous due to the history feature in most terminals that can save your private keys in plain text. Duration: 2min

9. Using Key

A practical guide to using encrypted keys in your Moccasin script. This lesson demonstrates how to run a deploy script using Moccasin and how to securely interact with a local blockchain using an encrypted private key. Duration: 1min

10. Account Cli

A powerful guide to using command-line options for managing your Mocksin accounts. Learn to set default accounts, manage keystores, and store private keys in an encrypted format to enhance your security. Duration: 7min

11. Mox Testing

A simple introduction to writing Mocassin tests using Pytest. The lesson covers the basics of setting up your testing environment, including creating a new file, running basic tests, and using the 'assert' function. Duration: 3min

12. Testing Deploy Script

A practical guide to testing deploy scripts - The lesson explains the importance of testing deploy scripts. It teaches you how to import functions from other files in a project for unit testing and how to write a test to ensure the deploy script functions correctly. Duration: 6min

13. Aaa

A comprehensive guide to testing Vyper smart contracts using Vyper. This lesson demonstrates how to effectively test your Vyper smart contract using the Arrange, Act, Assert (AAA) pattern, ensuring code accuracy and reliability. Duration: 3min

14. Fixtures

A comprehensive guide to using Pytest fixtures for efficient testing in your Python projects. This lesson explores the concept of fixtures, their different scopes (function, session), and how to utilize them to streamline your test workflow. Duration: 7min

15. Conftest

A simple guide to sharing fixtures with Pytest - This lesson explains how to utilize conftests.py to share fixtures, hooks, and configurations across multiple Pytest tests, ensuring consistent testing practices. Duration: 2min

16. Type Hints

A comprehensive guide to adding type hints to your Python smart contracts. The lesson explores the benefits of adding type hints, using the VyperContract type, adding type hints to functions, and incorporating type hints to improve code clarity. Duration: 5min

17. Sepolia Deploy

A comprehensive guide to deploying a Vyper smart contract to the Sepolia test network. The lesson covers setting up a dedicated RPC connection using Alchemy and configuring your Mocassin.toml file to ensure a smooth and secure deployment process. Duration: 15min

18. Anvil Zksync-update

Duration: 1min

19. Verify

A practical guide to verifying deployed Vyper smart contracts. The lesson explores how to verify contracts that have already been deployed on a blockchain, using the VyperContract library and relevant tools for contract interaction. It demonstrates the process through a real-world example. Duration: 1min

20. Zksync Setup

A comprehensive guide to setting up ZkSync Era with Moccasin - Learn how to install and configure the essential tools for building dApps on the ZkSync Era network, including the Era Test Node, Era Compiler Vyper, and Homebrew. Duration: 18min

21. Eravm

A comprehensive guide to using the Mochassin tool to deploy and test smart contracts on the Era VM. This lesson covers configuring the Mochassin tool, understanding the difference between the Era VM and EVM, and the basics of running tests. Duration: 6min

22. Setting Up Zksync

A practical guide to configuring your network for ZkSync - This lesson walks through the process of configuring your network for ZkSync. We'll learn how to set up ZkSync's testnet and mainnet within your development environment using Alchemy. Duration: 6min

23. Bridging

A comprehensive guide to bridging funds from the Sepolia testnet to the zkSync Sepolia testnet. Learn how to connect your MetaMask wallet, bridge your test ETH, and verify your smart contract on zkSync. Duration: 3min

24. Zksync Deploy

A practical guide to deploying a Vyper smart contract to ZkSync using Moccasin - Learn how to deploy your smart contract to the Sepolia ZkSync testnet, verify your contract, and celebrate your success by sharing it with the ZkSync community. Duration: 3min

25. Zksync Contract Deployment

26. Tx Types

A detailed explanation of transaction types on the Ethereum blockchain - This lesson explores different transaction types used on Ethereum, including legacy, access list, and the new normal, type 2 transactions, introduced by EIP-1559. Learn about their function, implementation, and how they relate to gas fees and transaction efficiency. Duration: 4min

27. Workshop

A fun workshop to Remix Buy Me a Coffee - This lesson involves three short coding challenges using your smart contract in Remix IDE. These challenges cover topics such as getting the price of an asset using Chainlink price feeds, writing a function to get the total funds in a contract, and modifying the owner of the contract. Duration: 6min

28. Recap

A comprehensive recap of the Moccasin favorites lesson - This lesson covers key concepts learned such as writing tests with Pytest, utilizing fixtures for faster tests, crafting deploy scripts in Moccasin, working with different networks, and securing private keys. Duration: 5min

Section 5: Mox Five

Duration: 53min

Section 6: Mox Coffee

Duration: 2h 24min

Section 7: Mox Html

Duration: 28min

Section 8: Mox Erc20

Duration: 1h 54min

Section 9: How To Get Hired

Duration: 11min