
Node Guardians is a gamified educational platform that creates lore-rich programming challenges for experienced Solidity, Huff, Cairo and Noir developers. Think of it as a skill-based RPG where developers can become familiar with specific stack components and a place where they can showcase their abilities. 

### Skills Upgrade

We have created a series of coding challenges called “quests” to engage smart contract developers, providing them with the knowledge to build safe and gas efficient applications. In addition to practical skills, we also provide theoretical knowledge about crypto history, technology and economics through building a library of articles that break down complex concepts of distributed systems & decentralized finance.


### Public Good

Node Guardians is a public good for developers and will always remain so. 
In addition to supporting the growth of cool ecosystems, we plan to make the platform sustainable by managing [infrastructure](https://infra.nodeguardians.io/) across various networks.

Rewarding non-contributing operators wastes funds, we prefer community-building and education.


Node Guardians is a gamified educational platform that creates lore-rich programming challenges for experienced Solidity, Cairo, Huff and Noir developers.

Node Guardians


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


This workshop is a set of smart contracts deployed on StarkNet Alpha on testnet. Each smart contract is an exercise/puzzle; each one outlines a feature of the Cairo Smart contract language. Completing the exercise 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 series 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 create an NFT collection and connect it with ArgentX.

Contents

- Quickstart
- Install a local testnet 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 collection 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


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


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

🏆 Node Guardians

Newsletter