
Building Ethereum Dapps teaches Dapps development on the Ethereum blockchain platform. You'll begin with a mental model of how Dapps operate, and then dive into designing and implementing smart contracts in Ethereum's Solidity language. You'll explore Ethereum smart contract development tools, like Truffle and Web3, and pick up best practices for design and security. Practical exercises throughout give you valuable hands-on experience. 

In this book, you'll learn the principles of Dapps development by rolling up your sleeves and actually building a few!

Building ethereum dapps decentralized applications on the ethereum blockchain


As IBM´s official liaison to the Ethereum core developers I gave talks on blockchain topics pretty much around the world. After one keynote I was asked for a non-technical guide to understand blockchains. This is it.

The book aims to help you get your head around blockchains in general and around Ethereum specifically. Since Ethereum is currently the pre-imminent blockchain, it makes sense as reference point. The essential stuff is the same for any blockchain.

This text was written for people with a fast grasp, who are not programmers. Reading this should give you the basics to cut through the hype and to identify blockchain opportunities in your professional domain. There are tiny bits of code, which can be admired and skipped.

We´ll look at Ethereum´s benefits first, how it is used and what can be done with it; then explain blockchain machinery, visiting the terms that you´ll be confronted with in every discussion about its application. Exactly what you need to tell the signal from the noise in the echo chamber of honest misunderstandings and desperate marketing.

We take a good hard look at limitations, throw in some history and names and give a realistic outlook.

The index reads like an FAQ and you can use the book like that. However, there is a strong build up, one chapter leading to the next, as optimized path to understanding all the interconnected, moving parts. There´s quite a number of them.

Blockchains are not a trivial topic. The fact that blockchain client programs are small has fooled many people into believing it can´t possibly be that hard. The challenges are in the implications though.

But what’s in this book will put you ahead of almost everyone outside the core bubble.

A deep dive into this field now – at least getting started – will help you to become part of the fun ahead. It should allow you to stand out, land deals or a great job.

It will also make you see first hand how early we are in the game.

Hopefully, we will find a contributor to the blockchain community in you, strengthening the portfolio of real-world use cases. Ideally, you´ll learn to navigate your own uncharted course through your domain and revolutionize it.

The book aims to help you get your head around blockchains in general and around Ethereum specifically as it's the preeminent blockchain.

Ethereum: Blockchains, Digital Assets, Smart Contracts, Decentralized Autonomous Organizations


Technology is constantly evolving, and blockchain is taking development to new places, as mobile did a decade ago – and Ethereum is the leading platform for creating this new wave of applications. This book reveals everything you need to create a robust decentralized application (more commonly known as DApp). Unlike other books on the topic, this one focuses on the web application layer, and guides you in creating great experiences on top of the Ethereum blockchain. You’ll review the challenges and differences involved in developing DApps as opposed to traditional web applications. 

After a brief introduction to blockchain history and Ethereum in particular, you’ll jump directly into building a sample decentralized application, to familiarize yourself with all the moving pieces. This book offers specific chapters on querying and rendering data from the blockchain, reacting to events, interacting with user accounts, sending transactions, managing gas, handling confirmations and reorganizations, and more. You will also find a chapter dedicated to Solidity that will give you the necessary means to understand and even build your own smart contracts. 
Other important topics covered include building backend servers that act as indexing layers, and managing storage efficiently with solutions like the interplanetary file system, or IPFS. Last but not least, you will find chapters that examine the biggest problems on Ethereum today: onboarding and scalability. These include the state of the art of the available strategies to tackle them, such as meta-transactions, smart accounts, ENS, state channels, sidechains, and more.

Learn to Build Web Applications on top of the Ethereum Blockchain

Ethereum for Web Developers


Foundry is a smart contract development toolchain. Foundry manages your dependencies, compiles your project, runs tests, deploys, and lets you interact with the chain from the command-line.


A book on all things Foundry, a smart contract development toolchain.

Foundry Book


Ready to dive into smart contract development for the blockchain? With this practical guide, experienced engineers and beginners alike will quickly learn the entire process for building smart contracts for Ethereum--the open source blockchain-based distributed computing platform. You'llget up to speed with the fundamentals and quickly move into builder mode.

It's the perfect resource for people who want to break into the smart contract field but don't know where to start.

Hands-On Smart Contract Development with Solidity and Ethereum: From Fundamentals to Deployment


In non-technical terms, this book explains Digital Contracts: legally enforceable smart contracts that anyone can read.

You do NOT need prior knowledge about blockchains.

The book outlines the concept, gives examples, provides links to online tools that help to write, sign, deploy and manage digital contracts on the blockchain. Lexon’s grammar, vocabulary and document structure are illustrated. Lexon's paradigm is explained, including how it differs from other programming languages, staying closer to human thought. Lexon’s relationship to Computational Law and AI is discussed and applications and benefits are detailed. The appendix lists notable steps towards human-readability by other programming languages, complemented with notes on constructed human languages.


In non-technical terms, this book explains Digital Contracts: legally enforceable smart contracts that anyone can read.

Lexon: Digital Contracts


Ethereum represents the gateway to a worldwide, decentralized computing paradigm. This platform enables you to run decentralized applications (DApps) and smart contracts that have no central points of failure or control, integrate with a payment network, and operate on an open blockchain. With this practical guide, Andreas M. Antonopoulos and Gavin Wood provide everything you need to know about building smart contracts and DApps on Ethereum and other virtual-machine blockchains.

Discover why IBM, Microsoft, NASDAQ, and hundreds of other organizations are experimenting with Ethereum. This essential guide shows you how to develop the skills necessary to be an innovator in this growing and exciting new industry.

A guide to the operation and use of Ethereum and other EVM-compatible blockchains.

Mastering Ethereum


Solidity design patterns are a critical component of smart contract development, enabling developers to create robust, efficient, and secure decentralized applications. "Solidity Design Patterns - Best Practices & Techniques for Developing Smart Contracts" is a comprehensive ebook available on Amazon that delves into the various design patterns used in Solidity smart contract development.

The ebook provides a detailed explanation of popular design patterns like the Security, Gas Optimisation, Proxy, and many more. It also covers the latest design patterns used in the development of decentralized finance (DeFi) applications. The ebook provides a step-by-step guide to help developers understand and implement these patterns to create high-quality smart contracts.

With Solidity design patterns, developers can create reusable code, minimize errors, and make their smart contracts more secure.The ebook provides practical examples, code snippets, and diagrams to help readers understand and implement these patterns in their projects.

Whether you are a beginner or an experienced developer, "Solidity Design Patterns - Best Practices & Techniques for Developing Smart Contracts" is an essential resource that provides a comprehensive guide to developing high-quality smart contracts. With the latest design patterns and best practices, this ebook is a must-have for anyone looking to excel in smart contract development. Get your copy today on Amazon and start building better smart contracts!


An Essential guide to developing Smart contract on Ethereum with Solidity Design Patterns.Solidity design patterns are a critical component of smart contract development, enabling developers to create robust, efficient, and secure decentralized applications.

Solidity Design Patterns


Solidity Starters : A Beginners Friendly book 
Learn Smart contract development with solidity language, Fundamentals of solidity, Beginners guide to solidity & Ethereum blockchain programming 2022
Dive into the exciting world of blockchain development with Solidity, the programming language used by Ethereum.

Blockchain developers are in high demand these days, and the demand is only going to grow. But what skills do you need to become a blockchain developer? How can you start learning about the technology?

Learn to create and deploy your first smart contract and decentralized app.

In this course, you will learn everything you need to know to create and deploy your first decentralized app with a smart contract. You will get an introduction to Solidity and how smart contracts work, as well as how the Ethereum blockchain stores information. We'll go through tools you can use to deploy your Dapp and write code in Solidity. By the end of the course, you should have an understanding

Create Web 3 dApps with solidity and use Data Structures to store data in a decentralized ledger.

This is a book for those interested in creating decentralized applications with Solidity, the programming language for smart contracts. You will learn how to create Dapps that store data in decentralized ledger.

This practical guide teaches budding Ethereum developers how to create smart contracts and DApps using Solidity.

This guide will help developers take their first steps in the decentralized world of Ethereum development, teaching them how to create smart contracts and DApps using Solidity, the programming language for Ethereum.

Covers the latest version of Solidity,Build decentralised applications that cannot be censored or shut down.

With the rise of the internet, we have seen an increase in the use of centralised applications. This has led to many security and censorship problems. Decentralised applications are a solution to these issues. Decentralised applications are typically open-source, have transparent data sharing and management systems, have a consensus mechanism for content submission, allow for privacy and anonymity of users, and do not rely


After finishing this Book, You will have a solid foundation in Solidity and a high degree of experience, allowing you to start creating and quickly expanding your knowledge.


A Beginners Friendly book to Learn Smart contract development with solidity language, Fundamentals of solidity, Beginners guide to solidity & Ethereum blockchain programming 2022.

Solidity Starters: A Beginners Friendly book


Capture the Ether is a game in which you hack Ethereum smart contracts to learn about security.

It's meant to be both fun and educational.

This game is brought to you by @smarx, who blogs about smart contract development at Program the Blockchain.

Capture the Ether is a game in which you hack Ethereum smart contracts to learn about security.

Capture the Ether


Cipher Shastra is a playground where anyone can enhance their Security Skills by solving and learning from CTF like challenges. 

The playground is open source and anyone can contribute challenges to it
Twitter: @ciphershastra

Cipher Shastra


Learn to Code Blockchain DApps By Building Simple Games

CryptoZombies is an interactive school that teaches you all things technical about blockchains. Learn to make smart contracts in Solidity or Libra by making your own crypto-collectibles game.

#1 Solidity Tutorial & Ethereum Blockchain Programming Course

CryptoZombies


More and more DeFi projects on Ethereum are getting hacked. This is your chance to join the party.

Each challenge can be considered standalone. Depending on the challenge, you should either stop the system from working, steal as much funds as you can, or do some other unexpected things.

Put your black hat on, and break some DeFi projects on Ethereum!

Damn Vulnerable DeFi


At PHDays security conference a new contest called EtherHack was held, to solve all tasks which featured smart contract vulnerabilities.

Etherhack


The Ethernaut is a Web3/Solidity based wargame inspired on overthewire.org, played in the Ethereum Virtual Machine. Each level is a smart contract that needs to be 'hacked'.

The game is 100% open source and all levels are contributions made by other players. Do you have an interesting idea? PRs are welcome at github.com/OpenZeppelin/ethernaut.

A Web3 based wargame played in the Ethereum Virtual Machine

The Ethernaut


This is an interactive tutorial website for learning Vyper while building games using smart contracts, similar to Cryptozombies.

VyperFun


If you're a dev that's curious about crypto but not sure where to start -- this is the spot for you. Get access to project-based courses you'll love.

Learn about crypto by building cool stuff.

_buildspace


Whether you're a curious hacker or an experienced engineer, 30 Days of Web3 is project-based curriculum created by developers to teach you how to build full-stack dapps.


The Ultimate Guide to Building Fullstack Dapps

30 Days of Web3


Wanna dive into Solana development? Let's do it right now with ICB platform🎉
Learn the Rust + Solana development course and get a job as a Solana developer.

The FREE course is available on the platform.
You will learn:

- How to write software using Rust, you will quickly get a good understanding of the type system, ownership, error handling, traits, and more
- How Rust helps you build robust and maintainable software
- What the Rust ecosystem offers
- Who is using Rust
- How can you gain further Rust development knowledge
- What is Solana blockchain, its differences from Ethereum, and cases when you should prefer Solana
- Fundamental features of the Solana such as Account, PDA, CPI, storage and rent, and more
- How to write production-ready programs with the Solana-SDK
- Most common vulnerabilities and security best-practice
- What is the Anchor framework, and what benefits it brings for Rust\Solana developers


 Learn the FREE Rust + Solana development course and get a job as a Solana developer.

Rust-and-Solana-development-for-beginners-ICB


In October 2016, the Berkeley Bitcoin Association, a group of about a dozen members, founded Blockchain at Berkeley, an organization dedicated to becoming the blockchain hub of the East Bay. They also debuted the world’s first undergraduate university-accredited blockchain course, Blockchain Fundamentals, taught to about 50 students. Alongside Blockchain at Berkeley’s education team grew a consultancy that aimed to bridge the gap between geeky bitcoin enthusiasts and technovative early-adopters in the industry to develop Proof-of-Concepts for disruptive blockchain use cases. Since then, as a result of other ambitious B@B members, R&D and Design departments have also emerged.

Join over 150,000 students in earning our renowned BerkeleyX Blockchain Fundamentals Professional Certificate, with our free online course series.

Blockchain @ Berkeley


This specialization introduces blockchain, a revolutionary technology that enables peer-to-peer transfer of digital assets without any intermediaries, and is predicted to be just as impactful as the Internet. More specifically, it prepares learners to program on the Ethereum blockchain. The four courses provide learners with (i) an understanding and working knowledge of foundational blockchain concepts, (ii) a skill set for designing and implementing smart contracts, (iii) methods for developing decentralized applications on the blockchain, and (iv) information about the ongoing specific industry-wide blockchain frameworks.

The specialization covers a range of essential topics, from the cryptographic underpinnings of blockchain technology to enabling decentralized applications on a private Ethereum blockchain platform. 

It is ideal for programmers and designers involved in developing and implementing blockchain applications, and anyone who is interested in understanding its potential. 

Innovate with the Next Frontier in Technology. Learn how the blockchain is leading to a paradigm shift in decentralized application programming

Blockchain Specialization


NFTs, non-fungible tokens, have taken the online world by storm ushering in the proclamation of a new world-wide web... web3.

For most, NFTs mean profile pictures (pfps). 🐵

This isn't the most practical use case, even if it is a lot of fun

Even if you wanted to create useful NFTs, it’s not easy to get started.

Since the tooling is still being developed, it can be confusing as to where to get started. It also doesn't help that there's a paradigm shift with app development from web2 to web3.

Here be dragons 🐉

This course is here to get you through that initial learning curve and frustrating lack of answered questions and good documentation.

Through building this project you will learn the general development lifecycle of NFT smart contracts and dApps giving you the skills to start your own projects.

By the end of this course, you will be able to do the following

- Use the OpenZeppelin Solidity library to create NFT smart-contracts
- Deploy smart contracts to Ethereum testnets
- Host static assets on IFPS
- Create a React dApp that interacts with your smart-contract API
- Confirm a wallet owns an NFT

This course will help you build a ticketing and proof-of-attendance service complete with wallet QR code scanning, using Solidity and React

Build a NFT ticketing service"


Cadena helps developers transition into web3 tuition free.
Learn by coding smart contracts, NFTs, tokens and more with our free courses. 
Then earn an NFT Certificate that unlocks exclusive job opportunities and perks.


Self paced tutorials to learn Web3 by building

Cadena


Blockchain is an exciting new discipline in Computer Science. It combines a wide array of skills from math and cryptography to social sciences and understanding organizations. Understanding blockchain decentralization and how/where to apply it is a brand new skill that very few have mastered.

You will build your skills from the ground up with strong fundamentals that will provide you with the ability to adapt in this rapidly evolving ecosystem.

Choose From Multiple Paths to Begin Your Ethereum Coding Journey.

Fast-track your Ethereum Developer career in an instructor-led and challenging bootcamp focused on discussion and application!

ChainShot


Smart Contracts? They're here.  The Ethereum Blockchain?  Covered.  Solidity?  Yep!

There can be no understating it: Ethereum and Blockchain technology is the most disruptive force in years.  Companies cannot hire developers who understand blockchain technologies fast enough, but there are a tiny number of resources published to help you truly understand what blockchains are used for, let alone build apps with them.  That's the purpose of this course: to be the best resource online for learning about Ethereum, blockchains, and how to build apps with this new technology.

The development community is still figuring out the best way to use Ethereum in the creation of new and exciting apps.  I spent a tremendous amount of time to research and create best practice for interfacing with Ethereum from Javascript.  I can't overstate it enough; this course will show you the best and most easily repeatable patterns for creating production-ready apps with Ethereum.

Use Ethereum, Solidity, and Smart Contracts to build production-ready apps based on the blockchain

Code with Ethereum & Solidity


Become a certified blockchain developer

Blockchain Developer Online Bootcamp

Get the skills you need to become an industry-leading Ethereum developer with our flagship Blockchain Developer Bootcamp! In our cohort-based bootcamp, you'll join a robust community of other students and developers and learn fundamental Ethereum concepts, key tools, security best practices, and smart contract/dApp development. You'll work in teams and have live access to Academy Ethereum experts through our online portal and office hours. You also get lifetime access to the community and one free year of access to the course materials through our alumni program.

ConsenSys Academy’s mission is to develop the global blockchain ecosystem by bridging the Ethereum knowledge gap, and revolutionizing education through blockchain technology.

ConsenSys Academy


Welcome to the Ethereum Blockchain Developer Bootcamp With Solidity. The only course you'll need to become an Ethereum blockchain developer.

With over 1,900 ⭐️⭐️⭐️⭐️⭐️ reviews, this course is one of the highest-rated Ethereum blockchain development courses online.

Updated video tutorials, practical projects, and fast support in the discussion board are how you master Ethereum blockchain development.

At 13+ hours, this Ethereum blockchain development course is undoubtedly the most comprehensive course of its kind anywhere online.

Even if you have zero or limited programming experience, this course will take you from beginner to Ethereum blockchain developer.

Become An Ethereum Blockchain Developer With One Course. Master Solidity, Web3.JS, Truffle, Metamask, Remix & More!

Developer Bootcamp with Solidity (2021)


An in-depth course about developing Full-Stack applications on Ethereum blockchain. It covers the basics of Ethereum and its infrastructure, Solidity programming language, setting up a development environment, testing smart contracts, creating libraries in Solidity, writing frontend for Dapps, and much more.


In-depth course about developing DApps on Ethereum

Developing Applications on Ethereum Blockchain


- Intensive, remote live courses and teaching.
- 50 person cohorts, daily sessions, weekly homework and projects, mentorship and support.
- You get placed in a crypto job after successfully completing a bootcamp!


Encode Club Bootcamps


This learning path introduces you to blockchain and development on the Ethereum platform. Discover what skills are necessary to learn to begin building your own blockchain networks at scale.

In this learning path, you will:

- Learn the foundations of blockchain and how blockchain technology works.
- Gain an understanding of the tools to develop on the Ethereum blockchain.
- Create smart contracts and decentralized applications.
- Deploy to local and test Ethereum networks.

This learning path introduces you to blockchain and development on Ethereum. Discover what skills are necessary to learn to begin building your own blockchain networks at scale.

Get started with blockchain development


This course contains the practical part of a university course on enterprise blockchain technologies. Typically, a university course is divided into theory and laboratory classes. The theory explains the theoretical foundations behind what is learned in the laboratories. At the end of this course, you will:

1. Understand the theory on blockchain: what is it (Lab 1, Lab2), and which problems it can solve (Lab 3)

2. Get to know Hyperledger Fabric's components in detail, such as architecture and transactional model (Lab 4), chaincode (Lab 5), network, and how to develop an enterprise full-stack blockchain decentralized application (Lab 6)

3. Leverage Hyperledger Umbra to study advanced topics on Fabric (Lab 7, Lab 8)

This free, open-source course aims at providing a reliable basis for university students to get started in enterprise blockchain. 

Enterprise Blockchain Technologies


Learn the basics of Solidity: the language to create smart contracts.

Introduction to Smart Contracts


Blockchain Foundation Program
Ethereum Fundamental Courses
Certified Blockchain Associate Program
Certified Hyperledger Fabric Developer Program

Kerala Blockchain Academy (KBA) offers training programs, consultancy services, and research activities in multiple domains of Blockchain Technology

Kerala Blockchain Academy


https://www.youtube.com/watch?v=gyMwXuJrbJQ

This course will give you a full introduction into all of the core concepts in blockchain, smart contracts, solidity, NFTs/ERC721s, ERC20s, Coding Decentralized Finance (DeFi), javascript and solidity, Chainlink, Ethereum, upgradable smart contracts, and full stack blockchain development.   

Some of the technologies covered are:
- The Graph
- Chainlink
- Metamask
- Alchemy
- Remix
- Hardhat
- Solidity
- Openzeppelin
- Trail of Bits
- Ganache
- Ethers
- Etherscan
- Coinmarketcap
- Aave
- IPFS
- Fleek.hq
- Filecoin
- NextJS
- Moralis
- Web3uikit
- Opensea
- Pinata
- Nft.storage

 And more!

Follow along with the videos and you'll be a blockchain wizard in no time!  💻 The repository with helpful links to all code, resources, and support forums is located here: https://github.com/smartcontractkit/full-blockchain-solidity-course-js.

This course will give you a full introduction into all of the core concepts related to blockchain, smart contracts, Solidity, ERC20s, full-stack Web3 dapps, decentralized finance (DeFi), JavaScript, TypeScript, Chainlink, Ethereum, upgradable smart contracts, DAOs, the graph, moralis, aave, IPFS, and more. Follow along with the videos and you'll be a blockchain wizard in no time!

Learn Blockchain, Solidity, and Full Stack Web3 Development with JavaScript – 32-Hour Course


This is the place for you if you're a developer who is interested in cryptocurrencies but is unsure of where to begin. Get access to classes with projects you'll love.


Learn about web3 and blockchain through creating awesome things.

metaschool


Node Guardians is a platform for builders, thinkers, and stakers. Our mission is to bolster innovative and promising crypto ecosystems, and contribute to the future of a decentralized internet. We do this through education and infrastructure.

### Education

Ecosystems need talented builders. There is a need to onboard and upgrade more developers into industry-standard builders across different protocols. We design a catalog of coding challenges that aim to engage smart contract developers of all levels, and equip them with knowledge on how to build safer, better, and smarter.

Beyond practical skills, we also aim to empower the space with theoretical knowledge in an unbiased manner, through growing a library of literature on crypto history, technology, and economics, written by us and the community.

### Infrastructure

Ecosystems need decentralized security. For proof-of-stake chains, this means more stakers and validators. We provide infrastructure for non-custodial staking that places an emphasis on availability and security. This enables users to stake their assets, act as validators in the ecosystem, and earn rewards.

On-chain governance is taken very seriously at Node Guardians. As validators, we aim to vote on proposals that push towards more decentralized & robust protocols, and proposals that are aligned with our community’s interests.  Expect full transparency on our governance choices through regular recaps.

a platform for builders, thinkers, and stakers. Our mission is to bolster innovative and promising crypto ecosystems, and contribute to the future of a decentralized internet.

Node Guardians


Questbook is a decentralized university where learning is always free. We enable with our cryptoeconomics and a native erc20 coin that powers the ecosystem. 

Wikipedia is where the world collaborates on facts, StackOverflow is where the world collaborates on technical question answers, but where does the world collaborate on great tutorials? That is the gap that Questbook fills. All the content is created collaboratively by the community and contributors are compensated by tokens from Questbook and other retroactive grants. 

Questbook will train the next 10 Million web3 developers not only with bite sized content created by the community but also by making it accessible on a mobile phone. Users will be able to learn and write web3 programming directly from a mobile phone. No need for a laptop. This unlocks a huge market in India, Southeast Asia, Africa and Latin America where many people don’t have access to a laptop - but have a mobile phone. But, it also allows those with access to be able to learn on the go.


Questbook


This is an initiative for the early solidity developers by those who were early developers sometime.

In this approach, we are looking to categorize the smart contract according to the difficulty level in multiple standards. For now, we are keeping the standard 0 to 5(can be discussed).

This initiative needs great support from Blockchain enthusiast, developer and researchers to build this school in a way which can attract learners and provide them ease for development.

First place for early developers to learn Solidity 

solidity-school


Join a community of Web3 engineers & educators that can help you supercharge your way into Web3 development.


Acquire foundational knowledge to start your path to becoming a Web3 engineer.

Teach Yourself Web3


![Smart_Contract_Auditor_RoadMap](https://user-images.githubusercontent.com/54918791/174233728-015bd233-1df9-49fb-a6a3-2af970d90b60.png)  


Available at: https://coggle.it/diagram/YqLzaiSABzXD4UnZ/t/smart-contract-auditor  
PDF: [Smart Contract Auditor.pdf](https://github.com/razzorsec/AuditorsRoadmap/files/8934042/Smart.Contract.Auditor.pdf)

### Step by Step Approach  

* [Mastering Ethereum](https://github.com/ethereumbook/ethereumbook)  
* Proof of Work vs Proof of Stake
* Solidity Fundamentals
  * [Solidity Documentation](https://docs.soliditylang.org/en/latest/)
  * [Solidity Docs](https://docs.soliditylang.org/en/v0.8.13/index.html)
  * [Smart Contract Programmer - Solidity 0.8](https://www.youtube.com/playlist?list=PLO5VPQH6OWdVQwpQfw9rZ67O6Pjfo6q-p)
  * Connect Missing Dots with Secureum
    * [Secureum Solidity 101](https://secureum.substack.com/p/solidity-101?s=r)
    * [Secureum Solidity 201](https://secureum.substack.com/p/solidity-201?s=r)

* Gas Optimizations
  * [Aggregated Tricks by pcaversaccio and Harikrishnan Mulackal](https://forum.openzeppelin.com/t/a-collection-of-gas-optimisation-tricks/19966/6)
  * [Kaden: Gas Optimization Tips](https://betterprogramming.pub/how-to-write-smart-contracts-that-optimize-gas-spent-on-ethereum-30b5e9c5db85)
  * [Juan: Advanced Gas Optimizations](https://dev.to/juanxavier/advanced-gas-optimizations-tips-for-solidity-1j2f)

* Smart Contract Testing
  * [Hardhat](https://hardhat.org/guides/waffle-testing.html)
  * [Better Programming Hub](https://betterprogramming.pub/the-complete-hands-on-hardhat-tutorial-9e23728fc8a4)
  * [Code Eater (Hindi)](https://www.youtube.com/watch?v=vuqhHOx6188&list=PLgPmWS2dQHW9mucRpDVe16j9Qn74ZXqcD&index=5)
  * [Foundry](https://github.com/foundry-rs/foundry)
  * [Tenderly](https://tenderly.co/)

* [ERC Standards]()
  * [Token Standards](https://ethereum.org/en/developers/docs/standards/tokens/)ERC20, ERC721, ERC777, ERC1155, ERC4626, BEP20
  * Other Standards: [ERC2981](https://eips.ethereum.org/EIPS/eip-2981)

* [Openzeppelin Helper Libraries/Contracts](https://github.com/OpenZeppelin/openzeppelin-contracts)

* Upgradeable Contracts
  * [Smart Contract Programmer - Upgradeable Contracts](https://www.youtube.com/watch?v=JgSj7IiE4jA&t=157s)
  * [Smart Contract Programmer - Risks of Upgradeable Contracts](https://www.youtube.com/watch?v=XmxfB5JOt1Q&t=3s)
  * [Different Proxy Patterns - EIPs 897, 1822, 1967, 1538, 2535](https://ethereum-blockchain-developer.com/110-upgrade-smart-contracts/00-project/)

* Attack Vectors
  * [Secureum Security Pitfalls 101](https://secureum.substack.com/p/security-pitfalls-and-best-practices-101?s=r)
  * [Secureum Security Pitfalls 201](https://secureum.substack.com/p/security-pitfalls-and-best-practices-201?s=r)
  * [SWC Registry](https://swcregistry.io/)
  * [Smart Contract Programmer - Hack Solidity](https://www.youtube.com/watch?v=4Mm3BCyHtDY&list=PLO5VPQH6OWdWsCgXJT9UuzgbC8SPvTRi5)
  * [Kaden: Smart Contract Attack Vectors](https://github.com/KadenZipfel/smart-contract-attack-vectors)

* [CTFs](https://github.com/blockthreat/blocksec-ctfs)
  * [Ethernaut](https://ethernaut.openzeppelin.com/)
  * [Capture The Ether](https://capturetheether.com/)
  * Read Walkthroughs

* DeFi
  * [Finematics - DeFi](https://www.youtube.com/watch?v=pWGLtjG-F5c&list=PLjrTIwaNiTwn39tg3sR_bPBWGHoznv47D)
  * [Smart Contract Programmer - DeFi](https://www.youtube.com/watch?v=qB2Ulx201wY&list=PLO5VPQH6OWdX-Rh7RonjZhOd9pb9zOnHW)
  * Well known protocols: Uniswap v2/v3, Compound, Curve, Aave, Balancer.
  * [Stablecoins](https://blog.chain.link/what-are-stablecoins/) => [Algorithmic Stablecoins](https://cointelegraph.com/altcoins-for-beginners/a-beginner-s-guide-on-algorithmic-stablecoins)
  * Staking Rewards, Vaults

* DeFi Attack Vectors
  * Flash Loan => Price Oracle Manipulation
  * Front-Running => Sandwich attacks
  * Rug Pulls => Unlimited Token Allowance

* [CTFs](https://github.com/blockthreat/blocksec-ctfs)  
  * [Damn Vulnerable DeFi](https://www.damnvulnerabledefi.xyz/)
  * Read Walkthroughs

* Postmortems
  * [Immunefi](https://medium.com/@immunefi)
  * [BlockSec](https://blocksecteam.medium.com/)
  * [SlowMist](https://slowmist.medium.com/)
  * [Rekt News](https://rekt.news/)
  * [PeckShield](https://twitter.com/peckshield)
  * [Mudit Gupta](https://twitter.com/mudit__gupta)
  * [Samczun](https://twitter.com/samczsun)

* Report Reading
  * [Secureum Audit Findings 101](https://secureum.substack.com/p/audit-findings-101?s=r)
  * [Secureum Audit Findings 201](https://secureum.substack.com/p/audit-findings-201?s=r)
  * Trail of Bits, Consensys, Openzeppelin, QuillAudits

* Security Standards & Checklists
  * [Rari-Capital Solcurity](https://github.com/Rari-Capital/solcurity)
  * [SCSVS](https://github.com/securing/SCSVS)

* Tools
  * [VS Code IDE](https://code.visualstudio.com/)
  * [Slither](https://github.com/crytic/slither)
  * [Mythril](https://github.com/ConsenSys/mythril)
  * [Mythx](https://mythx.io/)
  * [Echidna](https://github.com/crytic/echidna)
  * [Manticore](https://github.com/trailofbits/manticore)
  * [Surya](https://github.com/ConsenSys/surya)
  * [Scribble](https://github.com/ConsenSys/scribble)
  * [BlockSec ETH/BSC Tx Analysis](https://versatile.blocksecteam.com/tx) 
  * [ethtx ETH Tx Analysis](https://ethtx.info/)
  
* Continue Learning
  * [Ethereum Yellow Paper](https://github.com/ethereum/yellowpaper)
  * [Ethereum Improvement Proposals (EIPs)](https://eips.ethereum.org/)
  * [Eth Research](https://ethresear.ch/)
  * NewsLetters - Blockthreat, HashingBits
  * Communities
    * Immunefi, Secureum, Blockchain Pentesting( discord )  
    * Eth Security Community (Telegram)
  * Be Active on Twitter


This roadmap provides a step by step approach to become an Ethereum Smart Contract Auditor

Ethereum Smart Contract Auditor Roadmap


## What is a smart contract?

Smart contracts are the backbone of decentralized applications (DApps) and Web3. A smart contract is a simple program that lives on a blockchain network (such as Ethereum). They're actually not that smart. And nothing like a (legal) contract. They’re more like an executable piece of code that requires input or an trigger from an external source. They can validate those input conditions and if correct, execute their own logic to update the state on a blockchain.

## Benefits

They often serve the following purposes:
- Store and maintain data
- Manage relationships with users, or other contracts

Benefits of smart contracts are
- Immutable - once deployed none can change them
- Composable - they’re public and anyone can interact with them, or build on top of them. Much like public APIs

## Resources

The following resources have been the most popular resources on the site for a long time. These are all highly recommend to start learning about Solidity


### 1. Official Solidity website
The most obvious resources is ofcourse the official website and documentation of the Solidity team itself. The Solidity team covers all the core concepts and fundamentals of Solidity and smart contracts in general. Highly recommended

https://soliditylang.org/


### 2. Solidity by Example
The second one on the list is Solidity by Example. A great collection of more pratical examples, incl. source code and supporting videos.

https://solidity-by-example.org/


### 3. CryptoZombies 
CryptoZombies is an interactive school that teaches you all things technical about blockchains. A fun and interactive way to write smart contracts in Solidity by making your own crypto-collectibles game.

https://cryptozombies.io/


### 4. Speedrun Ethereum

Speedrun Ethereum helps you get to the next level. It teaches you how to build on Ethereum; the superpowers and the gotchas while you build up your Web3 portfolio. If you like this, also make sure to check out the other work of the amazing [Austin Griffith](https://twitter.com/austingriffith) such as [ETH-build](https://eth.build/) and [Scaffold-eth](https://scaffoldeth.io/).

https://speedrunethereum.com/


### 5. Smart Contract Best Practices 

Smart contracts are complex instruments that have the authority to allocate high-value resources between complex systems. Often working autonomously. With huge financial loss at risk. This makes them critical components in these systems. Development of such components requires thoughtful design, solid engineering practices, rigorous testing and a strong security mindset. This document provides a baseline knowledge of security considerations.

https://consensys.github.io/smart-contract-best-practices/


## Other resources

If you'd like to read more, make sure to checkout all the other [Solidity](/tags/smart%20contracts) resources on the site.

Solidity is a programming language designed for developing smart contracts that run on Ethereum. It's the most in demand skill in the Web3 space. These are the best resources to help you learn more about it.

Best resources to learn Solidity


Blockchain and smart contract development are still relatively new and highly experimental. They require a different engineering mindset than traditional web, or app development where ‘move fast and break things’ has become the norm. 

Blockchain development is much more like hardware, or financial service development. Smart contracts are complex instruments that offer the possibility to have self-enforcing contracts including transparent, tamper-proof, and immutable information. They have the authority to allocate high-value resources between complex systems. Often working autonomously. With huge financial loss at risk. This makes smart contracts critical components in these systems. Development of such components requires more investment, design, and effort upfront. Solid engineering practices, rigorous testing, and a strong security mindset. 

In a series of blog posts, I’m planning to go through several patterns, practices, and principles that can be applied to blockchain and smart contract development to reduce the risks associated with it. 


# Clean Code 

![WTFs/minute](../assets/images/wtfs-minute.jpeg)

In this first article, I’ll cover more general engineering practices based on the concepts of Clean Code. Clean code is a well-known concept within the software development industry. [Robert C Martin, also known as 'Uncle Bob' wrote the famous handbook](https://amzn.to/30RsoKk). Its principles go back to even the earlier concepts of the Agile manifesto and software craftsmanship. It’s a knowledge base for the way we think, write, and read code. Build on decades of wisdom in software development. 

> *“Truth can only be found in one place: the code“* - Robert C. Martin 

Clean code is code that is easy to read. Easy to understand. And easy to maintain. Clean code is an attempt to make sense of the complexity of systems that we’re dealing with. It’s a defense mechanism that can provide guidance when you’re not sure how a change would affect the codebase. While there’s valid criticism on the handbook and the examples are considered outdated, the principles are still very relevant. Especially for object-oriented languages, such as Solidity. They apply to designing and writing secure, open, and immutable code, such as smart contracts.  

# Practices

## Naming
The naming of contracts, functions, or variables should reveal the intention, why it exists, and how it is used. If a name requires comments to explain, then it doesn’t reveal its intent. 

Be consistent in your naming throughout your code. Especially when you’re working with a large codebase. Use the same names for abstract concepts, throughout multiple contracts. 

Use pronounceable names. 

Use searchable names.

> *"There are only two hard things in Computer Science: cache invalidation and naming things."* - Phil Karlton

**References**
- [Code example](https://github.com/wslyvh/clean-contracts/tree/master/1-naming)
- [Solidity Style guide](https://solidity.readthedocs.io/en/latest/style-guide.html)


## Structure & Ordering 

Ordering helps readers identify which functions they can call and to find the constructor and fallback definitions easier.

### Order of Layout 

Layout contract elements in the following order:

1. Pragma statements
1. Import statements
1. Interfaces
1. Libraries
1. Contracts

Inside each contract, library or interface, use the following order:

1. Type declarations
1. State variables
1. Events
1. Functions

### Ordering of Functions 

Functions should be grouped according to their visibility and ordered:

1. constructor
1. receive function (if exists)
1. fallback function (if exists)
1. external
1. public
1. internal
1. private

Explicitly label the visibility of functions and state variables. Functions can be specified as being `external`, `public`, `internal`, or `private`. Please understand the differences between them.

### Ordering of Modifiers

The modifier order for a function should be:

1. Visibility
1. Mutability
1. Virtual
1. Override
1. Custom modifiers

**References**
- [Code example](https://github.com/wslyvh/clean-contracts/tree/master/2-structure)
- [Solidity Style guide](https://solidity.readthedocs.io/en/latest/style-guide.html)


## Documentation & Natspec 

Solidity contracts can have a form of comments that provide rich documentation to others reading the code as well as end-users. This is called the Ethereum Natural Language Specification Format, or [NatSpec](https://solidity.readthedocs.io/en/latest/natspec-format.html).

This documentation is segmented into developer-focused messages and end-user-facing messages. These messages may be shown to the end-user (the human) at the time that they will interact with the contract (i.e. sign a transaction).

It is recommended that Solidity contracts are fully annotated using NatSpec for all public interfaces (everything in the ABI).

**References**
- [Code example](https://github.com/wslyvh/clean-contracts/tree/master/3-documentation)
- [NatSpec](https://solidity.readthedocs.io/en/latest/natspec-format.html)


## Formatting 

Reading code should be like reading this blog, an article, or a book. It should be well formatted. The Solidity style guide provides guidance for writing Solidity code. The goal for it is not to be the right or only way, but to be consistent. 

Consistency can be enforced by using a linter. This not only provides formatting and style guide validation but also includes security validation.

Linters for Solidity
- [Ethlint](https://github.com/duaraghav8/Ethlint) (formerly Solium)
- [Solhint](https://github.com/protofire/solhint) 
- [VS Code Solidity](https://github.com/juanfranblanco/vscode-solidity/)

Use a regular linter for your dapp development (e.g. eslint, depending on your language).

**References**
- [Code example](https://github.com/wslyvh/clean-contracts/tree/master/4-formatting)
- [Solidity Style guide](https://solidity.readthedocs.io/en/latest/style-guide.html)


## Contracts & Data structures 

- Contracts expose behavior and hide data (in abstraction. Not actually hiding data from others. No data on the blockchain is actually hidden, see chapter Contracts). This makes it easy to add new kinds of objects without changing existing behaviors. It also makes it hard to add new behaviors to existing objects.

- Data structures expose data and have no significant behavior. This makes it easy to add new behaviors to existing data structures but makes it hard to add new data structures to existing functions.

Clear separation of the two is important, due to the contract’s immutability. If you want to add logic or deploy new contracts, you want to be able to utilize the existing data structures. Separating the two can be done by storage contracts. We’ll cover these in more detail in another blog post. 


## Systems 

Keep it Simple Stupid ('KISS'). Complexity increases the likelihood of errors and unexpected behavior. Contracts should have one responsibility, and only one reason to change, supporting the Single Responsibility Principle. It's one of the most important concepts in OO design.

Keep your contracts small. Every line of code in a smart contract costs money to execute and storing data is expensive. A best practice is to store a pointer to data in a smart contract, rather than storing the data itself. For example, data can be stored using decentralized data storage providers such as IPFS.

Modularize your contracts to keep them small and utilize existing standards & libraries (see 'Standards & Libraries'). 

The same applies to functions. Functions should do one thing. They should do it well. They should do it only.

On blockchain everything is public. Private data and variables within a smart contract are not actually private. "Private" means within the execution scope of the contract, but the data is public and can be read by anyone. Keep this in mind when designing your programs.

Only use blockchain and smart contracts for the parts that need to be decentralized. 

> *"The first rule of functions is that they should be small. The second rule of functions is that they should be smaller than that."* - Robert C. Martin 


## Standards & Libraries 

An intrinsic feature of smart contracts is its composability. Turning every contract into a component and potential building block that others can leverage. A lot of these building blocks exist already and standards ensure the ease of use and development. The most well-known standard was created for the emerging token ecosystem and the exchanges serving it: the ERC20 standard.

Before you dive in and start writing your own, custom smart contracts, it’s wise to check if any standards or open-source components exist. If such standard contracts exist and are properly tested and audited, they can minimize the risk in your programs.

- Ethereum Improvement Proposals (EIPs) describe standards for the Ethereum platform, including contract standards. [Finalized ERC's](https://eips.ethereum.org/erc#final)
- [OpenZeppelin Contracts](https://openzeppelin.com/contracts/)


## Error handling 

Exceptions are a crucial part of modern software engineering. They require special treatment and can be extremely powerful. Instead of fighting them, we should try to leverage them, as an unhandled exception may cause unexpected behavior. 

When an exception is thrown in Solidity code, all state changes are rolled back and further execution is halted. Luckily, exception handling is built into Solidity (since 0.6). This is only available for external calls. 

Provide enough context with your exception to determine the source and cause of your error. 

Try to write tests that throw these exceptions.

Don’t return null. Don’t pass null to functions.

Guard Checks can help that the behavior of a smart contract and its input parameters are as expected.

Use `assert()`, `require()`, `revert()` properly. **assert** should be used to test for internal errors, and check invariants.
**require** should be used to test that inputs, contract state variables, or return values from external contracts are valid. 

If a transaction doesn’t have enough gas to execute, the out of gas error is not caught.


## Testing 

![Test my code](../assets/images/test-my-code.jpeg)

The same rules for clean code, apply to testing. Clean tests are tests that are easy to read. Easy to understand. And easy to maintain. Tests help you keep your code flexible, maintainable, and reusable. They validate the behaviors, reduce the risks of making unintended changes, and save time debugging and writing your code. 

### F.I.R.S.T

- **Fast** — Test should fast enough so that you want to run them frequently. It should help speed up your development process, not hinder it
- **Independent** — Tests should be independent of each other and able to run in any order
- **Repeatable** — Tests should be repeatable in any environment
- ** Self-validating** — Tests should a clear (boolean) output if it passes. 
- **Timely** — Tests need to be written in a timely fashion. Just before the production code. 

### AAA

The AAA (Arrange-Act-Assert) pattern is one of the most common standards in software testing. It suggests dividing your tests into the corresponding sections: arrange, act, and assert. Each one of them is responsible for the part in which they are named after.

- **Arrange** - The code required to set-up your test
- **Act** - Invocation of the method being tested
- **Assert** - Check whether the expectations are met

Use only one assert per test.

### Separation of tests 

- **Unit tests** determine whether an individual unit of source-code is fit for use. This is typically a single function, tested with different parameters to ensure it returns the expected values.
- **Integration tests** determine if independently developed units of software work correctly when they are connected. For smart contracts, this means interactions between different components of a single contract, or across multiple contracts.

### Test coverage 

Writing good tests to ensure your app is working as intended is not enough. If you're not measuring anything, it's hard to say exactly how much of your code is being tested. Test coverage (or code coverage) is a useful tool for finding untested parts of a codebase. 

There is much debate over how much should be covered. Just your best judgment, but aim for as high as possible. Untested code could do anything and result in unexpected behavior.

### Testing Tools 

- [Buidler](https://buidler.dev/) -  A task runner for Ethereum smart contract developers that allows you to deploy your contracts, run your tests and debug your code
- [OpenZeppelin Test environment](https://docs.openzeppelin.com/test-environment/) - Test Environment is a smart contract testing library: it provides utilities that help you write tests, but it doesn’t run your tests for you. Works with Mocha 
- [Brownie](https://github.com/eth-brownie/brownie) - A Python-based development and testing framework for smart contracts targeting the Ethereum Virtual Machine
- [Truffle](https://www.trufflesuite.com/truffle) - A development environment, testing framework and asset pipeline for blockchains using the Ethereum Virtual Machine (EVM)
- [Ganache](https://www.trufflesuite.com/ganache) - A personal blockchain for Ethereum development you can use to deploy contracts, develop your applications, and run tests
- [Solidity-coverage](https://github.com/sc-forks/solidity-coverage) (formerly Solcover) - Code coverage for Solidity smart-contracts


## Security & code analysis 

Static code analysis is the analysis of software that is performed without actually executing the program. In most cases the analysis is performed on some version of the source code. Anlaysis is usually performed by an automated tool (e.g. Sonarqube).

Analysis tools for smart contracts help identify smart contract vulnerabilities. These tools run a suite of vulnerability detectors and print out a summary of any issues found. 

### Analysis Tools

- [Echidna](https://github.com/crytic/echidna) - Ethereum smart contract fuzzer
- [Manticore](https://github.com/trailofbits/manticore) - Symbolic execution tool
- [Mythril](https://github.com/ConsenSys/mythril) - Security analysis tool for EVM bytecode
- [Oyente](https://github.com/melonproject/oyente) - An Analysis Tool for Smart Contracts
- [Slither](https://github.com/crytic/slither) - Static Analyzer for Solidity

### Gas Optimization

Optimizing gas costs can be a worthwhile endeavor, to reduce costs both for your own deployments, as well as for your end-users. Network usage is progressively increasing, with current gas costs at its peak. As the ecosystem continues to grow, so too will the value of gas optimization. We’ll cover these in more detail in another blog post. 

Analyzing your code can be done by using [eth-gas-reporter](https://github.com/cgewecke/eth-gas-reporter). It prints estimates of gas costs per function, or of each deployed contract. 



## Continuous Integration 

While not part of the clean code principles, continuous integration (‘CI’) has become a fundamental practice for any type software development. One of the key benefits of integrating regularly is that you can detect errors quickly and locate them more easily. 

It is based on a set of key principles.

- Keep a single repository where all the code lives and where anyone can obtain the current and previous versions (e.g. Git)
- Automate the build process so that anyone can use it to build directly from the sources (e.g. Truffle teams, Travis CI)
- Automate your tests so that anyone can run a full test suite at any time (see chapter Testing)
- Make sure anyone can view the results and get the latest executable from the build process

> *"Continuous Integration doesn’t get rid of bugs, but it does make them dramatically easier to find and remove."* - Martin Fowler

![Ship all the code](../assets/images/ship-all-the-code.jpeg)


## Further Reading 

Check out my [Clean Contracts](https://github.com/wslyvh/clean-contracts) repo for supporting code example from each chapter.

- [Clean Code](https://amzn.to/30RsoKk), Robert C. Martin
- [Solidity Patterns](https://fravoll.github.io/solidity-patterns/), Fravoll 
- [Ethereum Smart Contract Best Practices](https://consensys.github.io/smart-contract-best-practices), ConsenSys
- [Best Practices for Smart Contract Development](https://yos.io/2019/11/10/smart-contract-development-best-practices/), Yos Riady

Blockchain and smart contract development require solid engineering practices, rigorous testing, and a strong security mindset. This guide covers several patterns, practices, and principles to reduce the risks associated with it.

Clean Contracts - a guide on smart contract patterns & practices


Conversations with Solidity developers about the contracts they've written and the contracts they admire.

Solidity Galaxy Brain


This monorepo should allow you to get started with a simple Greeter smart contract on localhost and Rinkeby in record time with this basic react stack using

- Typescript
- NextJS
- Hardhat
- useDapp
- Tailwind CSS
- Redux Toolkit
- Yarn Workspace

Basic Typescript Starter

Celo Composer allows you to quickly build, deploy, and iterate on decentralized applications using Celo. It provides a number of frameworks, examples, and Celo specific functionality to help you get started with your next dApp.


Template to quickly build, deploy, and iterate on decentralized applications on Celo Blockchain.

celo-composer


Test, deploy, and interact with your smart contracts with this python brownie based framework!


Template for building smart contract projects in brownie with solidity, python, and chainlink. 

chainlink-mix


This repository contains a boilerplate for full stack development of a Zero Knowledge decentralized application with the use of DSLs and tools such as Hardhat, Circom, Snarkjs, Nextjs etc.


If you ever get stuck, and need a guide to reference, the guide written by Vivian Plasencia, "How to create a Zero Knowledge Dapp, from Zero to Production", is a great one, and where the inspiration for this boilerplate, was derived from. Find it [HERE](https://vivianblog.hashnode.dev/how-to-create-a-zero-knowledge-dapp-from-zero-to-production)

Ultimate Boilerplate for building full stack ZK decentralized application, with Circom, Snarkjs and Nextjs

Circom Next starter


Create Eth App supports multiple frontend frameworks. It comes with a host of decentralized finance templates pre-filled with contract ABIs, addresses and subgraphs. Everything you need to build a modern Ethereum-powered single-page app.

- Learning how to write Ethereum-powered apps in a comfortable and feature-rich development environment.
- Starting new Ethereum-powered single-page React applications without wasting time on copy-pasting boilerplates
- Creating examples with React for your Ethereum-related libraries and components.

Create Ethereum-powered apps with one command

Create Eth App


The complete toolbox to create full-stack web3 applications!


The complete toolbox to create web3 applications.

Create Web3 Dapp


This starter kit is composed of Next.js and Tailwind CSS, with RainbowKit, ethers, & wagmi for all your web3 needs. It uses Typescript and an opinionated directory structure for maximum dev confy-ness.

dApp Starter


Test, deploy, and interact with your smart contracts with this bash dapptools based framework!


Template for building smart contract projects in hardhat with solidity, bash, and chainlink. 

dapptools-starter-kit


✅ Type-Safe Contract-Interactions<br/>
✅ Multichain by default<br/>
✅ Production-Ready<br/>
✅ Maintained & Up-to-Date Packages<br/>

**The Stack:**

- Recommended Package-Manager: `pnpm`
- Monorepo Tooling: `turborepo`
- Smart Contract Development: `hardhat`
  - Deploy & ABI/Address-Export: `hardhat-deploy`
  - Typescript-Types: `typechain`
  - Vyper support: `hardhat-vyper`
- Frontend: `next`
  - Contract Interactions: `wagmi`, `rainbowkit`
  - Styling: `tailwindcss`
  - Styled Components: `twin.macro`, `emotion`
- Misc:
  - Linting & Formatting: `eslint`, `prettier`
  - Actions on Git Hooks: `husky`, `lint-staged`


Highly-integrated, fast, and type-safe monorepo with NextJS, Tailwind, Hardhat, wagmi.sh, and Rainbowkit.

ETHathon Full-Stack DApp Boilerplate


A monorepo boilerplate code for typesafe full-stack Solidity development based on template-ethereum-contracts .

Full-stack dApp starter for solidity smart contract development

Fullstack monorepo template


Simply Write, Test, Deploy, and Interact with your smart contracts with this javascript hardhat based framework containing various utilities for helping you out to easily manage your project.


Template for building smart contract projects in hardhat with solidity and javascript with necessary utilities.

hardhat-js-starterkit


Write smart-contracts that are typed, deployed, instantiated and connected to provider in React app.

Hardhat React boilerplate


Test, deploy, and interact with your smart contracts with this javascript hardhat based framework!


Template for building smart contract projects in hardhat with solidity, python, and chainlink. 

hardhat-starter-kit


A template to build a decentralised application using ethereum, buidler, svelte and thegraph

Jolly Roger


A simple template, having Next.js, Tailwind and Hardhat preconfigured 🔥


next-tailwind-hardhat


This is a default Next.js project bootstrapped with create-next-app, customized as the default boilerplate for new Web3 projects.

Features
- Separate packages from ethers.js for improved tree-shaking, often only ethers Contracts
- Hooks-first approach to fetching and caching data from Contracts and memoization for performance with SWR
- web3-react for ease of connecting to Web3 providers with a solid API
- Auto-generates types for the contract ABIs in the /contracts folder via TypeChain

Slightly opinionated Web3 boilerplate based on Next.js and SWR

Next Web3 boilerplate


A Simple, Minimalist Template for Noir Projects.

A Simple, Minimalist Template for Noir Projects

nplate


This is a collection of templates based on popular smart contracts like CoolCatsNFT and Loot.

Each contract is unique, addressing different aspects and mechanisms of the smart contract. Accompanying the contract is a detailed breakdown of how the contract is written and hardhat deployment scripts.

New contracts and breakdown are published every week.

Deployable templates of popular smart contracts

Popular Contract Templates


A one-click install local environment to build on Ethereum!


Forkable 'one-click install' ETH + Truffle + Ganache + VanillaJS dev stack to build locally

Quick dApp


Everything you need to build on Ethereum!

Quickly experiment with Solidity using a frontend that adapts to your smart contract

Forkable Ethereum dev stack focused on fast product iterations

Scaffold-ETH


Simple monorepo you can use as a template to start developing your dApp with Semaphore. 

Semaphore Boilerplate


This is a GitHub template, which means you can reuse it as many times as you want. You can do that by clicking the "Use this template" button at the top of the page.

Combines Hardhat, TypeChain, Ethers, Waffle, Solhint, Solcover and Prettier

Solidity template


Basic Sample Hardhat Project - with Starknet Plugin

This project demonstrates a basic Hardhat project, but with Starknet plugin.

Examples of how Starknet Hardhat plugin can be used.

Starknet Hardhat example

This repo shows how to connect your React app to StarkNet.

Starknet React example


Boilerplate for ethereum solidity smart contract development

Template to develop ethereum smart contracts

Template Ethereum contracts


This is a starter kit for developing, testing, and deploying smart contracts with a full Typescript environment. This stack uses Hardhat as the platform layer to orchestrate all the tasks. Ethers is used for all Ethereum interactions and testing.

Starter kit for smart contract development using Typescript

Typescript Solidity Dev Starter Kit


Introduces great features:

- React hooks - Uses React hooks as your primary building ingredient
- Auto refresh - Refreshes on a new block, wallet change or network change
- Multicall - Combines multiple blockchain calls into a single multicall

Combines the best practices:
- Modern stack - Employs ethers.js, web3-react, multicall & waffle
- Extendability - Extends easily with custom hooks
- Testability - Simple integration tests for UI and blockchain

Framework for rapid Dapp development. Simple. Robust. Extendable. Testable

#smart contracts

Newsletter