
This is a book for those who want to understand Ethereum 2.0 – Ethereum on proof of stake – at a technical level. What does it do? How does it work? Why is it like this?

Who am I writing for? For people like me! People who enjoy understanding how things work. But more than that, who like to know why things are the way they are.

Although I am an Eth2 staker, and an Ethereum user, I am not writing primarily for stakers or users here. Some of the generic material on Staking may be relevant (once I have written it), but you will find better help in places like the excellent Ethstaker community.

The scope of the book concerns (what I consider to be) the Ethereum 2.0 protocol. Ethereum 2.0 has become a less well-defined term recently. But for me, it broadly includes,

- all things proof of stake and the beacon chain,
- the process of The Merge at which Ethereum 1.0 moves to proof of stake,
- in-protocol data sharding, and
- an array of potential future enhancements.

I will not be covering any of the historic Ethereum 1.0 protocol, except as it touches upon The Merge. The Mastering Ethereum book is an excellent resource, and there is no point in duplicating it. Although roll-ups and other so-called layer 2 solutions have rapidly become part of the overall Ethereum 2.0 narrative, they are by definition not in-protocol, and I will not be covering them here. I will not be discussing, DeFi, DAOs, NFTs, or any of the wonderful things that can be built on top of this amazing technology.

A technical handbook on Ethereum's move to proof of stake and beyond.

Upgrading Ethereum


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


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


The easiest way to integrate succinct verifiable on-chain computation using hidden information in custom applications that execute on a credibly-neutral immutable public ledger.

Essentially, it's zero knowledge for those with zero knowledge.

zero knowledge for those with zero knowledge

zk-starter


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 betweens 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


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


Ethereum, the most popular blockchain, has seen scaling issues for quite a long time now. With high gas fees due to congestion being the primary pain point. With the increasing cost to use the network, a plethora of scaling solutions have emerged. Today in this guide, we will go over some Ethereum scaling solutions and deep dive into rollups.

Ethereum Scaling solutions
The main goal of all the Ethereum scaling solutions is to increase transaction speed and throughput without compromising the decentralized nature of the blockchain.

There are two main directions in which these scaling solutions are being explored:
- On-chain Scaling
- Off-chain Scaling

In this guide, we will go over some Ethereum scaling solutions and deep dive into rollups.

Introduction to Ethereum Rollups


These tutorials help you get started developing for Optimism.

Learn to build an Optimistic app! 


This workshop is a set of smart contracts deployed on StarkNet Alpha on testnet. Each smart contract is an exercice/puzzle; each one outlines a feature of the Cairo Smart contract language. Completing the exercice will credit you with points, in the form of an ERC20 token.

This workshop focuses on reading Cairo code and StarkNet smart contracts, in order to understand its syntax. You don't need to code or install anything on your machine in order to follow and complete it. Getting started (doing the first two exercises) will take you some time, in order to get into the tutorial. Hang on! Once there, things will flow more easily. You're learning!

This workshop is the first in a serie that will cover broad smart contract concepts (writing and deploying ERC20/ERC721, bridging assets, L1 <-> L2 messaging...).

Get started with Cairo with this simple tutorial. Complete the puzzles, get points and learn about StarkNet smart contracts!

StarkNet Cairo 101


Starknet is one of the most promising technologies in the Web3 scene. It is a Permissionless Decentralized ZK-Rollup. Any developer can deploy any dApp, using smart contracts, and achieve unlimited scale.

By the end of this tutorial you should be able to cerate an NFT collections and connect it with ArgentX.

Contents

- Quickstart
- Install a local tesnet and test with Nile
- Deploy a Cairo Smart Contract using Hardhat, and interact with it (call/invoke)
- Interact with the Smart Contract from Starknet.js
- Add events to the Contract
- Create a Struct
- Create a WhiteList (mapping)
- My first Account in Starknet.
- Calling another Contract (DelegateCAll)
- Create an NFT from my Account.
- Bridge an NFT to L1.
- Bridge an NFT back to L2.


By the end of this tutorial you should be able to create an NFT collections on Starknet and connect it with ArgentX.

Starknet Tutorial


Executing complex functions on chain Ethereum has always been a big no-no, something that you should never do. Blockchain computation is very expensive as all the nodes are needed to execute the same calculation to verify its correctness.

StarkWare is one of the Ethereum scaling services that is attempting to scale Ethereum using STARKs (Scalable Transparent ARgument of Knowledge) proofs. I will not go too deep into how STARKs work in this blogpost, but I am going to give a practical overview on how they can be used in practice.

Verifying complex auto battler calculation on Ethereum

STARKs: Scaling decentralized games


In this series wetry to demystify zero-knowledge proofs (ZKPs) for the rest of non-math nerds. Since writing [part 1](https://dev.to/tonyolendo/the-complete-full-stack-guide-to-getting-started-with-zero-knowledge-proofs-using-circom-and-zk-snarks-part-1-53gi), my thoughts on the subject have evolved. I’m more drawn to answering the following questions

- Can anyone be a ZK developer?
- Is there a simple path that we can define for anyone to get started in writing ZK circuits?

The simple answer to all the questions above is yes! Most assuredly, yes. How? Just learn [Circom](https://iden3.io/circom) and you’ll be well on your way.


Below is a contract that stores pen and paper inventory across different warehouses. To test that the contract works as expected a test is created that stores to the inventory twice with record_items(), then calls check_items(). By asserting that the values received match those that are expected, the test identifies errors before deployment.

Unit testing in Starknet


In this section we will write Cairo code for a small voting system. This voting system can be used, for example, to run a secure (non-private) voting with a lot of voters on a blockchain. We will assume that each voter has a pair of private and public keys (for the ECDSA signature scheme) and that the list of voters’ public keys is fixed. Each voter may vote “Yes” (1) or “No” (0). The system will not guarantee anonymity.

This section assumes some basic knowledge of cryptographic primitives such as hash functions, digital signatures and Merkle trees. In addition, if you haven’t already read the previous parts of the “Hello, Cairo” tutorial, you are encouraged to do so before reading this part.

In this guide we will write Cairo code for a small voting system, which can be used, for example, to run a secure (non-private) voting with a lot of voters.

Voting system in Cairo


Arbitrum is  a layer 2 scaling solution for the Ethereum network. In this tutorial we will be looking at how optimistic roll ups work, deploying a smart contract to Arbitrum and then carrying out a token swap on layer 2 using Uniswap.

00:00 What Is Arbitrum?
00:23 How Optimistic Rollups Work
02:00 Arbitrum Rinkeby
02:48 Arbitrum Token Bridge
04:44 Setting Up Truffle
06:54 Deploy To Arbitrum
07:36 Developer Notes
08:26 Uniswap On Arbitrum
09:33 Conclusion

Arbitrum is a L2 scaling solution for Ethereum. In this tutorial we will be looking at how optimistic roll ups work, deploying a contract and then carrying out a swap on L2.

Using and building on Arbitrum


A curated list of awesome StarkNet resources, libraries, tools and more

Awesome StarkNet


First setup using Nile which makes managing files and command line calls to StarkNet simple.
Second have a look at how pytest works
After you have set everything up, to run the examples:
- Open two terminals in the project folder and run source env/bin/activate
- In one run nile node to start a local devnet.
- In the other run the commands in the examples.

Examples of different elements in Cairo and StarkNet.
- Hello, World!
- First application
- Array
- Data types
- Variables
- Read and write values
- Read and write tuples
- Currency
- Constructor
- Custom imports
- Contract calls
- Array argument
- Array returns
- Struct returns


Cairo is a programming language that can be used to write blockchain applications. The language is novel in that it converts program logic into STARK proofs.

Cairo by example


The Sway Book introduces the Sway language to smart contract developers. It covers how to write, test, and deploy smart contracts for the Fuel Network using Sway and the Sway toolchain.


An introduction to the Sway programming language.

#scalability

Newsletter