> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sei.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Solidity Development Resources for Sei EVM

> Comprehensive guide on Solidity Development Resources for Sei EVM on Sei. Learn key concepts, commands, and best practices.

Most development resources for developing with Soldity on Ethereum Mainnet also apply to development on Sei.

This page suggests a minimal set of resources for getting started with building a decentralized app for Sei EVM.

## IDEs

* **[Remix](https://remix.ethereum.org)**\
  An interactive Solidity IDE that is the easiest and fastest way to start coding and compiling Solidity smart contracts without any additional installations.
* **[VSCode](https://code.visualstudio.com)** + **[Solidity extension](https://marketplace.visualstudio.com/items?itemName=NomicFoundation.hardhat-solidity)**

## Basic Solidity

* **[CryptoZombies](https://cryptozombies.io/en/course)**\
  A great end-to-end introduction to building dApps on the EVM. It offers lessons suitable for complete beginners as well as developers from other disciplines.
* **[Solidity by Example](https://solidity-by-example.org)**\
  Introduces Solidity concepts progressively through simple examples – ideal for developers with some programming background.
* **[Blockchain Basics course by Cyfrin Updraft](https://updraft.cyfrin.io/courses/blockchain-basics)**\
  Covers the fundamentals of blockchain, DeFi, and smart contracts.
* **[Solidity Smart Contract Development by Cyfrin Updraft](https://updraft.cyfrin.io/courses/solidity)**\
  Offers hands-on experience to become a smart contract developer.
* **[Ethereum Developer Degree by LearnWeb3](https://learnweb3.io)**\
  A course designed to take you from no background in web3 to building multiple applications and understanding key protocols, frameworks, and concepts.

## Intermediate Solidity

* **[The Solidity Language](https://docs.soliditylang.org)**\
  Official documentation providing an end-to-end description of smart contracts, blockchain basics, compiling, and deployment on an EVM.
* **[Solidity Patterns](https://github.com/fravoll/solidity-patterns)**\
  A repository of code templates with explanations of their usage.
* **[OpenZeppelin](https://www.openzeppelin.com)**\
  Provides a library of customizable template contracts for common Ethereum token deployments (e.g., ERC20, ERC721, ERC1155, Proxy). Note that these are not gas optimized. They provide the defacto standard for smart contract templates and are used across almost all existing smart contracts.
* **[Uniswap](https://github.com/Uniswap)**\
  A professional, easy-to-digest smart contract of the [Uniswap V2 pools](https://github.com/Uniswap/v2-core) that gives an overview of an in-production Solidity dApp. A guided walkthrough is available [here](https://ethereum.org/en/developers/tutorials/uniswap-v2-annotated-code/). For the more advanced Uniswap Pools, check out the Uniswap V3 [here](https://github.com/Uniswap/v3-core) and Uniswap V4 [here](https://github.com/Uniswap/v4-core).
* **[Morpho Finance](https://github.com/morpho-org)**\
  Morpho Finance's contracts provides an excellent real-world example of production-grade Solidity smart contracts, demonstrating how a successful DeFi lending protocol is structured and implemented. By studying Morpho's codebase, you can learn advanced patterns for gas optimization, security best practices, and complex financial logic implementation in a production environment. The accompanying documentation [here](https://docs.morpho.org/overview/) offers additional context to understand the protocol's architecture and design principles.
* **[Sky / Maker DAO](https://github.com/makerdao)**
  A pioneering DeFi protocol that created the DAI and USDS stablecoin. MakerDAO's codebase showcases complex financial mechanisms including collateralized debt positions, oracles, and governance systems. The project demonstrates how to implement a stable cryptocurrency backed by crypto collateral through sophisticated risk management systems.
* **[Rareskills Blog](https://rareskills.io/blog)**\
  Features in-depth articles on various Solidity concepts and their [Book of Gas Optimization](https://www.rareskills.io/post/gas-optimization).
* **[Foundry Fundamentals course by Cyfrin Updraft](https://updraft.cyfrin.io/courses/foundry)**\
  A comprehensive web3 development course covering Foundry—the industry-standard framework for building, deploying, and testing smart contracts.
* **[Smart Contract Programmer YT channel](https://www.youtube.com/@smartcontractprogrammer)**\
  Contains many in-depth videos covering topics from ABI encoding to EVM memory management.
* **[DeFi developer roadmap](https://github.com/OffcierCia/DeFi-Developer-Road-Map)**

## Advanced Solidity

* **[Solmate repository](https://github.com/transmissions11/solmate)** and **[Solady repository](https://github.com/Vectorized/solady)**\
  Gas-optimized contracts using Solidity or Yul.
* **[Yul](https://docs.soliditylang.org/en/latest/yul.html)**\
  An intermediate language for Solidity, akin to inline assembly for the EVM, offering control flow constructs while exposing low-level memory management.
* **[Advanced Foundry course by Cyfrin Updraft](https://updraft.cyfrin.io/courses/advanced-foundry)**\
  Teaches advanced smart contract development including building DeFi protocols, stablecoins, DAOs, and more.
* **[Smart Contract Security course by Cyfrin Updraft](https://updraft.cyfrin.io/courses/security)**\
  Provides comprehensive training on auditing and writing secure protocols.
* **[Assembly and Formal Verification course by Cyfrin Updraft](https://updraft.cyfrin.io/courses/formal-verification)**\
  Covers Assembly, using Yul, EVM opcodes, formal verification testing, and related tools.
* **[Smart Contract DevOps course by Cyfrin Updraft](https://updraft.cyfrin.io/courses/wallets)**\
  Focuses on post-deployment security, wallet access control, and ongoing protocol maintenance.
* **[Secureum YT Channel](https://www.youtube.com/@SecureumVideos)**\
  Features a variety of videos covering topics from Solidity basics to advanced subjects such as fuzzing and auditing.

## Tutorials

* **[Ethernaut](https://ethernaut.openzeppelin.com)**\
  Learn Solidity by solving puzzles.
* **[Damn Vulnerable DeFi](https://www.damnvulnerabledefi.xyz)**\
  A series of smart contract challenges designed to test and improve your Solidity skills.

## Testing

* **[Echidna](https://github.com/crytic/echidna)**\
  Fuzz testing tool for Solidity.
* **[Slither](https://github.com/crytic/slither)**\
  A static analysis framework for detecting vulnerabilities.
* **[solidity-coverage](https://github.com/sc-forks/solidity-coverage)**\
  Provides code coverage metrics for Solidity tests.

## Smart contract archives

* **[Smart contract sanctuary](https://github.com/tintinweb/smart-contract-sanctuary)**\
  A collection of contracts verified on Etherscan.
* **[EVM function signature database](https://www.4byte.directory)**
* **[EVM verified contracts on Etherscan](https://etherscan.io/contractsVerified)**
  If you are adventurous: Check the verified contracts on Etherscan directly.

## Using the OpenZeppelin Wizard

OpenZeppelin provides a convenient web-based wizard to create standard contracts. Visit the docs section for it [here](/evm/evm-wizard) or [https://wizard.openzeppelin.com/](https://wizard.openzeppelin.com/) to access it.

The wizard allows you to:

1. Select the contract type (ERC20, ERC721, ERC1155, etc.)
2. Configure settings, features, and access controls
3. Add custom functionality through a user-friendly interface
4. Generate ready-to-use Solidity code

The wizard is perfect for:

* Beginners learning smart contract development
* Quickly bootstrapping standard token contracts
* Exploring different configuration options
* Understanding best practices in contract development

## Best Practices & Security Considerations

When developing on Sei EVM with OpenZeppelin contracts, follow these best practices:

1. **Always use the latest version** of OpenZeppelin contracts
2. **Start with existing, audited components** rather than building from scratch
3. **Run comprehensive tests** before deploying to mainnet
4. **Consider upgradeability** for complex applications
5. **Use access controls** like `Ownable` or `AccessControl` for privileged functions
6. **Implement reentrancy guards** where needed
7. **Avoid `transfer()` and `send()`** for ETH transfers, use `call()` with reentrancy protection
8. **Validate all inputs** and check for edge cases
9. **Consider gas optimization**, but not at the expense of security
10. **Consider getting an audit** for high-value contracts