text:
using NUnit.Framework;
using Subterfuge.Remake.Api.Network;
using Subterfuge.Remake.Server.Test.util;
using Subterfuge.Remake.Server.Test.util.account;

namespace Subterfuge.Remake.Server.Test.test.social;

public class SocialControllerFriendTest
{

    private AccountRegistrationResponse userOne;
    private AccountRegistrationResponse userTwo;

    [SetUp]
    public async Task Setup()
    {
        TestUtils.Mongo.FlushAll();
        TestUtils.GetClient().UserApi.Logout();

        userTwo = await AccountUtils.AssertRegisterAccountAndAuthorized("UserTwo");
        userOne = await AccountUtils.AssertRegisterAccountAndAuthorized("UserOne");
    }

    [Test]
    public async Task PlayerCanSendFriendRequestToOtherPlayer()
    {
        var response = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);
        Assert.IsTrue(response.ResponseDetail.IsSuccess);
    }

    [Test]
    public async Task WhenAPlayerGetsAFriendRequestTheyCanSeeIt()
    {
        var response = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);
        Assert.IsTrue(response.ResponseDetail.IsSuccess);

        TestUtils.GetClient().UserApi.SetToken(userTwo.Token);

        var friendRequests = await TestUtils.GetClient().SocialClient.ViewFriendRequests(userTwo.User.Id);
        Assert.IsTrue(friendRequests.ResponseDetail.IsSuccess);
        Assert.AreEqual(1, friendRequests.GetOrThrow().FriendRequests.Count);
        Assert.IsTrue(friendRequests.GetOrThrow().FriendRequests.Any(request => request.Id == userOne.User.Id));
    }

    [Test]
    public async Task AfterSendingAFriendRequestTheRequestDoesNotAppearInTheOriginatingPlayersFriendRequestList()
    {
        var response = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);
        Assert.IsTrue(response.ResponseDetail.IsSuccess);

        var friendRequests = await TestUtils.GetClient().SocialClient.ViewFriendRequests(userOne.User.Id);
        Assert.IsTrue(friendRequests.ResponseDetail.IsSuccess);
        Assert.AreEqual(0, friendRequests.GetOrThrow().FriendRequests.Count);
    }

    [Test]
    public async Task PlayerCannotSendMultipleFriendRequests()
    {
        var response = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);
        Assert.IsTrue(response.ResponseDetail.IsSuccess);

        var exception = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);
        Assert.IsFalse(exception.IsSuccess());
        Assert.AreEqual(ResponseType.DUPLICATE, exception.ResponseDetail.ResponseType);
    }

    [Test]
    public async Task PlayerCanRemoveAFriendRequest()
    {
        var response = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);
        Assert.IsTrue(response.ResponseDetail.IsSuccess);

        TestUtils.GetClient().UserApi.SetToken(userTwo.Token);
        var removeRequest = await TestUtils.GetClient().SocialClient.RemoveRejectFriend(userOne.User.Id);
        Assert.IsTrue(removeRequest.ResponseDetail.IsSuccess);

        var friendRequests = await TestUtils.GetClient().SocialClient.ViewFriendRequests(userTwo.User.Id);
        Assert.IsTrue(friendRequests.ResponseDetail.IsSuccess);
        Assert.AreEqual(0, friendRequests.GetOrThrow().FriendRequests.Count);
    }

    [Test]
    public async Task PlayerCanAcceptAFriendRequest()
    {
        var response = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);
        Assert.IsTrue(response.ResponseDetail.IsSuccess);

        TestUtils.GetClient().UserApi.SetToken(userTwo.Token);
        var addFriendRequest = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userOne.User.Id);
        Assert.IsTrue(addFriendRequest.ResponseDetail.IsSuccess);

        var friendRequests = await TestUtils.GetClient().SocialClient.ViewFriendRequests(userTwo.User.Id);
        Assert.IsTrue(friendRequests.ResponseDetail.IsSuccess);
        Assert.AreEqual(0, friendRequests.GetOrThrow().FriendRequests.Count);
    }

    [Test]
    public async Task AcceptingPlayerCanViewFriendAfterAcceptingRequest()
    {
        var response = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);
        Assert.IsTrue(response.ResponseDetail.IsSuccess);

        TestUtils.GetClient().UserApi.SetToken(userTwo.Token);
        var addFriendRequest = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userOne.User.Id);
        Assert.IsTrue(addFriendRequest.ResponseDetail.IsSuccess);

        var friends = await TestUtils.GetClient().SocialClient.GetFriendList(userTwo.User.Id);
        Assert.IsTrue(friends.ResponseDetail.IsSuccess);
        Assert.AreEqual(1, friends.GetOrThrow().Friends.Count);
        Assert.IsTrue(friends.GetOrThrow().Friends.Any(it => it.Id == userOne.User.Id));
    }

    [Test]
    public async Task OriginalPlayerCanViewFriendAfterOtherPlayerAcceptsRequest()
    {
        var response = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);
        Assert.IsTrue(response.ResponseDetail.IsSuccess);

        TestUtils.GetClient().UserApi.SetToken(userTwo.Token);

        var addFriendRequest = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userOne.User.Id);
        Assert.IsTrue(addFriendRequest.ResponseDetail.IsSuccess);

        TestUtils.GetClient().UserApi.SetToken(userOne.Token);

        var friends = await TestUtils.GetClient().SocialClient.GetFriendList(userOne.User.Id);
        Assert.IsTrue(friends.ResponseDetail.IsSuccess);
        Assert.AreEqual(1, friends.GetOrThrow().Friends.Count);
        Assert.IsTrue(friends.GetOrThrow().Friends.Any(it => it.Id == userTwo.User.Id));
    }

    [Test]
    public async Task NonAdminsCannotViewAnotherPlayersFriendList()
    {
        var exception = await TestUtils.GetClient().SocialClient.GetFriendList(userTwo.User.Id);
        Assert.IsFalse(exception.IsSuccess());
        Assert.AreEqual(ResponseType.PERMISSION_DENIED, exception.ResponseDetail.ResponseType);
    }

    [Test]
    public async Task AdminsCanViewAnotherPlayersFriendList()
    {
        await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);
        TestUtils.GetClient().UserApi.SetToken(userTwo.Token);
        await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userOne.User.Id);
        TestUtils.GetClient().UserApi.SetToken(userTwo.Token);

        await TestUtils.CreateSuperUserAndLogin();
        var friendList = await TestUtils.GetClient().SocialClient.GetFriendList(userTwo.User.Id);
        Assert.IsTrue(friendList.ResponseDetail.IsSuccess);
        Assert.AreEqual(1, friendList.GetOrThrow().Friends.Count);
        Assert.IsTrue(friendList.GetOrThrow().Friends.Any(it => it.Id == userOne.User.Id));
    }

    [Test]
    public async Task PlayerCannotSendAFriendRequestToNonExistingPlayer()
    {
        var exception = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest("InvalidUserId");
        Assert.IsFalse(exception.IsSuccess());
        Assert.AreEqual(ResponseType.NOT_FOUND, exception.ResponseDetail.ResponseType);
    }

    [Test]
    public async Task PlayerCannotGetAFriendRequestFromABlockedPlayer()
    {
        // Block user two from player one.
        var blockResponse = await TestUtils.GetClient().SocialClient.BlockPlayer(new BlockPlayerRequest(), userTwo.User.Id);
        Assert.IsTrue(blockResponse.ResponseDetail.IsSuccess);

        TestUtils.GetClient().UserApi.SetToken(userTwo.Token);

        // Try to add friend from player two to player one.
        var exception = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userOne.User.Id);
        Assert.IsFalse(exception.IsSuccess());
        Assert.AreEqual(ResponseType.PERMISSION_DENIED, exception.ResponseDetail.ResponseType);
    }

    [Test]
    public async Task PlayerCannotSendAFriendRequestToABlockedPlayer()
    {
        // Block user two from player one.
        var blockResponse = await TestUtils.GetClient().SocialClient.BlockPlayer(new BlockPlayerRequest(), userTwo.User.Id);
        Assert.IsTrue(blockResponse.ResponseDetail.IsSuccess);

        // Try to add friend from player one to player two.
        var exception = await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);
        Assert.IsFalse(exception.IsSuccess());
        Assert.AreEqual(ResponseType.PERMISSION_DENIED, exception.ResponseDetail.ResponseType);
    }

    [Test]
    public async Task BlockingAPlayerWithAnIncomingFriendRequestRemovesTheFriendRequests()
    {
        await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);

        TestUtils.GetClient().UserApi.SetToken(userTwo.Token);

        var friendRequestsBeforeBlock = await TestUtils.GetClient().SocialClient.ViewFriendRequests(userTwo.User.Id);
        Assert.IsTrue(friendRequestsBeforeBlock.ResponseDetail.IsSuccess);
        Assert.AreEqual(1, friendRequestsBeforeBlock.GetOrThrow().FriendRequests.Count);
        Assert.IsTrue(friendRequestsBeforeBlock.GetOrThrow().FriendRequests.Any(request => request.Id == userOne.User.Id));

        await TestUtils.GetClient().SocialClient.BlockPlayer(new BlockPlayerRequest(), userOne.User.Id);

        var friendRequestsAfterBlock = await TestUtils.GetClient().SocialClient.ViewFriendRequests(userTwo.User.Id);
        Assert.IsTrue(friendRequestsAfterBlock.ResponseDetail.IsSuccess);
        Assert.AreEqual(0, friendRequestsAfterBlock.GetOrThrow().FriendRequests.Count);
    }

    [Test]
    public async Task BlockingAPlayerAfterSendingThemAFriendRequestRemovesTheFriendRequest()
    {
        await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);

        TestUtils.GetClient().UserApi.SetToken(userTwo.Token);

        var friendRequestsBeforeBlock = await TestUtils.GetClient().SocialClient.ViewFriendRequests(userTwo.User.Id);
        Assert.IsTrue(friendRequestsBeforeBlock.ResponseDetail.IsSuccess);
        Assert.AreEqual(1, friendRequestsBeforeBlock.GetOrThrow().FriendRequests.Count);
        Assert.IsTrue(friendRequestsBeforeBlock.GetOrThrow().FriendRequests.Any(request => request.Id == userOne.User.Id));

        TestUtils.GetClient().UserApi.SetToken(userOne.Token);

        await TestUtils.GetClient().SocialClient.BlockPlayer(new BlockPlayerRequest(), userTwo.User.Id);

        TestUtils.GetClient().UserApi.SetToken(userTwo.Token);

        var friendRequestsAfterBlock = await TestUtils.GetClient().SocialClient.ViewFriendRequests(userTwo.User.Id);
        Assert.IsTrue(friendRequestsAfterBlock.ResponseDetail.IsSuccess);
        Assert.AreEqual(0, friendRequestsAfterBlock.GetOrThrow().FriendRequests.Count);
    }
}


text:
using NUnit.Framework;
using Subterfuge.Remake.Api.Network;
using Subterfuge.Remake.Server.Test.util;
using Subterfuge.Remake.Server.Test.util.account;

namespace Subterfuge.Remake.Server.Test.test.social;

public class SocialControllerBlockTest
{
    private AccountRegistrationResponse userOne;
    private AccountRegistrationResponse userTwo;

    [SetUp]
    public async Task Setup()
    {
        TestUtils.Mongo.FlushAll();
        TestUtils.GetClient().UserApi.Logout();

        userTwo = await AccountUtils.AssertRegisterAccountAndAuthorized("UserTwo");
        userOne = await AccountUtils.AssertRegisterAccountAndAuthorized("UserOne");
    }

    [Test]
    public async Task PlayerCanBlockAnotherPlayer()
    {
        var blockResponse = await TestUtils.GetClient().SocialClient.BlockPlayer(new BlockPlayerRequest(), userTwo.User.Id);
        Assert.IsTrue(blockResponse.ResponseDetail.IsSuccess);
    }

    [Test]
    public async Task PlayerCannotBlockInvalidPlayerId()
    {
        var exception = await TestUtils.GetClient().SocialClient.BlockPlayer(new BlockPlayerRequest(), "InvalidUserId");
        Assert.IsFalse(exception.IsSuccess());
        Assert.AreEqual(ResponseType.NOT_FOUND, exception.ResponseDetail.ResponseType);
    }

    [Test]
    public async Task AfterBlockingAPlayerTheyAppearOnTheBlockList()
    {
        var blockResponse = await TestUtils.GetClient().SocialClient.BlockPlayer(new BlockPlayerRequest(), userTwo.User.Id);
        Assert.IsTrue(blockResponse.ResponseDetail.IsSuccess);

        var blockList = await TestUtils.GetClient().SocialClient.ViewBlockedPlayers(userOne.User.Id);
        Assert.IsTrue(blockList.ResponseDetail.IsSuccess);
        Assert.AreEqual(1, blockList.GetOrThrow().BlockedUsers.Count);
        Assert.IsTrue(blockList.GetOrThrow().BlockedUsers.Any(blockedUser => blockedUser.Id == userTwo.User.Id));
    }

    [Test]
    public async Task PlayerCanUnblockAPlayerAfterBlockingThem()
    {
        var blockResponse = await TestUtils.GetClient().SocialClient.BlockPlayer(new BlockPlayerRequest(), userTwo.User.Id);
        Assert.IsTrue(blockResponse.ResponseDetail.IsSuccess);

        var blockList = await TestUtils.GetClient().SocialClient.ViewBlockedPlayers(userOne.User.Id);
        Assert.IsTrue(blockList.ResponseDetail.IsSuccess);
        Assert.AreEqual(1, blockList.GetOrThrow().BlockedUsers.Count);
        Assert.IsTrue(blockList.GetOrThrow().BlockedUsers.Any(blockedUser => blockedUser.Id == userTwo.User.Id));

        var unblockResonse = await TestUtils.GetClient().SocialClient.UnblockPlayer(new UnblockPlayerRequest(), userTwo.User.Id);
        Assert.IsTrue(unblockResonse.ResponseDetail.IsSuccess);

        var blockListAfterUnblock = await TestUtils.GetClient().SocialClient.ViewBlockedPlayers(userOne.User.Id);
        Assert.IsTrue(blockListAfterUnblock.ResponseDetail.IsSuccess);
        Assert.AreEqual(0, blockListAfterUnblock.GetOrThrow().BlockedUsers.Count);
    }

    [Test]
    public async Task CannotUnblockNonValidPlayerId()
    {
        var exception = await TestUtils.GetClient().SocialClient.UnblockPlayer(new UnblockPlayerRequest(), "InvalidUserId");
        Assert.IsFalse(exception.IsSuccess());
        Assert.AreEqual(ResponseType.NOT_FOUND, exception.ResponseDetail.ResponseType);
    }

    [Ignore("If the player is not blocked, unblocking is going to do nothing anyway.")]
    public void CannotUnblockPlayerWhoIsNotBlocked()
    {
        throw new NotImplementedException();
    }

    [Test]
    public async Task BlockingAPlayerRemovesThemAsAFriend()
    {
        await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userTwo.User.Id);

        TestUtils.GetClient().UserApi.SetToken(userTwo.Token);
        await TestUtils.GetClient().SocialClient.AddAcceptFriendRequest(userOne.User.Id);

        var friendsBeforeBlock = await TestUtils.GetClient().SocialClient.GetFriendList(userTwo.User.Id);
        Assert.IsTrue(friendsBeforeBlock.ResponseDetail.IsSuccess);
        Assert.AreEqual(1, friendsBeforeBlock.GetOrThrow().Friends.Count);
        Assert.IsTrue(friendsBeforeBlock.GetOrThrow().Friends.Any(it => it.Id == userOne.User.Id));

        var blockResponse = await TestUtils.GetClient().SocialClient.BlockPlayer(new BlockPlayerRequest(), userOne.User.Id);
        Assert.IsTrue(blockResponse.ResponseDetail.IsSuccess);

        var friendsAfterBlock = await TestUtils.GetClient().SocialClient.GetFriendList(userTwo.User.Id);
        Assert.IsTrue(friendsAfterBlock.ResponseDetail.IsSuccess);
        Assert.AreEqual(0, friendsAfterBlock.GetOrThrow().Friends.Count);
    }

    [Test]
    public async Task CannotBlockAnAdmin()
    {
        var admin = await TestUtils.CreateSuperUserAndLogin();

        TestUtils.GetClient().UserApi.SetToken(userOne.Token);

        var exception = await TestUtils.GetClient().SocialClient.BlockPlayer(new BlockPlayerRequest(), admin.User.Id);
        Assert.IsFalse(exception.IsSuccess());
        Assert.AreEqual(ResponseType.PERMISSION_DENIED, exception.ResponseDetail.ResponseType);
    }
}

repo_name: Subterfuge-Revived/Remake-Core

repo_language: C#

mime_type: text/plain


text:
**[Back to READ ME file](./README.md/)**

# Contributing Guidelines

## Getting Started

- Fork this Repository [**here**](https://github.com/frankiefab100/Blockchain-Development-Resources/fork)

- Clone the forked Repository

- Open the cloned directory in your favorite Code Editor.

- Add new resources not listed above.
  <br>
  For efficient review, Please submit **one resource** in a pull request (PR).

- Indicate the **resource** name and **category** in the PR.

repo_language: Markdown


text:
<!DOCTYPE html>

    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
    <meta name="description" content="Description">
    <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta name="keywords" content="doc,docs,documentation,gitbook,creator,generator,github,jekyll,github-pages">
    <meta name="description" content="Web3 resources documentataion">
    <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/docsify/themes/vue.css">
    <link
    rel="stylesheet"
    href="//cdn.jsdelivr.net/npm/docsify-darklight-theme@latest/dist/style.min.css"
    title="docsify-darklight-theme"
    type="text/css"
    />
    <link rel="stylesheet" href="css/style.css">
    <title>Blockchain Development Resources</title>

    This page requires JavaScript to work, please enable it or just read it on Here.

Loading Web3 Learning Resources...


text:
![BDR header](https://user-images.githubusercontent.com/46662771/132558872-9fb63b1d-5c15-470a-8a84-23464519ff15.jpg)

[![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/sindresorhus/awesome) [![Tweet](https://img.shields.io/twitter/url/http/shields.io.svg?style=social)](https://twitter.com/intent/tweet?text=Blockchain%20Development%20Resources%20-%20A%20collection%20of%20FREE%20blockchain%20development%20learning%20resources%20by%20@frankiefab100&url=https://github.com/frankiefab100/Blockchain-Development-Resources&hashtags=blockchaindevelopment,web3,ethereum,smartcontract,blockchaindeveloper,solidity) [![Twitter Follow](https://img.shields.io/twitter/follow/frankiefab100?style=social)](https://twitter.com/frankiefab100)

# Blockchain Development Resources

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

It comprises of links to a range of topics like Introduction to Blockchain technology, Web3 and revolution of the Internet, deployment of smart contracts on Ethereum, Solana, Aeternity, Polygon, Celo and other EVM-compatible Blockchain networks, Minting of NFTs, building decentralized applications (DApps), lending protocols and tokens, creating decentralized autonomous organizations (DAOs), fundamentals of cryptography and distributed ledger technology, smart contract security, zero knowledge proof, understanding decentralized finance, How-to-use tutorials on Blockchain development tools and technologies - **RemixIDE, Metamask, Hardhat, Web3js, Ganache, Ethersjs, Web3py, Truffle, OpenZeppelin, Infura, IPFS**; including programming languages for writing smart contracts - **Solidity, Vyper, Rust, Golang, Sophia**.

#### Please carefully read [`Contributing guidelines`](./CONTRIBUTING.md) before opening a pull request or issue.

_If you really appreciate the content of this repository, don't forget to give it a Star⭐ and/or Tweet about it_.

---

## Table of Contents

- [Websites](#websites)
- [Gamified Tutorials](#gamified-tutorials)
- [Youtube Channels](#youtube-channels)
- [Free Online Courses](#free-online-courses)
- [Github Repositories](#github-repositories)
- [Tutorial Docs](#tutorial-docs)
- [Development Tools](#development-tools)
- [Node Providers](#node-providers)
- [Project Starter](#project-starter)
- [Articles](#articles)
- [Recommended Books](#recommended-books)

---

## Websites

|                                                                                |
| -------------------------------------------------------------------------------------------------------------- |
| [Consensys Academy](https://courses.consensys.net/collections)                                                            |
| [Ethereum.org](https://ethereum.org/en/developers/tutorials/)                                                  |
| [Questbook](https://openquest.xyz/)                                                                            |
| [Buildspace](https://buildspace.so)                                                                            |
| [Web3Learn](https://web3learn.io/)                                                                             |
| [The Blockchain School](https://theblockchainschool.io)                                                        |
| [Blockchain at Berkeley](https://blockchain.berkeley.edu/)                                                     |
| [ProtoSchool](https://proto.school/tutorials)                                                                  |
| [Dacade](https://dacade.org)                                                                                |
| [Figment](https://learn.figment.io)                                                                            |
| [Finematics](https://finematics.com)                                                                           |
| [Near University](https://www.near.university/learn/by-yourself)                                               |
| [Kerala Blockchain Academy](https://kba.ai)                                                                    |
| [DApp University](https://www.dappuniversity.com/)                                                             |
| [Ethereum Blockchain Dev](https://ethereum-blockchain-developer.com/)                                          |
| [Blockchain Hub](https://blockchainhub.net)                                                                    |
| [EthereumDev](https://ethereumdev.io/)                                                                         |
| [UseWeb3](https://useweb3.xyz)                                                                                |
| [Blockchain Edu](https://learn.blockchainedu.org)                                                              |
| [Web3 University](https://www.web3.university/)                                                                |
| [Zastrin](https://www.zastrin.com/)                                                                            |
| [Metaschool](https://metaschool.so/)                                                                           |
| [LearnWeb3 DAO](https://www.learnweb3.io)                                                                      |
| [Chainshot](https://www.chainshot.com/)                                                                        |
| [Althash University](https://www.althash.university/colleges-schools/blockchain-internship-youth-program-biyp) |
| [We teach Blockchain](https://weteachblockchain.org/courses)                                                   |
| [Cadena](https://cadena.dev)                                                                                |
| [Tacode](https://tacode.dev)                                                                                |
| [NFTschool](https://nftschool.dev)                                                                             |
| [StartonSolana](https://www.startonsolana.com/)                                                                |
| [Blockgeeks](https://blockgeeks.com)                                                                           |
| [CryptoLectures](https://cryptolectures.teachable.com/)                                                        |
| [Snakecharmers](https://snakecharmers.ethereum.org/)                                                           |
| [Pointer](https://www.pointer.gg/)                                                                             |
| [Soldev](https://soldev.app/)                                                                                |
| [Codiesalert](https://www.codiesalert.com/)                                                                    |
| [Soliditytips](https://soliditytips.com/)                                                                      |
| [Cryptopedia](https://www.gemini.com/cryptopedia)                                                              |
| [Learn NEAR Club](https://learnnear.club/)                                                                     |
| [Teach yourself Web3](https://www.teachyourselfweb3.com)                                                       |
| [Web3 Freecodecamp](https://web3.freecodecamp.org/)                                                            |
| [Cryptodappy](https://www.cryptodappy.com/)                                                                    |
| [MetaMask Learn](https://learn.metamask.io/)                                                                   |
| [Alchemy university](https://university.alchemy.com/)                                                          |
| [Buidlguidl](https://buidlguidl.com/)                                                                          |

    ↥ Back To Top

## Gamified Tutorials

|                                                                              |
| ---------------------------------------------------------------------------- |
| [Cryptozombies](https://cryptozombies.io)                                    |
| [Ethernaut](https://ethernaut.openzeppelin.com/)                             |
| [Damnvulnerable DeFi](https://www.damnvulnerabledefi.xyz/)                   |
| [Vyper.fun](https://vyper.fun/lessons.html#)                                 |
| [Capture the Ether](https://capturetheether.com/)                            |
| [Space Doggos](https://www.bitdegree.org/course/learn-solidity-space-doggos) |
| [Crypto Hack](https://cryptohack.org)                                        |

    ↥ Back To Top

## Youtube Channels

|                                                                                |
| ------------------------------------------------------------------------------------------------------ |
| [DApp University](https://www.youtube.com/c/DAppuniversity)                                            |
| [Eat the blocks](https://www.youtube.com/c/EatTheBlocks)                                               |
| [Ivan on Tech](https://www.youtube.com/c/IvanonTech/)                                                  |
| [Nader Dabit](https://www.youtube.com/c/naderdabit/)                                                   |
| [Samarth Developer](https://www.youtube.com/channel/UCfBN8r71cRThmEptCGJaX7w/)                         |
| [Austin Griffith](https://www.youtube.com/channel/UC_HI2i2peo1A-STdG22GFsA)                            |
| [Merunas Grincalaitis](https://www.youtube.com/channel/UCJInIwgW1duAEnMHHxDK7XQ)                       |
| [Will it Scale](https://youtube.com/playlist?list=PL16WqdAj66SCOdL6XIFbke-XQg2GW_Avg)                  |
| [Design Course](https://youtube.com/playlist?list=PL0lNJEnwfVVMuX2Ds19Wj_7Mcze3FDJr3)                  |
| [Smart Contract Programmer](https://www.youtube.com/channel/UCJWh7F3AFyQ_x01VKzr9eyA)                  |
| [Alchemy](https://www.youtube.com/channel/UCtvTdPZWUwW4whk9CLlCBug)                                    |
| [Hashlips NFT](https://www.youtube.com/playlist?list=PLvfQp12V0hS0-3AjKWAve5QHy3W6lOfO8)               |
| [Patrick Collins](https://m.youtube.com/c/patrickcollins)                                              |
| [ETHGlobal](https://www.youtube.com/channel/UCfF9ZO8Ug4xk_AJd4aeT5HA)                                  |
| [Finematics](https://www.youtube.com/c/Finematics)
| [Moralis Web3](https://m.youtube.com/c/MoralisWeb3)                                                 |
| [Practical Blockchain](https://youtube.com/channel/UCJCPs6IQ5SiDanwFg1RMysQ)                           |
| [Blockholic](https://youtube.com/c/Blockholic)                                                         |
| [Blockchain at Berkeley](https://youtube.com/c/BlockchainatBerkeley)                                   |
| [Vlad Wulf](https://youtube.com/channel/UCsVoOobxAQL6NbWY2t6E6Sg)                                      |
| [Ethereum Engineering Group](https://youtube.com/c/EthereumEngineeringGroup)                           |
| [Web3 Club](https://youtube.com/channel/UCJbA7dA_YPbnef0vEBFuhKQ)                                      |
| [Center for Innovative Finance](https://www.youtube.com/channel/UCOA52m4BOqtI8cHIx4zJAWg)              |
| [Web3 Foundation](https://www.youtube.com/watch?v=y8YyZELnVaw&list=PLxVihxZC42nF_MCN9PTvZMIifRjx9cZ2J) |
| [Learn Web3DAO](https://youtube.com/c/LearnWeb3DAO)                                                    |
| [Block Explorer](https://youtube.com/c/BlockExplorerMedia)                                             |
| [CodeXpert](https://youtube.com/c/CodeXpert)                                                           |
| [Learn Web3](https://youtube.com/channel/UCjl8iG0tFvwyLapBPluLfKw)                                     |
| [Edureka](https://www.youtube.com/watch?v=9qfxLo1rt1Q&list=PL9ooVrP1hQOFJblZm3OdcVV-H6Z8V7HP1)         |
| [Code Eater](https://www.youtube.com/c/CodeEater21)                                                    |
| [Mobilefish.com](https://www.youtube.com/watch?v=KXUTUhERJUE&list=PLmL13yqb6OxdEgSoua2WuqHKBuIqvll0x)  |
| [Simplilearn](https://www.youtube.com/watch?v=yubzJw0uiE4&list=PLEiEAq2VkUUKmhU6SO2P73pTdMZnHOsDB)     |
| [Crypto white board](https://www.youtube.com/c/WhiteboardCrypto)                                       |
| [Aeternity Blockchain](https://www.youtube.com/c/aeternityblockchain)                                  |
| [Chainlink](https://www.youtube.com/c/chainlink)                                                       |
| [Codiesalert](https://youtube.com/channel/UCpuR8mLqFrHokwPZBdLNdWA)                                    |
| [Web3Academy](https://youtube.com/c/Web3Academy)                                                       |

    ↥ Back To Top

## Free Online Courses

|                                                                                |
| ----------------------------------------------------------------------------------------------------------------------------------- |
| [Solidity, Blockchain, and Smart Contract Course – Beginner to Expert Python Tutorial](https://www.youtube.com/watch?v=M576WGiDBdQ)
| [Build and Deploy a Modern Web 3.0 Blockchain App - Solidity Smart Contracts Crypto](https://www.youtube.com/watch?v=Wn_Kb3MR_cU)
| [Learn Blockchain, Solidity and Full Stack Web3 Development with JavaScript](https://youtu.be/gyMwXuJrbJQ)
| [Blockchain Theory 101](https://www.udemy.com/share/101yjc2@PUdKbFpaTVMPcUBCO0hOfg==/)
| [Blockchain Technology](https://www.edx.org/course/blockchain-technology)
| [Smart Contracts](https://www.coursera.org/learn/smarter-contracts)
| [Blockchain and Deep Learning of AI](https://www.udemy.com/course/blockchain-and-deep-learning-future-of-ai/)
| [Understanding Blockchain Technology](https://www.udemy.com/course/understanding-blockchain-technology/)
| [Ethereum](https://www.ludu.co/course/ethereum)
| [Blockchain Technology and Applications](https://alison.com/course/diploma-in-blockchain-technology-and-applications)
| [Blockchain Technology Fundamentals](https://witscad.com/course/blockchain-technology-fundamentals)
| [Enterprise Blockchains Fundamentals](https://academy.101blockchains.com/courses/enterprise-blockchains-fundamentals)
| [Blockchain Demo - web-based demonstration of hash, block, distributed ledger, token, public/private key pairs and signing](https://andersbrownworth.com/blockchain/)

    ↥ Back To Top

## Github Repositories
- [Full blockchain solidity course javascript](https://github.com/smartcontractkit/full-blockchain-solidity-course-js)
- [Full blockchain solidity course python](https://github.com/smartcontractkit/full-blockchain-solidity-course-py)
- [Blockchain for software engineers](https://github.com/benstew/blockchain-for-software-engineers)
- [Ethereum developer tools list](https://github.com/ConsenSys/ethereum-developer-tools-list)
- [Awesome solidity](https://github.com/bkrem/awesome-solidity)
- [Awesome ethereum security](https://github.com/crytic/awesome-ethereum-security)
- [Awesome blockchain](https://github.com/yjjnls/awesome-blockchain)
- [Blockchain learning path](https://github.com/protofire/blockchain-learning-path)
- [Awesome solidity BlockchainLabs](https://github.com/BlockchainLabsNZ/awesome-solidity)
- [Solidity 101](https://github.com/l-henri/solidity-101)
- [Web3.0 Roadmap](https://github.com/frankiefab100/Web3.0-Roadmap)
- [Smart contract resources](https://github.com/ErichDylus/Smart-Contract-Resources)
- [Learning solidity](https://github.com/pbrudny/learning-solidity-2018)
- [Solidity notes](https://github.com/0xpranay/solidity-notes)
- [Learn solidity with examples](https://github.com/James-Sangalli/learn-solidity-with-examples)
- [Solidity patterns](https://github.com/fravoll/solidity-patterns)
- [Solidity by examples](https://github.com/raineorshine/solidity-by-example)
- [Blockchain development guide](https://github.com/dcbuild3r/blockchain-development-guide)
- [Solidity Cheatsheet](https://github.com/manojpramesh/solidity-cheatsheet)
- [Awesome list rpc nodes providers](https://github.com/arddluma/awesome-list-rpc-nodes-providers)
- [Journey to become a blockchain engineer](https://github.com/spo0ds/Journey-to-become-a-Blockchain-Engineer)
- [DeFi developer roadmap](https://github.com/OffcierCia/DeFi-Developer-Road-Map)
- [Web2 to web3 resources](https://github.com/decentology/web2-to-web3-resources)
- [Blockchain tutorial](https://github.com/nosequeldeebee/blockchain-tutorial)
- [Awesome blockchains](https://github.com/openblockchains/awesome-blockchains)
- [Awesome zero knowledge proofs](https://github.com/matter-labs/awesome-zero-knowledge-proofs)
- [Awesome ZK](https://github.com/ventali/awesome-zk)
- [Awesome ZkEVM](https://github.com/LuozhuZhang/awesome-zkevm)
- [Awesome cryptoeconomics](https://github.com/jpantunes/awesome-cryptoeconomics)
- [Building secure contracts](https://github.com/crytic/building-secure-contracts)
- [Ultimate DeFi research base](https://github.com/OffcierCia/ultimate-defi-research-base)
- [Solidity security](https://github.com/Rari-Capital/solcurity)
- [Solidity security blog](https://github.com/sigp/solidity-security-blog)
- [Web3 security library](https://github.com/immunefi-team/Web3-Security-Library)
- [Solidity school](https://github.com/Aniket-Engg/solidity-school)
- [Crypto List](https://github.com/coinpride/CryptoList)
- [Solidity trivias](https://github.com/ajsantander/trivias)
- [Practical cryptography for developers book](https://github.com/nakov/practical-cryptography-for-developers-book)
- [Awesome openzeppelin](https://github.com/OpenZeppelin/awesome-openzeppelin)
- [Blockchain Dark Forest selfguard handbook](https://github.com/slowmist/Blockchain-dark-forest-selfguard-handbook)
- [The Crowdsourced Comprehensive Ethereum Reading List](https://github.com/Scanate/EthList)
- [Eat the blocks](https://github.com/jklepatch/eattheblocks)
- [Decentralized Applications](https://github.com/DavidJohnstonCEO/DecentralizedApplications)
- [Decentralized Websites](https://github.com/unstoppabledomains/decentralized-websites)
- [EVM Opcodes](https://github.com/crytic/evm-opcodes)
- [Typechain](https://github.com/dethcrypto/TypeChain)
- [Awesome blockchain rust](https://github.com/rust-in-blockchain/awesome-blockchain-rust)
- [Awesome rust](https://github.com/rust-unofficial/awesome-rust)
- [Awesome aeternity](https://github.com/aeternity/awesome-aeternity)
- [Metaschool learning projects](https://github.com/0xmetaschool/Learning-Projects)
- [Solana course](https://github.com/Unboxed-Software/solana-course)

    ↥ Back To Top

## Tutorial Docs

| Tutorial                                                                                | Description                                                  |
| --------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------ |
| [Blockchain Development Tutorial](https://cryptodevhub.io/wiki/blockchain-development-tutorial)                 | Getting Started with Blockchain Development by CryptoDev Hub |
| [Advanced Smart Contracts](https://georgebrowncollege-toronto.github.io/Advanced-Smart-Contracts/index.html)    | Advanced Smart Contracts by George Brown College             |
| [Getting started with Blockchain](https://kauri.io/#collections/Getting%20Started/blockchain-explained/)        | Getting started with Blockchain by Kauri                     |
| [Public Good Blockchain Development Guide](https://www.devpill.me/docs)                                         | Blockchain Development Guide by Devpill                      |
| [Ethereum Blockchain Development](https://docs.microsoft.com/en-us/learn/paths/ethereum-blockchain-development) | Get started with blockchain development by Microsoft         |
| [Chainstack Web3 Decoded](https://docs.chainstack.com/docs/web3-decoded-introduction)                           | Diving into Web3 development with Chaintack                  |
| [Hello World Smart Contracts](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract)            | Smart Contract Tutorial by Alchemy                           |
| [Learn Solidity in Y Minutes](https://learnxinyminutes.com/docs/solidity)                                       | Solidity Tutorial by Learn-x-in-y-minutes                    |
| [Solidity Docs](https://solidity.readthedocs.io)                                                                | Solidity Tutorial                                            |
| [OpenZeppelin Docs](https://ethernaut.openzeppelin.com/)                                                        | OpenZeppelin Tutorials by Ethernaut                          |
| [Polygon Docs](https://academy.polygon.technology/module-1-getting-started/join-the-polygon-academy)            | Getting started with Polygon by Polygon Academy              |
| [Ethereum Docs](https://studio.ethereum.org/)                                                                   | Ethereum Tutorial                                            |
| [Decentology Docs](https://docs.decentology.com/)                                                               | Ethspring by Decentology                                     |
| [Solana Docs](https://docs.solana.com/)                                                                         | Solana Documentation                                         |
| [NEAR Docs](https://docs.near.org/docs/tutorials/overview)                                                      | NEAR Documentation                                           |
| [Celo Docs](https://docs.celo.org/)                                                                             | Celo Documentation                                           |
| [Avalanche Docs](https://docs.avax.network/build/tutorials)                                                     | Avalanche Documentation                                      |
| [Flow Docs](https://developers.flow.com/)                                                                       | Flow Documentation                                           |

    ↥ Back To Top

## Development Tools

> ETHEREUM & EVM ecosystem

| Tool                                                                  | Description                                                                                |
| --------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| [Remix IDE](https://remix.ethereum.org)                               | An online Integrated Development Environment used to write, compile, debug and deploy solidity code for smart contracts                          |
| [EthFiddle](https://ethfiddle.com/)                                   | A solidity browser-based development tool                                                                                |
| [Solidity](https://docs.soliditylang.org)                             | An object-oriented, high-level language for implementing smart contracts on Ethereum Virtual Machine                                             |
| [Metamask](https://docs.metamask.io/guide)                            | A wallet extension for accessing and injecting the Ethereum web3 API                                                                             |
| [Truffle Suite](https://trufflesuite.com/doc)                         | Development environment, testing framework and asset pipeline for blockchains using the EVM                                                      |
| [Web3.js](https://web3js.readthedocs.io)                              | A collection of libraries that allow you to interact with a local or remote ethereum node using HTTP, IPC or WebSocket                           |
| [Hardhat](https://hardhat.org/getting-started/)                       | An Ethereum development environment that helps developers manage and automate the recurring tasks inherent to building smart contracts and DApps |
| [Ethers.js](https://docs.ethers.io)                                   | A compact library for interacting with the Ethereum Blockchain and its ecosystem                                                                 |
| [Vyper](https://vyper.readthedocs.io/en/latest/vyper-by-example.html) | A contract-oriented, pythonic programming language that targets the Ethereum Virtual Machine (EVM)                                               |
| [Web3.py](https://web3py.readthedocs.io)                              | A Python library for interacting with Ethereum, inspired by web3.js                                                                              |
| [Go Ethereum](https://geth.ethereum.org/docs/)                        | Golang implementation of Ethereum protocol                                                                                |
| [Brownie](https://eth-brownie.readthedocs.io)                         | A Python-based development and testing framework for smart contracts targeting the Ethereum Virtual Machine                                      |
| [OpenZeppelin](https://docs.openzeppelin.com/learn/)                  | A library for secure smart contract development and community-vetted code                                                                        |
| [EVM Codes](https://www.evm.codes/)                                   | An interactive reference to Ethereum Virtual Machine Opcodes                                                                                |
|  |
| [EVM Opcodes](https://www.ethervm.io/)                                | Ethereum Virtual Machine Opcodes                                                                                |
|  |
| [Chainlist](https://chainlist.org/)                                   | A list of EVM networks with informations used to connect wallets and Web3 middleware providers to the appropriate Chain and Network ID           |
|  |
| [Web3 Type Converter](https://web3-type-converter.onbrn.com/)         | Convert from a bytes32/hex into a string/number or vice-versa                                                                                |
|  |
| [Foundry](https://getfoundry.sh/)                                     | A blazing fast, portable and modular toolkit for Ethereum application development written in Rust                                                                                |
|  |

> SOLANA

| Tool/Resource                                 | Description                                                           |
| --------------------------------------------- | --------------------------------------------------------------------- |
| [Solana Cookbook](https://solanacookbook.com) | Developer resource for building on Solana Blockchain                  |
| [Rust](https://www.rust-lang.org/learn)       | Programming language for writing smart contracts on Solana Blockchain |
| [Solang](https://solang.readthedocs.io/)      | Solidity Compiler for Solana                                          |

> Web3 SDK & Platforms

| Platform                                      | Description                                                                |
| --------------------------------------------- | -------------------------------------------------------------------------- |
| [Moralis](https://moralis.io)                 | Moralis provides a single workflow for building high performance dapps     |
| [Thirdweb](https://thirdweb.com)              | Powerful SDK and intuitive tools for developers to implement web3 features |

    ↥ Back To Top

## Node Providers

> Infrastructure services provides instant and reliable infrastructure, empowering developers to create dApps and enhance efficiency.

| Infrastructure Service                | Description                                                                                |
| ------------------------------------- | --------------------------------------------------------------------------------------------- |
| [NodeReal](https://nodereal.io)       | NodeReal is a blockchain infrastructure and services provider                                 |
| [Infura](https://infura.io/)          | Infura provides infrastructure and tools for developers to build amazing Web 3.0 applications |
| [Alchemy](https://www.alchemy.com)    | Alchemy provides infrastructure service to build great blockchain applications                |
| [Chainstack](https://www.chainstack.com) | Chainstack is the leading suite of services connecting developers with Web3 infrastructure |
| [QuickNode](https://www.quicknode.com)| A single platform for your production, staging, and testing environments                      |
| [Ankr](https://www.ankr.com/protocol/)| The fastest and most reliable Web3 infrastructure provider                                    |
| [GetBlock](https://getblock.io/)| A flexible Blockchain RPC Provider that offers instant API access to over 50 multiple blockchains   |

    ↥ Back To Top

## Project Starter

- [Create-web3-dapp](https://github.com/alchemyplatform/create-web3-dapp)
- [Scaffold-Eth](https://github.com/scaffold-eth/scaffold-eth)
- [Create-eth-app](https://github.com/paulrberg/create-eth-app)
- [Web3-react](https://github.com/NoahZinsmeister/web3-react)
- [Web3-ui](https://github.com/Developer-DAO/web3-ui)
- [Create-web3-frontend](https://github.com/Dhaiwat10/create-web3-frontend)
- [Wagmi.sh](https://wagmi.sh/)
- [Nexth](https://github.com/wslyvh/nexth)
- [create-near-app](https://github.com/near/create-near-app)
- [Eth-hooks](https://scaffold-eth.github.io/eth-hooks/)
- [Typescript Solidity Dev Starter Kit](https://github.com/rhlsthrm/typescript-solidity-dev-starter-kit)
- [Dapp scaffold](https://github.com/solana-labs/dapp-scaffold)
- [Ethereum Boilerplate](https://github.com/ethereum-boilerplate/ethereum-boilerplate)
- [Solana dapp scaffold](https://github.com/swaroopmaddu/solana-dapp-scaffold)
- [Polygon dapp starter kit](https://github.com/Polygon-Academy/starter-kits)
- [Nextjs dapp starter ts](https://github.com/G3root/nextjs-dapp-starter-ts)
- [Lens protocol frontend](https://github.com/dabit3/lens-protocol-frontend)
- [Buildspace dao starter](https://github.com/buildspace/buildspace-dao-starter)
- [Solidity hardhat boilerplate](https://github.com/defi-wonderland/solidity-hardhat-boilerplate)
- [Solidity foundry boilerplate](https://github.com/defi-wonderland/solidity-foundry-boilerplate)
- [Hardhat template](https://github.com/paulrberg/hardhat-template)
- [Web3ui kit](https://github.com/web3ui/web3uikit)
- [Lens API starter](https://github.com/womenbuildweb3/lens-api-starter)
- [Solidity template](https://github.com/mattstam/solidity-template)
- [template-web3-app](https://github.com/turbo-eth/template-web3-app)
- [Boilr3](https://github.com/Envoy-VC/boilr3)
- [Solidity hardhat typescript boilerplate](https://github.com/emretepedev/solidity-hardhat-typescript-boilerplate)

    ↥ Back To Top

## Articles

- [Blockchain](https://www.investopedia.com/terms/b/blockchain.asp)
- [What is Web3? The Decentralized Internet of the Future Explained](https://www.freecodecamp.org/news/what-is-web3/)
- [The meaning of decentralization](https://medium.com/@VitalikButerin/the-meaning-of-decentralization-a0c92b76a274)
- [Getting started as an ethereum web developer](https://hackernoon.com/getting-started-as-an-ethereum-web-developer-9a2a4ab47baf)
- [The complete guide to full stack ethereum development](https://freecodecamp.org/the-complete-guide-to-full-stack-ethereum-development/)
- [Learn blockchain development by playing games](https://frankiefab.hashnode.dev/learn-blockchain-development-by-playing-games)
- [An introduction to bitcoin and cryptocurrency](https://hackernoon.com/an-introduction-to-bitcoin-and-cryptocurrency-618c139d1d06)
- [Ethereum dapp crash course - make an erc20 token faucet frontend](https://dev.to/richardmelko/ethereum-dapp-crash-course-make-an-erc20-token-faucet-frontend-2m43)
- [How to create an erc20 token and a solidity vendor contract](https://dev.to/stermi/how-to-create-an-erc20-token-and-a-solidity-vendor-contract-to-sell-buy-your-own-token-4j1m)
- [Building on ethereum mainnet](https://kndrck.co/posts/building-on-ethereum-mainnet-an-opinionated-guide/)
- [Ethereum dev speed run](https://medium.com/@austin_48503/%EF%B8%8Fethereum-dev-speed-run-bd72bcba6a4c)
- [Ethereum for web-developers](https://medium.com/@mvmurthy/ethereum-for-web-developers-890be23d1d0c)
- [How to deploy your first smart contract on ethereum with solidity and hardhat](https://stermi.medium.com/how-to-deploy-your-first-smart-contract-on-ethereum-with-solidity-and-hardhat-22f21d31096e)
- [Create a solana dapp from scratch](https://lorisleiva.com/create-a-solana-dapp-from-scratch)
- [Ethereum in depth - part1](https://blog.openzeppelin.com/ethereum-in-depth-part-1-968981e6f833/)
- [How the bitcoin protocol actually works](https://michaelnielsen.org/ddi/how-the-bitcoin-protocol-actually-works/)
- [How does Ethereum work anyway](https://medium.com/@preethikasireddy/how-does-ethereum-work-anyway-22d1df506369)
- [Solidity tutorial](https://blockonomi.com/solidity-tutorial/)
- [Solidity 101](https://secureum.substack.com/p/solidity-101)
- [How to create an erc-20 token on polygon](https://blog.chain.link/how-to-create-an-erc-20-token-on-polygon/)
- [How to get into ethereum crypto web3 as a developer](https://dev.to/dabit3/how-to-get-into-ethereum-crypto-web3-as-a-developer-9l6)
- [Building scalable full stack apps on ethereum with polygon](https://dev.to/edge-and-node/building-scalable-full-stack-apps-on-ethereum-with-polygon-2cfb)
- [How to make an nft and render on opensea marketplace](https://www.freecodecamp.org/news/how-to-make-an-nft-and-render-on-opensea-marketplace/)
- [Build defi yield farming application with chainlink](https://blog.chain.link/build-defi-yield-farming-application-with-chainlink/)
- [Intro security hacking smart contracts ethereum](https://www.notonlyowner.com/learn/intro-security-hacking-smart-contracts-ethereum)
- [How to build a blockchain in rust](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/)
- [Web 3.0 and the evolution of the internet](https://dev.to/frankiefab100/web-30-and-the-evolution-of-the-internet-56hk)
- [Nft deployment cost](https://blog.alchemy.com/blog/nft-deployment-cost)
- [How to code your own cryptokitties style game on ethereum](https://medium.com/loom-network/how-to-code-your-own-cryptokitties-style-game-on-ethereum-7c8ac86a4eb3)
- [How to create run your own dao](https://medium.com/bitfwd/how-to-create-run-your-own-dao-5e3eadd96962)
- [The ultimate ENS and dApp tutorial](https://www.toptal.com/ethereum/ethereum-name-service-dapp-tutorial)
- [How Can A Newbie Start Learning About Blockchain?](https://www.blockchain-council.org/blockchain/how-can-a-newbie-start-learning-about-blockchain/)
- [Learn Blockchain Development By Playing Games](https://frankiefab.hashnode.dev/learn-blockchain-development-by-playing-games)
- [Understanding Blockchain Explorers](https://frankiefab.hashnode.dev/understanding-blockchain-explorers)
- [Introduction to Blockchain Wallet](https://frankiefab.hashnode.dev/introduction-to-blockchain-wallet)
- [How To Setup Metamask Account and Add Custom Blockchain Networks](https://frankiefab.hashnode.dev/how-to-setup-metamask-account-and-add-custom-blockchain-networks)
- [A Guide To Web3 Domain Naming Services](https://frankiefab.hashnode.dev/a-guide-to-web3-domain-naming-services)
- [20 Web3 Developer Communities You Should Join In 2023](https://frankiefab.hashnode.dev/20-web3-developer-communities-you-should-join-in-2023)
- [The Future of Science: What You Need to Know About Decentralized Science (DeSci)](https://frankiefab.hashnode.dev/the-future-of-science-what-you-need-to-know-about-decentralized-science-desci)

    ↥ Back To Top

## Recommended Books

- [Bitcoin White Paper: A Peer-to-Peer Electronic Cash System - Satoshi Nakamoto](https://bitcoin.org/bitcoin.pdf)

- [Ethereum Yellow Paper: A Secure Decentralized Generalised Transaction Ledger - Dr. Gavin Wood](https://ethereum.github.io/yellowpaper/paper.pdf)

- [Mastering Ethereum: Building Smart Contracts and DApps - Andreas Antonopoulos & Dr. Gavin Wood](https://github.com/ethereumbook/ethereumbook)

- Mastering Ethereum: Implement Advanced Blockchain Applications - Merunas Grincalaitis

- [Mastering Bitcoin: Programming the Open Blockchain - Andreas M. Antonopoulos](https://github.com/bitcoinbook/bitcoinbook)

- The Infinite Machine: How an Army of Crypto-hackers Is Building the Next Internet with Ethereum - Camila Russo

- Mastering Bitcoin: Unlocking Digital Cryptocurrencies - Andreas Antonopoulos

- Programming Bitcoin: Learn How to Program Bitcoin from Scratch - Jimmy Song

- Bank 4.0 - Brett King

- Building Ethereum DApps: Decentralized Applications on the Ethereum Blockchain - Roberto Infante

- [Mastering the Lightning Network: A Second Layer Blockchain Protocol for Instant Bitcoin Payments - Andreas Antonopoulos, Olaoluwa Osuntokun & Rene Pickhardt](https://github.com/lnbook/lnbook)

- Seizing Opportunities in the Blockchain and Digital Currency Revolution: A Handbook for Enthusiasts - Chimezie Chuta

- Ethereum Blockchain Developer Guide - Thomas Wiesner

- Hands on Smart Contract Development with Solidity and Ethereum: From fundamentals to deployment - Randall Kanna & Dave Hoover

- The Spatial Web: How Web 3.0 Will Connect Humans, Machines, and AI to Transform the World - Gabriel Rene

- How to DeFi - Darren Lau et al

- The Blockchain Developer: A practical guide - Elad Elrom

- [Token Economy : How the Web3 reinvents the internet - Shermin Voshmgir](https://github.com/sherminvo/TokenEconomyBook/wiki)

    ↥ Back To Top


text:
@import url("https://fonts.googleapis.com/css?family=PT+Sans&Source+Sans+Pro&Roboto+Mono&display=swap");
* {
	-webkit-font-smoothing: antialiased;
	-webkit-overflow-scrolling: touch;
	-webkit-tap-highlight-color: rgba(0, 0, 0, 0);
	-webkit-text-size-adjust: none;
	-webkit-touch-callout: none;
	box-sizing: border-box
}

body:not(.ready) {
	overflow: hidden
}

.search {
	border-bottom: none !important;
}

.search .input-wrap {
	margin-top: 20px !important;
}

.search input {
	border: 1px solid var(--borderColor) !important;
	background-color: var(--background) !important;
	margin: 0 auto;
	color: var(--textColor);
	width: 90% !important;
	border-radius: 15px;
	text-indent: 15px;
}

body:not(.ready) .app-nav,
body:not(.ready)>nav,
body:not(.ready) [data-cloak] {
	display: none
}

div#app {
	font-size: 30px;
	font-weight: lighter;
	margin: 40vh auto;
	text-align: center
}

div#app:empty:before {
	content: "Loading..."
}

.emoji {
	height: 1.2rem;
	vertical-align: middle
}

.progress {
	background-color: var(--accent);
	height: 2px;
	left: 0;
	position: fixed;
	right: 0;
	top: 0;
	transition: width .2s, opacity .4s;
	width: 0;
	z-index: 999999
}

.search .search-keyword,
.search a:hover {
	color: var(--accent)
}

.search .search-keyword {
	font-style: normal;
	font-weight: 700
}

body,
html {
	height: 100%
}

body {
	-moz-osx-font-smoothing: grayscale;
	-webkit-font-smoothing: antialiased;
	color: var(--textColor);
	font-family: var(--siteFont), Helvetica Neue, Arial, sans-serif;
	font-size: var(--bodyFontSize);
	letter-spacing: 0;
	margin: 0;
	overflow-x: hidden;

}

.markdown-section h2 {
	color: #fff;
}

img {
	max-width: 100%
}

a[disabled] {
	cursor: not-allowed;
	opacity: .6
}

kbd {
	border: 1px solid #ccc;
	border-radius: 3px;
	display: inline-block;
	font-size: 12px!important;
	line-height: 12px;
	margin-bottom: 3px;
	padding: 3px 5px;
	vertical-align: middle
}

li input[type=checkbox] {
	margin: 0 .2em .25em 0;
	vertical-align: middle
}

.app-nav {
	margin: 25px 60px 0 0;
	position: absolute;
	right: 0;
	text-align: right;
	z-index: 10
}

.app-nav.no-badge {
	margin-right: 25px
}

.app-nav p {
	margin: 0
}

.app-nav>a {
	margin: 0 1rem;
	padding: 5px 0
}

.app-nav li,
.app-nav ul {
	display: inline-block;
	list-style: none;
	margin: 0
}

.app-nav a {
	color: inherit;
	font-size: 16px;
	text-decoration: none;
	transition: color .3s
}

.app-nav a.active,
.app-nav a:hover {
	color: var(--accent)
}

.app-nav a.active {
	border-bottom: 2px solid var(--accent)
}

.app-nav li {
	display: inline-block;
	margin: 0 1rem;
	padding: 5px 0;
	position: relative;
	cursor: pointer
}

.app-nav li ul {
	background-color: #fff;
	border: 1px solid;
	border-color: #ddd #ddd #ccc;
	border-radius: 4px;
	box-sizing: border-box;
	display: none;
	max-height: calc(100vh - 61px);
	overflow-y: auto;
	padding: 10px 0;
	position: absolute;
	right: -15px;
	text-align: left;
	top: 100%;
	white-space: nowrap
}

.app-nav li ul li {
	display: block;
	font-size: 14px;
	line-height: 1rem;
	margin: 8px 14px;
	white-space: nowrap
}

.app-nav li ul a {
	display: block;
	font-size: inherit;
	margin: 0;
	padding: 0
}

.app-nav li ul a.active {
	border-bottom: 0
}

.app-nav li:hover ul {
	display: block
}

.github-corner {
	border-bottom: 0;
	position: fixed;
	right: 0;
	text-decoration: none;
	top: 0;
	z-index: 1
}

.github-corner:hover .octo-arm {
	-webkit-animation: octocat-wave .56s ease-in-out;
	animation: octocat-wave .56s ease-in-out
}

.github-corner svg {
	color: #fff;
	fill: var(--accent);
	height: 70px;
	width: 70px
}

main {
	display: block;
	position: relative;
	width: 100vw;
	height: 100%;
	z-index: 0
}

main.hidden {
	display: none
}

.anchor {
	display: inline-block;
	text-decoration: none;
	transition: all .3s
}

.anchor span {
	color: var(--textColor);
}

.anchor:hover {
	text-decoration: underline
}

.sidebar {
	border-right: 1px solid var(--borderColor);
	overflow-y: auto;
	padding: 40px 0 0;
	position: absolute;
	top: 0;
	bottom: 0;
	left: 0;
	transition: transform .25s ease-out;
	width: 300px;
	z-index: 20
}

.sidebar>h1 {
	margin: 0 auto 1rem;
	font-size: 1.5rem;
	font-weight: 300;
	text-align: center
}

.sidebar>h1 a {
	color: inherit;
	text-decoration: none
}

.sidebar>h1 .app-nav {
	display: block;
	position: static
}

.sidebar .sidebar-nav {
	line-height: 2em;
	padding-bottom: 40px
}

.sidebar li.collapse .app-sub-sidebar {
	display: none
}

.sidebar ul {
	margin: 0 0 0 15px;
	padding: 0
}

.sidebar li>p {
	font-weight: 700;
	margin: 0
}

.sidebar ul,
.sidebar ul li {
	list-style: none
}

.sidebar ul li a {
	border-bottom: none;
	display: block
}

.sidebar ul li ul {
	padding-left: 20px
}

.sidebar::-webkit-scrollbar {
	width: 4px
}

.sidebar::-webkit-scrollbar-thumb {
	background: transparent;
	border-radius: 4px
}

.sidebar:hover::-webkit-scrollbar-thumb {
	background: hsla(0, 0%, 53.3%, .4)
}

.sidebar:hover::-webkit-scrollbar-track {
	background: hsla(0, 0%, 53.3%, .1)
}

.sidebar-toggle {
	background-color: transparent;
	border: 0;
	outline: none;
	padding: 10px;
	position: absolute;
	bottom: 0;
	left: 0;
	text-align: center;
	transition: opacity .3s;
	width: 284px;
	z-index: 30;
	cursor: pointer
}

.sidebar-toggle:hover .sidebar-toggle-button {
	opacity: .4
}

.sidebar-toggle span {
	background-color: var(--accent);
	display: block;
	margin-bottom: 4px;
	width: 16px;
	height: 2px
}

body.sticky .sidebar,
body.sticky .sidebar-toggle {
	position: fixed
}

.content {
	padding-top: 60px;
	position: absolute;
	top: 0;
	right: 0;
	bottom: 0;
	left: 300px;
	transition: left .25s ease
}

.markdown-section {
	margin: 0 auto;
	max-width: 90%;
	padding: 30px 15px 40px;
	position: relative
}

.markdown-section>* {
	box-sizing: border-box;
	font-size: inherit
}

.markdown-section>:first-child {
	margin-top: 0!important
}

.markdown-section hr {
	border: none;
	border-bottom: 1px solid #eee;
	margin: 2em 0
}

.markdown-section iframe {
	border: 1px solid #eee;
	width: 1px;
	min-width: 100%
}

.markdown-section table {
	border-collapse: collapse;
	border-spacing: 0;
	display: block;
	margin-bottom: 1rem;
	overflow: auto;
	width: 100%
}

.markdown-section th {
	font-weight: 700
}

.markdown-section td,
.markdown-section th {
	border: 1px solid #ddd;
	padding: 6px 13px
}

.markdown-section tr {
	border-top: 1px solid #ccc
}

.markdown-section p.tip,
.markdown-section tr:nth-child(2n) {
	background-color: var(--codeBackgroundColor)
}

.markdown-section p.tip {
	border-bottom-right-radius: 2px;
	border-left: 4px solid #f66;
	border-top-right-radius: 2px;
	margin: 2em 0;
	padding: 12px 24px 12px 30px;
	position: relative
}

.markdown-section p.tip:before {
	background-color: #f66;
	border-radius: 100%;
	color: #fff;
	content: "!";
	font-family: Dosis, Source Sans Pro, Helvetica Neue, Arial, sans-serif;
	font-size: 14px;
	font-weight: 700;
	left: -12px;
	line-height: 20px;
	position: absolute;
	height: 20px;
	width: 20px;
	text-align: center;
	top: 14px
}

.markdown-section p.tip code {
	background-color: #efefef
}

.markdown-section p.tip em {
	color: #34495e
}

.markdown-section p.warn {
	background: rgba(66, 185, 131, .1);
	border-radius: 2px;
	padding: 1rem
}

.markdown-section ul.task-list>li {
	list-style-type: none
}

body.close .sidebar {
	transform: translateX(-300px)
}

body.close .sidebar-toggle {
	width: auto
}

body.close .content {
	left: 0
}

@media print {
	.app-nav,
	.github-corner,
	.sidebar,
	.sidebar-toggle {
		display: none
	}
}

@media screen and (max-width:768px) {
	.github-corner,
	.sidebar,
	.sidebar-toggle {
		position: fixed
	}
	.app-nav {
		margin-top: 16px
	}
	.app-nav li ul {
		top: 30px
	}
	main {
		height: auto;
		overflow-x: hidden
	}
	.sidebar {
		left: -300px;
		transition: transform .25s ease-out
	}
	.content {
		left: 0;
		max-width: 100vw;
		position: static;
		padding-top: 20px;
		transition: transform .25s ease
	}
	.app-nav,
	.github-corner {
		transition: transform .25s ease-out
	}
	.sidebar-toggle {
		background-color: transparent;
		width: auto;
		padding: 30px 30px 10px 10px
	}
	body.close .sidebar {
		transform: translateX(300px)
	}
	body.close .sidebar-toggle {
		transition: background-color 1s;
		width: 284px;
		padding: 10px
	}
	body.close .content {
		transform: translateX(300px)
	}
	body.close .app-nav,
	body.close .github-corner {
		display: none
	}
	.github-corner:hover .octo-arm {
		-webkit-animation: none;
		animation: none
	}
	.github-corner .octo-arm {
		-webkit-animation: octocat-wave .56s ease-in-out;
		animation: octocat-wave .56s ease-in-out
	}
}

@-webkit-keyframes octocat-wave {
	0%,
	to {
		transform: rotate(0)
	}
	20%,
	60% {
		transform: rotate(-25deg)
	}
	40%,
	80% {
		transform: rotate(10deg)
	}
}

@keyframes octocat-wave {
	0%,
	to {
		transform: rotate(0)
	}
	20%,
	60% {
		transform: rotate(-25deg)
	}
	40%,
	80% {
		transform: rotate(10deg)
	}
}

section.cover {
	align-items: center;
	background-position: 50%;
	background-repeat: no-repeat;
	background-size: cover;
	height: 0vh;
	display: none
}

section.cover.show {
	display: inline;
	background: var(--coverBackground)!important;
}

section.cover.has-mask .mask {
	background-color: #fff;
	opacity: .8;
	position: absolute;
	top: 0;
	height: 100%;
	width: 100%
}

section.cover .cover-main {
	flex: 1;
	margin: -20px 16px 0;
	text-align: center;
	z-index: 1
}

section.cover a {
	color: inherit
}

section.cover a,
section.cover a:hover {
	text-decoration: none
}

section.cover p {
	line-height: 1.5rem;
	margin: 1em 0
}

section.cover h1 {
	color: inherit;
	font-size: 2.5rem;
	font-weight: 300;
	margin: .625rem 0 2.5rem;
	position: relative;
	text-align: center
}

section.cover h1 a {
	display: block
}

section.cover h1 small {
	bottom: -.4375rem;
	font-size: 1rem;
	position: absolute
}

section.cover blockquote {
	font-size: 1.5rem;
	text-align: center
}

section.cover ul {
	line-height: 1.8;
	list-style-type: none;
	margin: 1em auto;
	max-width: 500px;
	padding: 0
}

section.cover .cover-main>p:last-child a {
	border-radius: 2rem;
	border: 1px solid var(--accent);
	box-sizing: border-box;
	color: var(--accent);
	display: inline-block;
	font-size: 1.05rem;
	letter-spacing: .1rem;
	margin: .5rem 1rem;
	padding: .75em 2rem;
	text-decoration: none;
	transition: all .15s ease
}

section.cover .cover-main>p:last-child a:last-child {
	background-color: var(--accent);
	color: #fff
}

section.cover .cover-main>p:last-child a:last-child:hover {
	color: inherit;
	opacity: .8
}

section.cover .cover-main>p:last-child a:hover {
	color: inherit
}

section.cover blockquote>p>a {
	border-bottom: 2px solid var(--accent);
	transition: color .3s
}

section.cover blockquote>p>a:hover {
	color: var(--accent)
}

.sidebar,
body {
	background-color: var(--background);
	transition: background-image .15s ease-in-out .15s;
}

.sidebar {
	color: var(--textColor);
}

.sidebar li {
	margin: 6px 0
}

.sidebar ul li a {
	color: var(--sidebarSublink);
	font-size: 14px;
	font-weight: 400;
	overflow: hidden;
	text-decoration: none;
	text-overflow: ellipsis;
	white-space: nowrap
}

.sidebar ul li a:hover {
	text-decoration: underline
}

.sidebar ul li ul {
	padding: 0
}

.sidebar ul li.active>a {
	border-right: 2px solid;
	color: var(--accent);
	font-weight: 600
}

.app-sub-sidebar li:before {
	content: "-";
	padding-right: 4px;
	float: left
}

.markdown-section h1,
.markdown-section h2,
.markdown-section h3,
.markdown-section h4,
.markdown-section strong {
	color: var(--textColor);
	font-weight: 600
}

.markdown-section a {
	color: var(--accent);
	font-weight: 600;
	text-decoration: none;
}

.markdown-section h1 {
	font-size: 2rem;
	margin: 0 0 1rem
}

.markdown-section h2 {
	font-size: 1.75rem;
	margin: 45px 0 .8rem
}

.markdown-section h3 {
	font-size: 1.5rem;
	margin: 40px 0 .6rem
}

.markdown-section h4 {
	font-size: 1.25rem
}

.markdown-section h5 {
	font-size: 1rem
}

.markdown-section h6 {
	color: #777;
	font-size: 1rem
}

.markdown-section figure,
.markdown-section p {
	margin: 1.2em 0
}

.markdown-section ol,
.markdown-section p,
.markdown-section ul {
	line-height: 1.6rem;
	word-spacing: .05rem
}

.markdown-section ol,
.markdown-section ul {
	padding-left: 1.5rem
}

.markdown-section blockquote {
	border-left: 4px solid var(--accent);
	color: var(--blockQuoteColor);
	margin: 2em 0;
	padding-left: 20px
}

.markdown-section blockquote p {
	font-weight: 600;
	margin-left: 0
}

.markdown-section iframe {
	margin: 1em 0
}

.markdown-section em {
	color: #7f8c8d
}

.markdown-section code {
	border-radius: 2px;
    color: var(--highlightColor);
    font-size: .9rem;
    margin: 0 2px;
    padding: 3px 5px;
    white-space: pre-wrap;
    font-weight: bold;
}

.markdown-section code,
.markdown-section pre {
	background-color: var(--codeBackgroundColor);
	font-family: var(--codeFontFamily);
}

.markdown-section pre {
	-moz-osx-font-smoothing: initial;
	-webkit-font-smoothing: initial;
	line-height: 1.5rem;
	margin: 1.2em 0;
	overflow: auto;
	padding: 0 1.4rem;
	position: relative;
	word-wrap: normal
}

.token.cdata,
.token.comment,
.token.doctype,
.token.prolog {
	color: #8e908c
}

.token.namespace {
	opacity: .7
}

.token.boolean,
.token.number {
	color: #c76b29
}

.token.punctuation {
	color: #525252
}

.token.property {
	color: #c08b30
}

.token.tag {
	color: #2973b7
}

.token.string {
	color: var(--accent)
}

.token.selector {
	color: #6679cc
}

.token.attr-name {
	color: #2973b7
}

.language-css .token.string,
.style .token.string,
.token.entity,
.token.url {
	color: #22a2c9
}

.token.attr-value,
.token.control,
.token.directive,
.token.unit {
	color: var(--accent)
}

.token.function,
.token.keyword {
	color: #e96900
}

.token.atrule,
.token.regex,
.token.statement {
	color: #22a2c9
}

.token.placeholder,
.token.variable {
	color: #3d8fd1
}

.token.deleted {
	text-decoration: line-through
}

.token.inserted {
	border-bottom: 1px dotted #202746;
	text-decoration: none
}

.token.italic {
	font-style: italic
}

.token.bold,
.token.important {
	font-weight: 700
}

.token.important {
	color: #c94922
}

.token.entity {
	cursor: help
}

.markdown-section pre>code {
	-moz-osx-font-smoothing: initial;
	-webkit-font-smoothing: initial;
	background-color: var(--codeBackgroundColor);
	border-radius: 2px;
	color: var(--codeTextColor);
	display: block;
	font-family: Roboto Mono, Monaco, courier, monospace;
	font-size: .8rem;
	line-height: inherit;
	margin: 0 2px;
	max-width: inherit;
	overflow: inherit;
	padding: 2.2em 5px;
	white-space: inherit
}

.markdown-section code:after,
.markdown-section code:before {
	letter-spacing: .05rem
}

code .token {
	-moz-osx-font-smoothing: initial;
	-webkit-font-smoothing: initial;
	min-height: 1.5rem;
	position: relative;
	left: auto
}

pre:after {
	color: var(--codeTypeColor);
	content: attr(data-lang);
	font-size: .6rem;
	font-weight: 600;
	height: 15px;
	line-height: 15px;
	padding: 5px 10px 0;
	position: absolute;
	right: 0;
	text-align: right;
	top: 0
}

 /* toogler */

 #docsify-darklight-theme {
    border: none;
    background-color: transparent;
	position: absolute;
	right: 10px;
    top: 15px;
	width: 25px;
	height: 25px;
	background-repeat: no-repeat;
	background-image: var(--toogleImage);
	-o-background-size: cover;
    -moz-background-size: cover;
    -webkit-background-size:cover;
    background-size: cover;
	cursor: pointer;
	user-select: none;
	transition: background-image .15s ease-in-out .15s
}