ERC-404 is a new token standard combining features of ERC-20 and ERC-721, allowing tokens to be both divisible and unique. It enables the creation of tokens with native liquidity and fractionalization opening new possibilities for asset representation and interoperability within the Ethereum ecosystem.

A Deep Dive into ERC-404 Token Standard and Crafting your Custom Token

In this Tutorial, We’ll go through the process of building a basic Lending Protocol.

Build Your Own Decentralized Lending Protocol

In this Tutorial, We’ll go through the process of building a basic Decentralized Exchange.

Build your own Decentralized Exchange


Summary of what we will do.

1. Developing the NFT Marketplace Smart Contract
2. Getting up the infra needed to deploy the Contract
3. Deploying the NFT Marketplace Smart Contract
4. Listing and Buying NFT from the Marketplace.  


In this Tutorial, We’ll go through the process of building the smart contracts that hold the business logic for our NFT marketplace.

Building a Decentralized NFT Marketplace with Solidity and Hardhat: A Step-by-Step Tutorial


Summary of what we will do.

1. Developing the voting Smart Contract.
2. Getting up the infra needed to deploy Contract.
3. Deploying the voting Smart Contract.
4. Starting an Election and Voting.


A Step-by-Step Guide to Building and Deploying a Voting Smart Contract on the Blockchain.

Build a Voting Smart Contract 

Learn how to create an NFT lottery smart contract along with a front-end to let the user buy the tickets.

NFT Lottery DApp

In this tutorial, you'll deploy ERC721 NFT Staking smart contract by leveraging BuildBear's No-Code deployment solution.

Deploy Your Own ERC721 NFT Staking with Infinite Rewards with BuildBear's No-Code Deployment

In this Tutorial, We’ll go through the Euler Finance’s 196 Million Flash Loan Exploit

Euler Finance’s 196 Million Flash Loan Exploit

In this Tutorial, We’ll go through the process of building and deploy an ERC 1155 smart contract.

Learn and deploy an ERC 1155 smart contract

Testing smart contracts is a crucial aspect of the development process to ensure that the contracts function correctly and are error-free. Hardhat is a development environment for Ethereum applications that offers various tools and libraries to facilitate smart contract testing

Mastering Smart Contract Testing: A Comprehensive Guide to Hardhat

Things that you should actually know to code safe protocols.

Re-constructing the GDS Hack

In this Tutorial, We’ll go through the Recreating Kubz NFT Hack.

Recreating Kubz NFT Hack

Spark is a decentralized non-custodial liquidity market protocol where users can participate as suppliers or borrowers. 

Unveiling the Power of Spark Protocol: A Comprehensive Review


Magic technology, advancing civilization, short letters, privacy, and a future that's already here. That's Zero Knowledge Proofs (ZKPs) in a nutshell. What's going on?

Zero Knowledge Proofs are magic. They allow us to do things we couldn't dream of before.

A Friendly Introduction to Zero Knowledge


Using the project’s code base and test frameworks for trying exploits, written as unit tests.

This method has a few advantages:
- Sometimes contracts are deployed, but there isn’t solid info on finding them. Using the development team’s code base makes things easier because you don’t have to interact with deployed contracts.
- You can easily test contracts that are in scope for the bounties but haven’t been deployed yet. Forking the mainnet wouldn’t help you here.
- Sometimes project code bases already have tons of tests and scenarios ready. You just need to tweak a few lines of a unit test to test an exploit.
- Project development teams are familiar with their unit tests. A new unit test using the same practices is easier for them to validate than a stand-alone PoC (proof of concept).

Being able to quickly modify an existing test and check if an exploit works is a valuable asset to have in your toolkit.

This step-by-step guide will help you use developmental test code to validate smart contract exploits

A guide for reusing test code to validate smart contract exploits


Blockchains revolutionized fundraising for open-source software, but not everything worked right from the start. In fact, ICOs of the 2016-2018 era were often horribly broken mechanisms that allowed founders to cash out before delivering any products. Many lessons have been learned since, with today’s projects having a working product before launching a token and distributing it to incentivize usage and decentralize governance.

NFTs are proving to be another clear product-market-fit for crypto, but they are experiencing their own growing pains. The life of every NFT begins in an NFT launch (also sometimes called a mint or drop). An NFT launch is where a new collection is first created, sold, and distributed to buyers, who then decide to hold or trade it in secondary markets.

Like any item that goes on sale for the first time, NFT launches face the challenge of pricing something that has never had a price before. But unlike most other sales, they have the added difficulty of taking place in a highly adversarial environment full of idiosyncrasies that already alienate inexperienced users—a public blockchain. As a result, developers have to design mechanisms that are efficient and robust to exploitation.

This article starts with real-world examples of launches that empirically hurt their users to identify what goals a good launch should satisfy. Next, we deconstruct the idea of a launch into individual steps, exploring the design space for each of them. Finally, we provide a reference implementation of what we think is one well-designed launch mechanism for the community to use and build on.

This article starts with real-world examples of NFT launches and explores the design space for well-designed launch mechanisms for the community to use and build on.

A Guide to Designing Effective NFT Launches


So, you’ve heard about this Ethereum thing and are ready to venture down the rabbit hole? This post will quickly cover some blockchain basics, then get you interacting with a simulated Ethereum node – reading block data, checking account balances, and sending transactions. Along the way, we’ll highlight the differences between traditional ways of building apps and this new decentralized paradigm.

This post will cover some blockchain basics, then get you interacting with a simulated Ethereum node using Python

A Python Guide to Ethereum, Pt. 1


Whether you’re starting out developing your first smart contract, or you’ve already written and deployed a few of them, there’s going to be a point where you’ll wonder how the interaction with your smart contracts is made possible. In this post we’re going to explore ABI encoding, the encoding format used to talk to an EVM (Ethereum Virtual Machine) to execute smart contract functions.

This will be a bit of a deep dive and fairly interactive, so buckle up.
I hope you’ll enjoy it!

Learn to read and understand EVM calldata

ABI Encoding and EVM Calldata demystified


If you want maximum arbitrage performance, you need to swap tokens between exchanges in a single transaction. Or maybe you just want to save gas on certain swaps you perform regularly. Or maybe you have your own custom use case for swapping between decentralized exchanges. And of course maybe you are just here for the learning aspect.

How to better arbitrage with Solidity by making multiple swaps across different decentralized exchanges in a single transaction

Advanced MultiSwap


Build better contracts and applications on top of Ethereum or any EVM based blockchains.

Article series that aims to help smart contracts developers.

All about Solidity


One of the most exciting recent advances in the field of cryptographic proof systems is the development of STARKs. It comes in the wake of a booming blockchain industry, for which proof systems in general seem tailor-made: blockchain networks typically consist of mutually distrusting parties that wish to transact, or generally update collective state according to state evolution rules, using secret information. Since the participants are mutually distrusting, they require the means to verify the validity of transactions (or state updates) proposed by their peers. Zk-SNARKs are naturally equipped to provide assurance of computational integrity in this environment, as a consequence of their features:

- zk-SNARKs are (typically) universal, meaning that they are capable of proving the integrity of arbitrary computations;
- zk-SNARKs are non-interactive, meaning that the entire integrity proof consists of a single message;
- zk-SNARKs are efficiently verifiable, meaning that the verifier has an order of magnitude less work compared to naïvely re-running the computation;
- zk-SNARKs are zero-knowledge, meaning that they do not leak any information about secret inputs to the computation.

This tutorial series explains the mechanics of the STARK proof system. It is directed towards a technically-inclined audience with knowledge of basic maths and programming.

Anatomy of a STARK


This monorepo will help you get started with building on Arbitrum. It provides various simple demos showing and explaining how to interact with Arbitrum — deploying and using contracts directly on L2, moving Ether and tokens between L1 and L2, and more.

We show how you can use broadly supported Ethereum ecosystem tooling (Hardhat, Ethers-js, etc.) as well as our special arb-ts library for convenience.


This monorepo will help you get started with building on Arbitrum. It provides various simple demos showing and explaining how to interact with Arbitrum

Arbitrum Tutorials

Guide walking through creating a tokenized asset contract and deploying it on Goerli

Ethereum: Asset tokenization with Embark


It's not a secret that passwords are a relic from a different century. However, modern cryptography provides us with far better means to authenticate with applications, such as Ethereum's Secp256k1 public-private key pairs. This article is a complete step-by-step deep-dive to securely establish a Ruby-on-Rails user session with an Ethereum account instead of a password. In addition, it aims to explain how it's done by providing code samples and expands on the security implications.

This article is a complete step-by-step deep-dive to securely establish a Ruby-on-Rails user session with an Ethereum account instead of a password.

Authenticating Rails users with MetaMask 


A curated list of awesome Web3 resources, libraries, tools and more.

Awesome Web3


Becoming a blockchain engineer is the most fun, rewarding, and exhilarating choice I’ve and my colleagues have ever made. And we’ve already blazed the trail for you to get started! In this article, we will show you exactly how to learn to become a blockchain engineer, from beginner to professional.

Spoiler alert, here is the exact blueprint we are going to cover to get you to a successful blockchain engineer:

1. Understand why you should become a blockchain engineer
2. Take a Blockchain Course
3. Join a Hackathon, the Community, & Build
4. Start your own protocol, Take a job, Freelance & Contribute

If you make it this far, you’ve done it! Although, I’ll add a bonus step 5 that we will talk about soon.

5. You’ve made it! Keep learning!

That’s it! These are the exact steps you need to take to become a blockchain engineer!

Become a blockchain, solidity, and smart contract engineer by following these steps

Become a Blockchain Engineer


From time to time, I receive messages asking me for advice on how to get started as a smart contract security auditor. While there are already articles written about this topic, most of them are just a collection of security-related articles which they throw at beginners, overwhelming them. I’ll provide a path that I would take if I had to do it all over again. This will be ETH specific (or more general EVM-specific) as most auditing work is currently still in this ecosystem.

At the end, I’ll also go over frequently asked questions that are related to auditing and getting your first job.

This guide provides a path on how to get started as a smart contract security auditor.

Become a smart contract auditor


Yul is an intermediate programming language that can be used to write a form of assembly language inside smart contracts. Although we often times see Yul used inside smart contracts, you can write a smart contract entirely in Yul. Understanding Yul can level up your smart contracts and allow you to understand what is going on under the hood in solidity, which in turn can help you save user’s gas costs. We can identify Yul in a smart contract with the following syntax.

Yul is an intermediate programming language that can be used to write a form of assembly language inside smart contracts

Beginner's Guide to Yul


A curated list of FREE resources for learning blockchain development and Web3 in general. Featuring free learning platforms, websites, online courses, tutorials, documentation, games, project starter templates, articles, and books; useful for blockchain enthusiasts, engineers, crypto enthusiasts, developers, designers, and stakeholders in the web3 space.

A curated list of free resources for learning blockchain development.

Blockchain Development Resources

Guide walking through deploying and bridging an ERC20 token

Polygon: Bridging ERC-20 from Ethereum to Polygon


The journey of building a Cross-Platform Solana Wallet to learn the basics to interact with Solana Blockchain.

Blog post series to build step by step a Solana Wallet

Building in Public an Open Source Solana Wallet Cross-Platform App with Expo, Web3 and React Native


Circom is a fantastic tool for learning zk-snarks. However, because it is quite low-level, there are more opportunities to accidentally add subtle bugs. In real applications, programmers should consider using higher level zero knowledge programming languages. You should always get an audit before deploying a smart contract that holds user funds, but this is especially true for zk circuits, as the attack vectors are less well known.


This tutorial introduces the Circom language and how to use it, along with common pitfalls

Circom language tutorial with circomlib walkthrough


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.

A guide on smart contract patterns & practices

Clean Contracts


in this post I’ll be showing how to use a library called web3-react in order to connect users to MetaMask or any wallet from your frontend.

Connect Users to MetaMask

This article walks you through how to build a zk-circuit using the halo2 rust crate by the Zcash team.

Constructing ZK SNARK Circuits

In this tutorial, you will learn how to build a 2-way cross-chain communication smart contract with Solidity and Axelar General Message Passing (GMP)

How to Create a 2-way Communication Smart Contract With Solidity and Axelar


This is a step-by-step guide on how to build a Zero Knowledge (zk) Decentralized Application (DApp) from zero to production.

The goal is to explain the flow of a zk dapp and deploy it so that users can use it.

- We will create a zk DApp to prove that someone knows how to solve a sudoku game, without revealing the answer.
- We will use Circom (for circuits), Solidity (for smart contracts) and Javascript (for the frontend).
- I will cover circuits and smart contracts testing.
- I will give some tips that I use to build and organize this kind of projects.

How to create a Zero Knowledge DApp: From zero to production


Payments are a reoccurring topic across pretty much every area of crypto, specifically providing payments to multiple stakeholders. For instance, a DAO wants to provide funding to multiple initiatives, a DEX want to consolidate and distribute trading fees to certain participants, or a team wants to distribute tokens to team members as a monthly paycheck.

Smart contracts allow us to automate these type of payment functions, which limits potential mistakes caused by manually managing payments and allows us to spend our valuable time on other productive tasks.

Today we will learn how to create our own ERC20 token payment splitter that can be incorporated into any project!

Create an ERC20 token payment splitting smart contract


My Twitter feed has tons of avatar profile pictures, articles are coming out daily showcasing some large NFT sales, and people are earning money with their in-game creatures...

I guess this means it's time to go down the NFT rabbit hole. So let's get to it!

This article introduces NFT's and guides you through creating your NFT collection on Ethereum using solidity.

Create your own NFT collection on Ethereum w/Solidity

This article will serve as a guide through the process of developing a crypto wallet application. By utilizing the powerful combination of web3.js v4

Creating a Wallet Application Using web3.js v4 and ReactJS


DappTools is a suite of Ethereum focused CLI tools following the Unix design philosophy, favoring composability, configurability and extensibility.

But so is hardhat, right?

Yeah, but hardhat is not perfect and the JavaScript based testing workflow is a nightmare and has following issues:

- So much boilerplate
- Context switching: The mental gymnastics of switching between two different languages to test the same functionality is like having a penguin as your co worker, you might think it’s exotic and adds value. But it doesn’t.
- It gets complicated real fast.
- Its painfully Slow for complex tests, you are still making RPC calls behind the scenes And no, adding typescript to the equation doesn’t help.

Simply put, working with JavaScript to test solidity is like trying to put out a fire by blowing at it, it works for a small fire, it gets increasingly difficult to put out as it gets bigger. And before you know it, you’re out of breath and in tears wishing there was a fire extinguisher all along. DappTools is the fire extinguisher. It can help you fix bugs in your smart contracts that can cost you millions of dollars.

DappTools is a suite of Ethereum focused CLI tools following the Unix design philosophy, favoring composability, configurability and extensibility.

DappTools: Supercharge Your Smart Contracts


Libraries are similar to smart contracts, but, typically, are only deployed once. Their code is reused by taking advantage of delegatecall(). This means that the context of the code is executed in the calling contract. The library functions will not be explicitly visible in the inheritance hierarchy. The use of delegatecall() can allow us to access state variables from our calling smart contract. However, since libraries are an isolated piece of code, you must supply the state variables for the library to access them.

In this article we will look at how the EVM interprets libraries, and walk through an example of how to create one.

Deep Dive Into Solidity Libraries


Python is one of the most versatile programming languages; from researchers running their test models to developers using it in heavy production environments, it has use cases in every possible technical field. In today's guide, we will learn about Brownie, a Python-based tool used to write and deploy smart contracts.

Prerequisites
- Python3 installed
- Ethereum node
- Text editor
- Command-line
- Love for brownies

How to deploy a smart contract with Brownie

Deploy a contract with Brownie


If you're new to smart contract development and looking to get started on the Polygon network, this guide is an excellent resource to have. It provides clear and concise steps on how to create and deploy a smart contract using GetBlock endpoints, Metamask, and Remix. The tutorial is easy to follow and provides preparatory steps to ensure a smooth deployment process.
The best part is that you can test your smart contract using the Polygon test network, allowing you to experiment and learn without any risk. The guide's community of Web3 developers is always available to chat and answer any questions you may have.


This guide provides a step-by-step tutorial on how to create and deploy a smart contract on the Polygon test network using GetBlock endpoints, a virtual wallet (Metamask), and Remix.

Deploy a Smart Contract on Polygon using GetBlock

An Ethereum proxy contract that can be used for deploying contracts to a deterministic address on any chain. 

Deterministic Deployment Proxy

This article walks you through a Capture the Flag (CTF) challenge on Fibonacci

Develop EVM assembly opcode logic for Fibonacci


I don’t know about you dear reader, but I hate reading research papers. They are overly complex, introduce inhuman scribbles called “scientific notation” and are pain to read. So, I won’t go through Ethereum yellow paper, but rather we’ll go deep into go-ethereum - Ethereum execution client implementation in Go language.

Dissecting EVM using go-ethereum - Part 1

Dissecting EVM using go-ethereum - Part 2

Dissecting EVM using go-ethereum - Part 3


The EIP-2535 standard has several projects already using it, most notably Aavegotchi holding many millions of dollars.

What is it and should you use it instead of the commonly used proxy upgrade pattern?

We're not talking about diamond programmer hands here of course. A diamond refers to a smart contract system where functionality and storage is split up into separate contracts. You might already be familiar with the upgrade proxy pattern. It shares some similarities to a diamond. In short to fix the problem of smart contracts not being upgradable due to their immutability, a proxy pattern deploys two contracts.

EIP-2535: A standard for organizing and upgrading a modular smart contract system.

EIP-2535 Diamond standard

ERC-7201 is a standard for grouping storage variables together by a common identifier called a namespace and to document the group via NatSpec.

ERC-7201 Storage Namespaces Explained


One of the most significant smart contract standard on Ethereum is known as ERC-20, which has emerged as the technical standard used for all smart contracts on the Ethereum blockchain for fungible token implementations.

The ERC-20 defines a common list of rules that all Ethereum tokens must adhere to. Consequently, this token standard empowers developers of all types to accurately predict how new tokens will function within the larger Ethereum system. This simplifies and eases developers’ tasks, because they can proceed with their work, knowing that each and every new project won’t need to be redone every time a new token is released, as long as the token follows the rules.

Understand the ERC20 token smart contract

ERC20 token standard

Protocols that are meant to work with ERC20 tokens can face a number of different issues that at first glance aren't that obvious.

ERC20 Weirdness & Attacks Part 1

Ethereum Dev Speed Run


A guide to available tools, components, patterns, and platforms for developing applications on Ethereum.

Creation of this list was spurred by product managers at ConsenSys who saw a need for better sharing of tools, development patterns, and components amongst both new and experienced blockchain developers.

A guide to available tools, components, patterns, and platforms for developing applications on Ethereum.

Ethereum developer tools list

Ethereum logs tutorial series: Logs and filters


Your entire Ethereum (and almost every other blockchains) wallet is accessible by your private key, which is basically a random 256 bits long number. In fact, you could enter any 32 hex characters long key, and import an account to your Metamask for example. If you want to try this out, there are two ways: some websites like https://keys.lol/ allow you to see random private keys, and even compute their balance. However, I’d be tempted to think that if you use such websites to compute a private key, you’ll probably won’t be able to withdraw from one whose balance is not zero, as there’s a high chance the website installed a bot that filters the latter and instantly transfers the funds to another address, such as the website owner’s.

This article is an introduction to possible attacks against cryptography algorithms used in blockchains and is to arouse your curiosity about cryptography.

Ethereum private keys attacks


Solidity events are integral for smart contract developers, allowing smart contracts to be tested for specific variables, frontends to be changed in an automated manner, and much more. In general, knowing how to use events in Solidity makes smart contract development a whole lot easier.

In this post, we’ll look into the logging and events feature of the Ethereum Virtual Machine (EVM) from a smart contract developer’s perspective, covering what logging and events are used for, indexed events, and how to use logging and events in Hardhat and Brownie. 

Solidity events are integral for smart contract devs, allowing smart contracts to be tested for specific variables, frontends to be changed in an automated manner, and much more.

Events & Logging in solidity


This tutorial will teach you how to query onchain data using the amazing Dune Analytics platform. Dune Analytics is the all-in-one destination to query, visualise, share and explore human readable smart contract data. It’s trusted by a lot of awesome companies like Gnosis, Compound and Bancor. 

This tutorial will teach you how to query onchain data using the amazing Dune Analytics platform.

Explore Ethereum Data with Dune Analytics


Ethereum allows us to build decentralized applications (dapps). The main difference between a typical application and a dapp is that you don’t need to deploy a backend—at least as long as you take advantage of the other smart contracts deployed on the Ethereum mainnet.

Because of that, the frontend plays a major role. It is in charge of marshaling and unmarshaling the data from the smart contracts, handling the interactions with the wallet (hardware or software) and, as usual, managing the UX. Not only that, by design, a dapp uses JSON-RPC calls and it can open a socket connection to receive updates.

As you can see there are a few things to orchestrate but don’t worry, the ecosystem has matured quite a lot in the last few months.

How to Fetch and Update Data From Ethereum with React and SWR

Fetch data from Ethereum with SWR


NFTs, as unique items on the blockchain, has a URI that points to data containing the metadata & the corresponding visuals. This URI can be an HTTP link, pointing to a video or image hosted on a normal server, or other services like IPFS (hash-based addresses), or Arweave (incentivized hosting of hash-based content).

There is another way, however, a format that's become increasingly popular: the usage of a data URI. These URIs contain all the information within it. There is thus no server at the other end. Using data URIs has allowed NFT creators to experiment with putting all the content related to an NFT 'on-chain'. It adds a vector of permanence to the art. If Ethereum continues, it does not need ancillary infrastructure to support it. A common format, currently, is to store the NFT visuals as SVG in the data URI, since most browsers are able to natively parse it.

It's fun, and due to some of the constraints of smart contract coding (limited execution & expensive storage), it becomes in itself a game of gas golf, trying to pack as much as one can into the architecture to create dynamic art that will live (currently) forever on Ethereum.

Store NFT visuals as SVG in the data URI, so it does not need ancillary infrastructure to support it.

Flavours of On-Chain SVG NFTs

A Comprehensive Guide for Testing with Hardhat

Forking Ethereum Mainnet


What is Formal Verification?
What is Symbolic Execution? 

Troy Interview: https://www.youtube.com/watch?v=H52U4ibkf5Q
Josselin Interview: https://www.youtube.com/watch?v=3pWYvtx_sjA

✍️ Article: https://medium.com/@patrickalphac/formal-verification-symbolic-execution-38e0ac9072eb
🗻 Code Examples: https://github.com/PatrickAlphaC/denver-security/tree/main
🟩 Comparing Symbolic Execution tools: https://hackmd.io/@SaferMaker/EVM-Sym-Exec
📚 Invariant vs Fuzz: https://ethereum.stackexchange.com/questions/144691/whats-the-difference-between-invariant-and-fuzz-testing
🛠️ Foundry Invariant: https://book.getfoundry.sh/forge/invariant-testing
🦔 Echidna: https://github.com/crytic/echidna


We look at formal verification & symbolic execution with two Trail of Bits Web3 security team members. Additionally, we review the value these techniques bring and compare them to other tools.

Formal Verification & Symbolic Execution | The Security Silver Bullet?


Wrapped ETH, or WETH, is one of Ethereum’s most popular smart contracts. While WETH serves a simple purpose, a significant portion of all Ethereum transactions depend on it. WETH now underpins large parts of DeFi. In this blog post, we prove critical safety guarantees and invariants within the WETH contract. We do so by leveraging Z3, a battle-tested SMT solver.

Proving the safety of the Wrapped ETH smart contract, using the Z3 Theorem Prover

Formally Verifying The World’s Most Popular Smart Contract


We learn exactly how web3 / blockchain / smart contract applications work in the front end using HTML and Javascript. We then go through 6 different ways you can connect your Metamask, Phantom, or other blockchain wallet address to your front end. We’ll look at popular Nextjs / React packages to make your development lifecycle 100 times easier.

💻 Code: https://github.com/PatrickAlphaC/full-stack-web3-metamask-connectors
✍️ Article: https://betterprogramming.pub/everything-you-need-to-know-about-fullstack-web3-94c0f1b18019?sk=a2764bcbdae98bf05e1052931de77982
NextJS: https://nextjs.org/


We learn exactly how web3 / blockchain / smart contract applications work in the front end using HTML and Javascript. We then go through 6 different ways you can connect your Metamask, Phantom, or other blockchain wallet address to your front end. We’ll look at popular Nextjs / React packages to make your development lifecycle 100 times easier. 

Full Stack Web3 — Everything You Need to Know


What are Fuzz tests?
What are invariant tests?
What are they for? 

The fuzz/invariant test suite is one we at Cyfrin use to find high-severity issues quickly before we jump into the manual review!

This is the new FLOOR for security in Web3. Please understand your invariants and write fuzz tests for them! 

✍️ Article: https://medium.com/@patrickalphac/fuzz-invariant-tests-the-new-bare-minimum-for-smart-contract-security-87ebe150e88c
👌 Using the Handler Method: https://mirror.xyz/horsefacts.eth/Jex2YVaO65dda6zEyfM_-DXlXhOWCAoSpOx5PLocYgw
📚 Invariant vs Fuzz: https://ethereum.stackexchange.com/questions/144691/whats-the-difference-between-invariant-and-fuzz-testing
🛠️ Foundry Invariant: https://book.getfoundry.sh/forge/invariant-testing
🦔 Echidna: https://github.com/crytic/echidna


What is fuzz testing? What are invariant tests? We introduce how to use these tools in Web3 & Solidity and explain why they are essential, especially for security. 

Fuzz / Invariant Tests | The New Bare Minimum For Smart Contract Security


Writing smart contracts is hard. Not only do you get a single chance to write bug-free code, but depending on exactly how you write, it’ll cost your users more or less to interact with it.

When you compile a smart contract, every line of Solidity gets converted into a series of operations (called opcodes), which have a set gas cost. Your goal is to write your program using as little opcodes as possible (or replace the most expensive with cheaper ones).

Of course, this is all very complex, so let’s take it slowly. Instead of going down the opcode rabbit hole, here are some simple optimizations you can apply to your contracts today.

The basics of optimizing Solidity contracts, explained for regular coders.

Gas Optimizations for the Rest of Us


Have you ever wondered what lies under the hood of the Ethereum network? How the transaction is made. How the data was passing around. And what is it made of?

This blog is intended to be a very basic introduction to how to look at Ethereum Calldata (Or any other EVM based Calldata) we're going to look at how it structures, what it keeps, and how it can be categorized into what ways.

The highlight of this article is we will also be revealing how to generate Ethereum Calldata without writing a single line of code - the Laika🐶 way!


This article explains what Ethereum Calldata is and how it's structured.

Get to know Ethereum Calldata


Diving into the difference in RPC methods on Geth and Erigon, written by the Chainstack Developer Experience Team.


In-depth tutorial on RPC methods for Geth and Erigon

Geth vs Erigon: Deep dive into RPC methods on Ethereum clients

SSX is a library that enables you to easily add user authentication, session management, and more to your dapp.

Getting started with SSX


It supports cloning, pushing ( with pushing with force), pulling, using branches, working with remotes & checking out previous commits & files. It also includes a nifty diff viewer.

The app does not handle more advanced tasks such as rebasing, squashing and the like. But you should find the basics to be ample.

Remix release v0.18.0 now includes full support for a plugin called dGIT that allows you to interact with GitHub as if you were doing it on your terminal or in VSCode.

GitHub in Remix IDE


I remember watching the events of the Poly Network hack and being at a loss for words. My mind began to fire off on all cylinders trying to piece together how it had happened. Blockchain-related hacks were quite common by this time, but this was one of the first that had made its way to my ears. And although the hacker returned the funds, the event itself was wild enough to be memorable, to spark my curiosity, and to set me on the path to become a hacker…again.

Blockchain hacking is one of the more elusive paths in cybersecurity, but taking it remains one of the best decisions I’ve ever made. It’s groundbreaking, challenging, and extremely rewarding, both intellectually and financially. I’ve had to get knee deep into the intricacies of how things work — something I didn’t do in other disciplines. Smart contract hacking is a form of art, and there’s nothing more beautiful than watching an exploit and the series of transactions that follow.

Being a whitehat hacker in the Web3 space feels a lot like being a superhero. Nothing beats the elation that comes from saving the common man millions of dollars, especially because many are just trying to get by in a system designed to fail them. The financial benefits that come from being at the forefront of technological breakthroughs aren’t bad, either. Bug bounties of up to 2.5 million USD are being paid out for critical bugs, and the average yearly salary at a blockchain security firm is $150,000.

To top it off, most of these opportunities are fully remote, meaning you can work from home.

Join me, Anon, on this path that very few walk. Join me in saving Web3 and becoming a legend. We need you to prevent the next big hack.

Join me, Anon, on this path that very few walk. Join me in saving Web3 and becoming a legend. We need you to prevent the next big hack.

Hacking the Blockchain: An Ultimate Guide


Welcome to our beginners guide to Ethereum contracts and dApp development. This tutorial is aimed at hackathon participants who are getting setup to quickly build something from scratch.

To orchestrate this process we're going to use Hardhat, a development environment that facilitates building on Ethereum. It helps developers manage and automate the recurring tasks that are inherent to the process of building smart contracts and dApps, as well as easily introducing more functionality around this workflow. This means compiling and testing at the very core.

Hardhat also comes built-in with Hardhat Network, a local Ethereum network designed for development. It allows you to deploy your contracts, run your tests and debug your code.

A beginners guide to Ethereum contracts and dApp development

Hardhat's tutorial for beginners


If you are new to blockchain development and don’t know where to start, or if you just want to understand how to deploy and interact with smart contracts, this guide is for you. We will walk through creating and deploying a simple smart contract on the Ropsten test network using a virtual wallet (Metamask), Solidity, Hardhat and Truffle, and Alchemy (don’t worry if you don’t understand what any of this means yet, we will explain it!).

This is a step-by-step introductory tutorial that will teach you how to create and deploy a smart contract on Ethereum

Hello World Smart Contract


This is an example for high-speed EVM blockchain event reading in Python. The example shows How to read Solidity events, or use eth_getLogs RPC, to maximize output.

Solidity event high-speed multithread reading

We review use cases and implications of Meta-Transactions.

How does Ethereum Manage Data


Odds are you’ve heard about the Ethereum blockchain, whether or not you know what it is. It’s been in the news a lot lately, including the cover of some major magazines, but reading those articles can be like gibberish if you don’t have a foundation for what exactly Ethereum is. So what is it? In essence, a public database that keeps a permanent record of digital transactions. Importantly, this database doesn’t require any central authority to maintain and secure it. Instead it operates as a “trustless” transactional system — a framework in which individuals can make peer-to-peer transactions without needing to trust a third party OR one another.

Still confused? That’s where this post comes in. My aim is to explain how Ethereum functions at a technical level, without complex math or scary-looking formulas. Even if you’re not a programmer, I hope you’ll walk away with at least better grasp of the tech. If some parts are too technical and difficult to grok, that’s totally fine! There’s really no need to understand every little detail. I recommend just focusing on understanding things at a broad level.

Many of the topics covered in this post are a breakdown of the concepts discussed in the yellow paper. I’ve added my own explanations and diagrams to make understanding Ethereum easier. Those brave enough to take on the technical challenge can also read the Ethereum yellow paper.

Many of the topics covered in this post are a breakdown of the concepts discussed in the yellow paper. I’ve added my own explanations and diagrams to make it easier.

How does Ethereum work, anyway?


Tornado cash is a cryptocurrency smart contract mixer that enables users to deposit crypto with one address and withdraw with another wallet without creating a traceable link between those two addresses.

Web3 Tutorials

💻 Become a Blockchain Engineer

💻 How does Ethereum work, anyway?

💻 The Complete Guide to Full Stack Ethereum Development

Newsletter