There are a lot of points out there and suggested by many masters in this field.

I will try my best to consolidate the majority of them here 👇

**Will update this blog periodically, so save it for further reference

Don't Initialize Variables with Default Value

If the variable is not set/initialized, it is assumed to have a default value (0, false, 0x0, etc., depending on the data type).

If you explicitly initialize it with its default value, you are just wasting gas.

Reading and writing local variables is cheap, whereas reading and writing state variables stored in contract storage are expensive.

Pack your variables!

uint8 is not always cheaper than uint256

Mark immutable variables

Public vs External (External is cheaper)

The public modifier is equivalent to external + internal. In other words, both public and external can be called from outside your contract (like MetaMask), but only the public can be called from other functions inside your contract.

Similarly, if a function is only called by other functions in the contract using the "internal" modifier is good it is cheaper to call

prefix increment is better than postfix increment.

Note to be careful using this optimization whenever the expression's return value is used afterwards, e.g. uint a = i++ and uint a = ++i result in different values for a.

Another benefit of using this method👇

When using any kind of counter (like _tokenId), starting it off at 1 instead of 0 will make the first mint slightly cheaper. In general, writing a value to a slot that doesn’t have one will be more expensive than writing to one that does, so keep that in mind.

Delete variables that you don’t need.

In Ethereum, you get a gas refund for freeing up storage space. If you don’t need a variable anymore, you should delete it using the delete keyword provided by solidity or by setting it to its default value.

Welcome again to my blog, I am Praneeth Reddy Arikatla. Pursuing my master's in Computer Science at Polimiand living in Berlin as an exchange student at TU Berlin. Also, looking for full-time job opportunities in WBE3. Please visit praneethreddy.me for more details and here is my resume.

Enough, let's get back to DevConnect and dive in.

Okay, Before getting in I should thank two people without them I wouldn't have gone to this event. Baptiste for sponsoring enough amount to attend this week-long event and Piablo another developer_daomember for letting me crash in his place.

DAY 0

I was so excited and planned a lot on what events to attend and how to interact/network with people and get some benefit(JOB OPPORTUNITIES) out of it. Which didn't happen as exactly as planned, but in the end, everything went fine so, follow along till the end and see what happened.

DAY 1

Attended WEB3 UX unConference("A participant-driven meeting").

Met many great people in this space like Tom from Tokyo, Taha from ChainSafe, Raffiq and also SAM and discussed the user experience on ONBOARDING people into WBE3 with as a working group. That was a great talk with the group and also with Sam.

My personal takeaway from the event:- Maxis in this space wants everything to be as per the web3 principles, But the technology still didn't reach that advanced stage where it makes even non-tech people hop in without any friction/bad user experience. I personally think the future would be WEB2.5 where people take leverage of WEB2 to bring more people onto WEB3 and both technologies will co-exist.

DAY 2

Attended "Build an ETH Dapp in 7hours" by buidspace

I know this is a beginners event, but I went there to meet Farzaand the team behind buildspace IRL. I had a great time there and did a mini hack "Token gated file sharing" tool with a great teamGeorge, Pedro, and Jason.

Also, a suggestion for buildspace would be to try to have some in-hand building experience in-person in these types of events, I know the majority of people would be coming for networking but since this is a beginners event there will be people attending there who would be willing to learn something in-person.

My Personal Takeaway from this event:- You should be very strong at the fundamentals be it a normal tech stack or web3 tech stack. This will help you build something faster than it takes when you google something.

DAY 3

Attended "Oh! Snap It's Metamask!" by MetaMask

Man, this was such a great workshop! got to know that metamask has a development version metamask(FLASK) and wrote a snap for a password manager. People who attended there are soooo technically strong in this space and the team behind metamask were there who are also really at another level, where at a time I felt it was over my head but two other people(Steph and Alex) from developer_daohelped me understand what's happening there :P

My Personal Takeaway from this event:- Don't think you know many things, especially in WEB3, You know just a drop in an ocean.

Also attended a party "Filecoin & Friends Social!" by IPFS& FILECOIN and met another incredible person MICHAEL MORAMI from Certora and had insights on formal verification in Smart contract security.

DAY 4

Attended "Secureum TrustX" by Secureum

People who attended are really really knowledgeable and very strong at what they know/speak. Security is one of the most important aspects of any protocol or application being built especially in WEB3 because if you want to onboard more people you would make them feel that the tech here is safe enough to interact with. The recent rise in hacks, bugs, and scams scares the shi* out of people. Also, meeting Rajeev in person is really exciting

My Personal Takeaway from this event:- Security in WEB3 should do a "LEFT SHIFT" in the development process. While developing always think from a security perspective as well.

DAY 5

ETHAmsterdam

I actually have registered for the hackathon but unfortunately couldn't stake the required eth to reserve my spot. So, they withdrew my application which I came to know lately. But, somehow I wanted to be there and have that experience of meeting people and sharing knowledge and meeting the companies in WEB3. Looked at all possible ways and finally decided to volunteer for the ETHGlobal team that is organizing ETHAms. Got into this space and spend as much time as I can there. Met really great people here and legends out there in this space. Also met people who are budding into this space which is really inspiring and motivating to stay strong and stick to your journey in web3.

Met great people like Huichi, Andrew Dunscomb, Kartik Talwar, Naomi, CheeChyuan, Luke, Shaka, Emily, and Anna.

Also met the great Evan and had a great talk. Thanks for the suggestion to start contributing to opensource, I will start doing that.

My Personal Takeaway from this event:- Don't worry about how much you know in WEB3, just stay in this space and take your time and keep on building. Eventually, you will learn a lot and gain a lot of knowledge. We are soooooooo fuck*ng early into this there will be a lot of ups and downs in this journey, just take inspiration from the community and stay long.

Developer_Dao members-only Happy hours

Also attended developer_dao event sponsored by coinbase happened on Saturday(23rd April 2022). This is where real networking for me happened I met people whom I am following from the start of my web3 journey. Thanks to Nader, Vitto, Albert, Josh, Rahat, Alex, Kay, Sil, Ryan, piablo, pedro, Aakansha, kempsterrr, George, Cami, for making this happen, for hearing me out, giving me suggestions.

MY LEARNINGS FROM THE WHOLE WEEK:-

STAY STRONG, KEEP LEARNING, KEEP BUILDING, KEEP NETWORKING, BELIEVE IN YOURSELF, and CONTRIBUTE TO OPEN SOURCE. You will eventually land in a good place that is designated for you.

I will be trying as much as I can and let's see what will happen. I AM ALL IN.

Blockchain is one of the most interesting and exciting technology in recent times. You can see people making millions of dollars by selling NFTs. Take for example an Indonesian guy Sultan Gustaf Al Ghozali, 22, who studies computer science at a college in Indonesia, he took a photo of himself sitting in front of his computer every day for five years.

Started selling them as NFT for $3 each but later it became famous and was sold out, as of today total volume traded is Ether 396 which is ~ $1.1 M.

ghozali-everyday Opensea account

With the rising interest in NFTs, developers are also slowly rising to the top. Ethereum is the biggest smart-contract blockchain and has a huge NFT community but the problem is its gas fees.

At the time of writing this article, a simple NFT smart contract would cost around $1000+ to deploy. So we would be using Polygon’s blockchain to deploy and mint. It is an EVM-compatible blockchain with many projects adopting it as a secondary option including OpenSea the dominating NFT marketplace. Gas fees in Polygon are relatively low compared to Ethereum and have the same functionalities.

⚙️ Project Setup

We will be using a tool called Hardhat, It is an Ethereum development environment, fortunately, it also works with Polygon and a few other chains. Hardhat will let us quickly compile smart contracts and test them locally. Assuming you already have node/npm in your system.

Next, let's head to the terminal. Go ahead and cd to the directory you want to work in. then install hardhat following the below commands,

mkdir polygon-nft
cd polygon-nft
npm init -y
npm install --save-dev hardhat

After you execute the last command and install hardhat, You may see a message about vulnerabilities. This is a common warning when you install anything using NPM. You can google about it if you want to know more!

Now execute the following command which is basically initiating hardhat which will give us an option to start with basic/simple project setup. After you execute the below command it gives you a few options, for now, we will go ahead with default options, so just keep pressing enter.

npx hardhat

The sample project will ask you to install a few other dependencies which are helpful like hardhat-waffle and hardhat-ethers.

I would suggest going ahead and installing these other dependencies just in case it didn't do it automatically.

npm install --save-dev @nomiclabs/hardhat-waffle ethereum-waffle chai @nomiclabs/hardhat-ethers ethers

We'll also want to install "OpenZeppelin" which is another library that's used a lot to develop secure smart contracts

npm install @openzeppelin/contracts

You should now have a directory filled with a few files and folders like contracts, scripts, and test.

So just to verify go ahead and run the following command

npx hardhat run scripts/sample-script.js

which should give us something like

💥 If you see this it means your local environment is set up and you also ran/deployed a smart contract to a local blockchain.

What happened here is that

• Hardhat compiled your smart contract from solidity to bytecode
• Hardhat created a "local blockchain" on your computer
• Hardhat then "deployed" your compiled contract to your local blockchain

✍Writing actual Smart Contract

Now there are multiple files and folders in your polygon-nft folder. Go ahead and delete the file sample-test.js under the test folder. Also, delete sample-script.js under scripts. Then, delete Greeter.sol under contracts. Don't delete the actual folders!

Now you can try going to https://docs.openzeppelin.com/contracts/4.x/wizard and get code is generated by their useful tool depending on selected features for making a simple contract.

OR

Let's write it!!

Create a file named polygonNFT.sol under the contracts directory and copy-paste the following code in that file and save it. I will explain the code below

// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.1;

import "hardhat/console.sol";

contract polygonNFT {
    constructor() {
        console.log("This is my first ever Polygon NFT contract. I am Excited!");
    }
}

let's go line by line :

// SPDX-License-Identifier: UNLICENSED

This is about the license of using your smart contract, you can fine more about them here.

pragma solidity ^0.8.1;

This is the version of the Solidity compiler we want our contract to use. When you say 0.8.1, it means that any Solidity compiler with version 0.8.1 or higher but less than 0.9.0 can be used to run our smart contract.

Note, be sure your compiler is set accordingly (0.8.1) in hardhat.config.js.

import "hardhat/console.sol";

Importing Hardhat provided a solidity file that will allow us to do some console logs in our contract which would be helpful while developing and testing.

contract polygonNFT {
    constructor() {
        console.log("This is my first ever Polygon NFT contract. I am Excited!");
    }
}

It is basically like a class on other object-oriented programming languages. Once we initialize this contract for the first time, that constructor will run and print out that line to the console.

🏃 Let's run our smart contract

Go ahead into the scripts folder and create a file named run.js. And copy-paste the following code in run.js:

const main = async () => {
  const polygonContractFactory = await hre.ethers.getContractFactory('polygonNFT');
  const nftContract = await polygonContractFactory.deploy();
  await nftContract.deployed();
  console.log("Contract deployed to:", nftContract.address);
};

const runMain = async () => {
  try {
    await main();
    process.exit(0);
  } catch (error) {
    console.log(error);
    process.exit(1);
  }
};

runMain();

The above basically doing the following things:

• compile our smart contract
• deploy it to our local blockchain

let's go line by line again:

const polygonContractFactory = await hre.ethers.getContractFactory("polygonNFT");

This will compile our contract and generate a few necessary files in the artifacts folder which are needed work with our contract.

const nftContract = await polygonContractFactory.deploy();

The above line will make Hardhat create a local Ethereum network for us, but just for this contract. Then, after the script completes it'll destroy that local network. So, every time you run the contract, it'll be a fresh blockchain.

await nftContract.deployed();

The above line will make sure to wait until our contract is officially mined and deployed to our local blockchain. Yeah, hardhat will actually create fake "miners" on your machine to try its best to imitate the actual blockchain.

Our constructor will also run when the smart contract is fully deployed!

console.log("Contract deployed to:", nftContract.address);

You know the console.log line, it will print the nftContract.address which is the address of our smart contract on that blockchain onto the terminal.

The runMain() function is actually the starting function that will be executed once we run below. Function content is self-explanatory :)

Now let's go ahead and run the actual smart contract we created. Go back to your terminal where you executed "npx hardhat run scripts/sample-script.js" previously

npx hardhat run scripts/run.js

Once you run that command, on your terminal you would see "This is my first ever Polygon NFT contract. I am Excited!" the console.log text in your constructor then "Contract deployed to: .........." which displays your contract address.

It should look something like this:

👷 Now let's write minting functionality

// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.1;

// We import some OpenZeppelin Contracts which are helpful.
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "hardhat/console.sol";

// We inherit the contract we imported. Which means we'll have access to the inherited contract's methods.
contract polygonNFT is ERC721URIStorage {
  // provided by OpenZeppelin to help us keep track of tokenIds.
  using Counters for Counters.Counter;
  Counters.Counter private _tokenIds;

  // We need to pass the name of our NFT token and its symbol.
  constructor() ERC721 ("My First Polygon NFT Project", "0xViking") {
    console.log("This is my first ever Polygon NFT contract. I am Excited!");
  }

  // A function our user will hit to get their NFT.
  function mintMyPolygonNFT() public {
     // Get the current tokenId, this starts at 0.
    uint256 newItemId = _tokenIds.current();

     //Main minting of the NFT to the caller using msg.sender.
    _safeMint(msg.sender, newItemId);

    // Set the NFTs data.
    _setTokenURI(newItemId, "ThisNeedsToBeChanges");

    // Increment the counter for when the next NFT is minted.
    _tokenIds.increment();
  }
}

I tried to explain each line using comments. If you still have any doubt please comment below, I am more than happy to explain you :)

Now let's update the TokenURI which is the actual NFT data. It usually links to a JSON file called the metadata and that looks something like this:

{
    "name": "This is Viking",
    "description": "Let's conquer the web3",
    "image": "https://i.imgur.com/ZIbmiR6.png"
}

You can customize this, but, almost every NFT has a name, description, and a link to something like a video, image, etc.

Be careful with the structure of your metadata, if your structure does not match the OpenSea Requirements your NFT will appear broken on the website. This is all part of the ERC721 standards and it allows people to build websites on top of NFT data.

The image link mentioned above is an Imgur link which is a centralized image hosting service, I have created an account there and uploaded my image there, and copied the link from it.

Please check your copied Imgur link should be a Direct Imgur link that looks like - https://i.imgur.com/abc123.png NOT https://imgur.com/gallery/abc123. The easiest way to tell is to check if the URL ends in an image extension like .png or .jpg. You can right-click the Imgur image and "copy image address". This will give you the correct URL.

We can copy the This is Viking JSON metadata above and paste it into this jsonkeeper site.

This website is just an easy place for people to host JSON data and we'll be using it to keep our NFT data for now. Once you click "Save" you'll get a link to the JSON file. (Something like https://jsonkeeper.com/b/56BW). You can test your link by opening a new tab and be sure it all looks good!

Now, let's go head to our smart contract and change that one line.

Following line of code

_setTokenURI(newItemId, "ThisNeedsToBeChanges")

to the below code where we are actually setting the URI as the link to our JSON file.

// mine looks like _setTokenURI(newItemId, "https://jsonkeeper.com/b/56BW");
_setTokenURI(newItemId, "INSERT_YOUR_JSON_URL_HERE");

Under that line, we will add a console.log just to help us see when the NFT is minted and to whom!

console.log("An NFT with ID %s has been minted to %s", newItemId, msg.sender);

🎉 Let's Mint an NFT on our local chain

What we need to do is to change our run.js file to call our mintMyPolygonNFT() function. add the following code below our console.log line in the main function

  // Call the function.
  let txn = await nftContract.mintMyPolygonNFT()
  // Wait for it to be mined.
  await txn.wait()

  // Mint another NFT for fun.
  txn = await nftContract.mintMyPolygonNFT()
  // Wait for it to be mined.
  await txn.wait()

that's it, let's run using the following command:

npx hardhat run scripts/run.js

It should mint 2 NFTs on your local blockchain. Here is how mine looks like

💻 Let's deploy to Polygon Mumbai testnet

When we deploy our contract, we need to tell all those miners, "hey, this is a new smart contract, please add my smart contract to the blockchain and then tell everyone else about it as well".

We will use Alchemy to do this.

Alchemy essentially helps us broadcast our contract creation transaction so that it can be picked up by miners as quickly as possible. Once the transaction is mined, it is then broadcasted to the blockchain as a legit transaction. From there, everyone updates their copy of the blockchain.

Go ahead and create an account at Alchemy

Then check out this video created by Farza below on how to get your Testnet API-key, in the video, he showed Rinkeby testent, instead, you can select Polygon and the Polygon-Mumbai in the dropdown.

BTW you also need a wallet to do so, I will suggest to go with Metamask and creating a wallet. Now add Polygon Mumbai to your metamask wallet. Check out this short video below. which also shows adding fake matic tokens which are required to deploy our smart contract

Once everything is ready let's set our deploy.js file. Go ahead and create a file named deploy.js under the scripts folder. Copy-paste all of run.js into deploy.js.

Then update your hardhat.config.js

require("@nomiclabs/hardhat-waffle");

// This is a sample Hardhat task. To learn how to create your own go to
// https://hardhat.org/guides/create-task.html
task("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
  const accounts = await hre.ethers.getSigners();

  for (const account of accounts) {
    console.log(account.address);
  }
});

// You need to export an object to set up your config
// Go to https://hardhat.org/config/ to learn more

/**
 * @type import('hardhat/config').HardhatUserConfig
 */
module.exports = {
  solidity: "0.8.1",
  networks: {
    mumbai: {
      url: 'YOUR_ALCHEMY_API_URL-COPY_IT-FROM-DASHBOARD',
      accounts: ['YOUR-MUMBAI-ACCOUNT-PRIVATE-KEY'],
    },
  },
};

DON'T COMMIT THIS FILE TO GITHUB. IT HAS YOUR PRIVATE KEY. YOU WILL GET HACKED + ROBBED. THIS PRIVATE KEY IS THE SAME AS YOUR MAINNET PRIVATE KEY. In the meantime - open your .gitignore file and add a line for hardhat.config.js.

Once you've got your config setup we're set to deploy with the deploy script we wrote earlier.

execute the following command in the terminal:

npx hardhat run scripts/deploy.js --network mumbai

Executing the above command gives you similar output:

Copy that contract address and go to Mumbai Testnet explorer and paste the address there and verify whether it was successful or not.

Okay, BTW you have minted two NFTs while deploying your smart contract let's go to opensea testnetsand see in your account whether those minted NFTs are there are not, Opensea might take a few minutes to sync.

This is how my collection looks:

That brings an end to this article.

So while deploying to the Polygon mainnet, in the deploy.js file remove that mintMyPolygonNFT() triggering statements so that your collection starts from starting in the mainnet.

txn = await nftContract.mintMyPolygonNFT()
// Wait for it to be mined.
await txn.wait()

BONUS: If you want to deploy it to mainnet, add configurations to networks key in hardhat.config.js. Something like;

networks: {
    mumbai: {
      url: 'YOUR_ALCHEMY_API_URL-COPY_IT-FROM-DASHBOARD',
      accounts: ['YOUR-MUMBAI-ACCOUNT-PRIVATE-KEY'],
    },
    rinkeby: {
      url: 'YOUR_ALCHEMY_RINKEBY-API_URL-COPY_IT-FROM-DASHBOARD',
      accounts: ['YOUR-ACCOUNT-PRIVATE-KEY'],
    },
    polygon: {
      url: 'YOUR_ALCHEMY_POLYGON-MAINNET-API_URL-COPY_IT-FROM-DASHBOARD',
      accounts: ['YOUR-ACCOUNT-PRIVATE-KEY'],
    },
  },

I hope this was helpful and all the best for your journey in web3.

Let me know how this went on Twitter @0xViking. My DMs are open feel free to text me :)

WAGMI🚀

I believe this is the time to jump into this emerging field and grab the only " once in a lifetime" opportunity.

Below I have written a crowdsourced roadmap(step-by-step) I am going to follow to become a blockchain master. I chose Ethereum blockchain to start with and I have mentioned the reason below for that. You can choose whatever blockchain you want but I believe after looking at the stats below you feel the same as me.

According to State of the Dapps till January 2022 there are a total of 3,957 Dapps.

Out of those 3,957 dapps the majority of the share was dominated by Ethereum with 2,929 dapps which is ~74% of the total dapps available. So I believe to start with Ethereum since there would be many opportunities, later you can go for other blockchains depending on your interest.

🏗🔨 Building vs Breaking

I personally believe that you are a master in any field only if you have knowledge of how to break a system and find vulnerabilities in it.

So in my roadmap, I am going to make sure you know how to break a system, But without knowing how an application/protocol/framework is built or structured, we cannot proceed further to find any vulnerabilities in it, however, If you do manage to find actual vulnerabilities in a smart contract or any blockchain protocol, without having any prior knowledge of how it is built and structured; You were just throwing arrows in the dark, and got lucky.

To a great extent, your ability to break into an application is directly proportional to your understanding of how that application is built and structured

🛣The Ultimate Roadmap

I have crowdsourced the majority of the roadmap from multiple GOATs and legends in this field, it is organized in a way to cover all rudimentary topics that one needs to know in order to master in this field.

Note: I will be following this roadmap and will be updating as required in the process and will be posting links to my threads on each of the topics I learn and resources at the end of the thread which will help you to get along which would be like a TLDR; of each concept. Also will write an estimated time to complete that concept

All of the resources I would be posting later with the links will be 100% free openly available to everyone.

Note to mention: All the threads, text, images, videos are crowdsourced I am not the creator of any of them, I just try to find good resources already available over the internet and write a summary(TLDR;) on that topic. All the rights lie with the original creators/publishers.

Basics(🤔Understanding of below concepts is enough to go to next step)

• Linux & Bash commands (10 minutes)
• Networking concepts (8-10 minutes)
• How a Web Browser works (10-15 minutes)

  Also check this for more technical explanation

• DNS 👆
• HTTP Protocol 👆
• HTTP Request and Response 👆

  👆 meaning same resource as above

• HTTP Caching (5 minutes)
• RPC Protocol (5 minutes)
• Browser’s developer tools (10 minutes)

  Amazing chrome dev tools cheat sheet

• JavaScript(atleast Couple of days)
• IDE's
• Version control systems such as Git
• node.js
• Package Managers (Like npm, yarn)
• Object-Oriented programming - check out resource at the end of this thread
• Python

Essential Blockchain Basics (✔️Mandatory)

• Distributed Ledger
• Bitcoin Whitepaper - This is an explanation resource, please feel free to check out the original paper lined in the blog
• Asymmetric Cryptography
• Elliptic Curve Cryptography
• Double Spending problem
• 51% Attack
• Other basic terms used like web2, web3, blockchain, decentralized, distributed, Defi, NFT, etc., (Can be found here)

Basics of Ethereum (✔️Mandatory)

• What is Ethereum
• Why Ethereum is termed as World Computer
• Why is it different from previous blockchains
• Ethereum Protocol and how it started
• Ether Currency
• Transactions in Ethereum ecosystem using wallets like metamask etc.,
• Types of accounts (EOAs vs contract accounts)
• Ethereum Clients, Nodes, and Wallets
• Public Key vs Private Key
• Mining
• Gas
• Different types of networks in Ethereum (Mainnet, Testnet, etc)
• Block Explorer
• EIPs and ERC standards
• Most used ERC20, ERC721, and ERC1155
• Turing Completeness
• Ethereum Virtual Machine
• Smart Contracts
• Ethereum High-Level Languages (Solidity, Vyper, LLL, Serpent)

Solidity (✔️Mandatory)

• What is Solidity
• The famous Remix IDE
• Data types in Solidity
• Predefined global variables and functions
• Error handling in Solidity
• Contract ABI
• Lifecycle of a Smart Contract
• Compiling, Testing & Deploying of Smart Contracts
• Interacting with deployed Smart Contracts
• Interaction using an external library(web3.js,ethers.js)
• JSON RPC

Frameworks for Ethereum Development (🤔For ease of development)

• Truffle Suit (Truffle, Ganache, Mocha, Drizzle)
• Brownie
• Infura
• Hardhat
• Openzeppelin
• Dapptools

Frontend (! -> ✔️Mandatory)

• HTML, CSS !
• Javascript !
• React !
• Vue.js
• next.js
• tailwind.css

Professional level (✔️Mandatory to know if you wish to continue to work in this field)

• Distributed Storage Systems (IPFS, SWARM, storej)
• ENS
• Defi
• NFT
• Chain, Side Chain
• Polygon, Solana, BSC(Now called BNB chain)
• L1/L2 Solutions
• Plasma
• State Channels
• Rollups - ZKRollup, Optimistic Rollup
• DEX
• MEV
• Lending
• Farming
• Stable Coins
• DAOs

Future of Ethereum

• ETH2.0(🤔NOW called Consensus Layer)

📻 Further useful resources

• Mastering Ethereum Book
• Smart Contract Programmer
• Week in Ethereum News
• The Daily Gwei to stay updated

NOTE: Next steps are required only if you want to master, I suggest you go through them even if you are not into security/auditing because having knowledge of vulnerabilities will help you code better.

To become a smart contract auditor or security specialist in the blockchain you have to complete the whole roadmap including the below and should complete at least one CTF mentioned below

🔐 Smart Contract Security(✔️First point is very needed to master, rest are to help you in the process)

1. Most common Vulnerabilities in Smart contracts:- What is Reentrancy, What is Junk code (Code With No Effects), What is Unencrypted Private Data On-Chain, What is Integer Overflow and Underflow, What is Floating Pragma, What is Unchecked Call Return Value, What is Unprotected SELFDESTRUCT Instruction, State Variable Default Visibility, What is Uninitialized Storage Pointer, Use of Deprecated Solidity Functions, DoS with Failed Call, Authorization through tx.origin, Signature Malleability, Weak Sources of Randomness from Chain Attributes, Lack of Proper Signature Verification, Missing Protection against Signature Replay Attacks, Insufficient Gas Griefing, DoS With Block Gas Limit, Hash Collisions With Multiple Variable Length Arguments, Message call with a hardcoded gas amount, Oracle Manipulation.

2. Visualization Tools (Solidity Visual Developer, EVM Lab, Surya, Solgraph, Piet, Ethereum-graph-debugger )

3. Linters and formatters (Ethlint, Prettier + Solidity Plugin, Solhint)
4. Static and Dynamic Analysis (Oyente, Octopus, Vertigo, MythX, Mythril, Slither, Echidna)

CTF's to Look at(✔️Mandatory)

• Openzeppelin’s Ethernaut
• Damn Vulnerable DeFi
• Capture the Ether
• Paradigm CTF
• Smart Contract CTF

💵Bug bounty platforms(🤔community)

• Immunefi
• HackerOne
• code4rena

📻Security related resources to stay up to date

• Rekt News
• Blockchain Threat Intelligence Newsletter
• GOAT samczsun blog
• Bad Things - Crypto Security

That was it from my side, I hope and wish you all the best for your success, This is also part of my Round 2 #21DaysOfLearnandShare Challenge. If you wish to join the challenge and learn along with me just connect and ping me on Twitter @0xViking

I would like to take the opportunity to thank a few people from whom I inspired and compiled this roadmap and resources.

• @officer_cia
• @Asm0d3us
• @tinchoabbate
• few more, will add in near future

❤️‍🔥 Liked my work? would like to support me?

If you think my work has added some value to your existing knowledge, then you can follow me on Twitter @0xViking and share this article with others whom you think would be a valuable asset for them

What is this 21DaysOfLearnandShare and why I think this will help everyone to make anything new as a habit.

I am 0xViking, a budding developer in web3 and want to learn a lot of things but majority of time I didn't complete learning that new technology which I started.

So this is what I feel the best way(#21DOLS) to make a new habit which came out after some thought process after referencing 100DaysOfCode .

How it works: Pick what ever topic you are planning to learn but never started till now or started but left after few days. Commit yourself to the challenge #21DaysOfLearnandShare #21DOLS on twitter. Later everyday share on twitter what you have learned and the resources that helped you with the hashtags explained later in the article.

Rules:

• Tweet to commit to the challenge!

• Plan: Formulate what you want to work on during the challenge. It might be - coding, new technology, design, sports. Don’t spend too much time planning, but having a plan like this will help you on your path. From today on, for the next 21 days, tweet your progress every day using the #21DaysOfLearnandShare #21DOLS hashtag

• Work at least 90 minutes per day with a 20 minute learn and 10 min documenting resources for sharing

• Other than me tag someone else who is willing to learn something new or can support you along with in the journey. He/She can also ask you about the progress to make sure you are accountable for something you started.

So what is the 90 Days thing then? Above challenge is something that helps you make a new habit. Just learning something for 21 days will not make you an expert in it. Then how do you become an expert in something?, Ok to be honest being an expert level with in quite few days won't happen but rest assured you will be in top 1 percentile in the topic you have chosen. Do the #21DOLS in rounds like Round 1 of 21 days, Round 2 of 21 days etc., for at least of 4 rounds. Which makes a total of 84 days, adding the breaks of 1-2 days after each round makes a total of 90 days. This process will help you master any topic and make it as lifestyle.

Official Hashtags you can use for the Challenges:

#21DaysOfLearnandShare

#21DOLS

#R1D1 , #R1D2 ...... #R1D21 -- Round1Day15, Round3Day6 etc.,

#21DOLSweb3 -- Topic you choose

Benefits:

• You can be accountable to complete the challenge
• Not only learn, you help others to learn by sharing
• You can check the resources shared by other which might be useful to you on the topic you choose

Have you implemented the process and succeeded? "To be honest, No, I didn't and here I am committing to this challenge in the topic "WEB3" and tagging thatguyintech to join on my journey"

Credits to #100DaysOfCode - website @ka11awaay for starting this revolution.

This is my first blog, Sorry if there are any mistakes and help me correct if you find any. Thanks for joining me. Hope this helps me and everyone who joins along