DEV Community: Eda

How to get a job in Web3

Eda — Mon, 23 May 2022 19:52:06 +0000

Last week I asked, "who wants to work in web3?" on twitter. The engagement on the tweet was mind-blowing; it got so many responses.

It seems like so many are considering a switch and have some questions. So, I decided to gather some questions and answer them here, as well as share some tips on how I got my job.

Now, worth noting that these are based on my and some of my friend's experiences only. They are by no means the norm, and I am not an expert in this field. However, with this disclaimer, I hope that they will help you understand the web3 space, and the tips can help you move in, if you are interested.

So let's get to it!

My Experience

I started my job in web3 almost three months ago. You can head over to my article on moving to web3 for more insights on my career change. In this post, I want to lay out some tips based on my experience.

The platform

Interestingly I got all my job offers on Twitter.

Coming from the traditional tech world, I was used to the path of applying through Linkedin, then getting a few online tests and finally moving to the interview stages. In web3, the process was not like the traditional route. I think that's why it seems like a scary process, but the reality is that it's not hard it's just different. You'll need to take a few steps yourself and be more creative, since there isn't a clear path just yet.

I also hear that many other people that got their job from Twitter or Discord. These places are great for meeting people with similar interest, and you may be speaking to a founder of a protocol.

Alongside Twitter dm's, there are many job boards on Pallet that people are launching and sharing on Twitter. You can learn about these job boards on Twitter and head over to apply to jobs over there.

I've also started my Job Board. I pick the companies and jobs that I find interesting. Additionally, you can join my talent collective, where I try to match people with the companies; it's completely free so if you're looking to transition we could work together to find you a match! 🙌

Interest in web3/crypto

Okay, so we've covered the platform. Now, let me cover some tips on standing out. First, whichever job role and level you are applying to, you should be interested in the web3/crypto space. It's a very fast-paced space, and you'll be spending a lot of time learning together with your team, so having a passion for the area is a must.

You don't need to be an expert (is there such a thing as a crypto expert anyway), but you would need to demonstrate some sort of understanding of crypto. So make sure to have a crypto wallet, have an understanding on DAO's (preferably be part of some), have a look at NFT's etc.

In my case, I had already started to share my web3 journey through my blog and Twitter. So I was able to show my passion and learning journey through these places.

Building your Portfolio

Firstly, if you're a developer looking for a job in web3, there are many ways you can build your portfolio:

Hacaktons (virtual and irl)
Bounties
Grants

With these, you can feel the technology, build stuff yourself, and meet the teams without moving full time. It's a great way to get an understanding of the space.
Make sure to check out Speed Run Ethereum by Austin Griffith when building your portfolio. It's one of the best resources I've found that gives you an understanding of what and how to build decentralized applications, while add some creative elements yourself.

Depending on the level you are applying to the strength of the portfolio will likewise vary. If it's a senior roles the projects expected will be different than a entry level job.

Secondly, just like technical roles for non-technical roles you'll need to have a portfolio. If you're into video creation then having a collection of related videos, if you're a community builder a way to demonstrate your activities in communities, if you're a writer some articles on the space etc.

It's similar to demonstrating your understanding with a certificate or online tests for the traditional tech world. The difference is that you'll need to be more creative since there isn't a straightforward method.

Wrapping Up

Overall, it's not hard to get a job in web3; it's just a new and different way than the traditional one. You'll need to be creative and show some related work. Having done some work before will make you stand out in the interview and also allow you to understand the space before moving full time.

Q & A

1. "I want to, but I don't know where and how to start."

This was one of the main questions I got on the topic. Here's my previous post on how to get started in web3. Let me also add a small recap over here.

If you've heard about web3 and are interested in learning more, I'd suggest you start using the products and see what it's all about. You can start by setting up a crypto wallet on Metamask. Next, you can checkout NFTs on Opensea. Finally, look at ENS (these are the .eth you may have seen on Twitter). These are some basic starter steps to understanding the technology. It's a new area, and a lot is going on, be sure to try it out for yourself.

Once you've got a grasp of the tools, start learning more about what's happening. Read articles and newsletters, check out podcasts, head over to the white papers and get a better understanding.

Then last but not least, if all these were interesting, get involved with the communities. The communities are in the heart of web3. Join the Discord servers and look for projects that you can join, check out the grants and the hackathons. There are many different ways to get involved and start doing.

2. "I've been trying to get into the space, and I've done some tutorials on YouTube and all, but getting to the next level and working on projects is where I want to get to now, but I've not got much of an idea of how to do so"

One thing that worked out for me was building the projects. It's vital to get hands-on 🙌 many learning paths are based on building projects which I'd suggest you check out.

Make sure to look at:

Speed Run Ethereum by Austin Griffith: It's a curriculum for developers to follow a path of projects to learn about development on Ethereum. I've written an article about scaffold-eth, the toolset to build Ethereum applications by Austin. On speedrunethereym you start out with Scaffold-eth and then add different elements to it to complete the projects. I've completed the DEX projects and onto the multi-sig. Worth noting that one of the most powerful parts of the curriculum is that you'll be learning what you can do with Ethereum and how it works.
Buildspace: they have many projects where you have to get to the building. I was super surprised after my first buildspace project on what I could build over the weekend. Here's my article on building an NFT collection after completing the project on Buildspace. Today they have lots more different projects, from building a web3 app on Solana to making your own DAO.

These will give you some developer experiences and show you what you can build in web3. You can make your portfolio with these projects and try to see how you can add extra elements to go beyond the tutorial.

Once you've got the experience from these projects, check out different grants and hackathons if you want to continue to add more projects to you portfolio.

3. "Without having any experience in it, can I get a job by doing some sample projects?"

Yes!! That's the best way to get a job in web3. Start building and sharing your projects. Just like you'll need a portfolio or demonstrate your understanding in any job, sample projects will help you do this and can lead you to jobs (without in needing to apply).

Don't take my word for it; checkout Rodrigo, who's been sharing his progress and getting multiple offers!

Start learning and sharing your journey. Then, once you build projects, write articles, threads on Twitter, make videos etc., You can use these to apply for jobs or even better jobs can come to you!

Additionally you make sure to have a lot at the Grants! There are so many people getting jobs after completing a grant project with the team. It allows you to meet the team and learn more about the project without moving full-time. You may get the opportunity to move full-time afterwards!

4. "Will a beginner get a job in web3?"

Yes! And I think that web3 needs more beginners. There have been many new people entering in the past few months, myself included. It's pretty overwhelming once you first discover and start learning web3. I think beginners know this the best and can work towards making it simpler for anyone getting in. With new perspectives, we could start making it more straightforward.

It is important to mention that the jobs you'll get as a beginner will most probably not be senior protocol engineers. Those are the jobs that generally require more experience in the field. You'll need to demonstrate a high understanding for senior roles and show you related job or project experience. But starting in a role as a technical writer for example could be an option. Then while learning more about the technology, you could move into a software engineering role.

5. "What are the best resource to learn web3?"

I will answer this for developers getting in. Firstly, Francesco has a list of free web3 resources, which you can find over here. I've found it to be very comprehensive and helpful.

I want to specially mention some people and resources I've used and have helped me massively:

Nader Dabit: Youtube and articles: Nader has many walk-through tutorials, including Full Stack development with Ethereum,
Patrick Collins: Patrick has a complete guide on becoming a developer in web3.
Austin Griffith: Austin has created many tools including, Speed Run Ethereum which is a roadmap for developers getting into web3 to follow a path of projects. It's a great way to understand what you can do in web3 alongside the syntax.
Developer DAO: Developer DAO has been one of the most impactful communities for me. It's been the main driving force for me to learn and share my journey online. I had entered the community early on when the DAO was starting out. Today, you join in and can access many different projects spanning from creating educational content, developer conversations, and real-life meetups.
Buildspace: it is a platform for developers to learn about web3 by creating projects. They have a huge community of web3 developers and work with companies with job opportunities for web3 builders.
UseWeb3 by Wesley: It's a curated list of resources from books, tutorials, articles - everything web3. I'd highly recommend checking it out and following on Twitter for the week's most-read posts to understand the most recent trend.
Cryptozombies: you can learn how to make smart contracts solidity interactively.
LearnWeb3DAO: they have different tracks for developers learning about web3. It's a
great educational resource to learn and connect with others knowing. Learning is better when done together :)
Web3 University: it has curated articles to learn about blockchain development. You can find articles from the people I've mentioned and many more.

I hope this was helpful and that I was able to answer some of the burning questions. Please let me know if you have any comments or questions!

See you in the next post 👋

Building with Polygon

Eda — Mon, 21 Mar 2022 12:06:35 +0000

With increasing demand Ethereum has become expensive and slow. This created an urgent need for scaling solutions. That's where Polygon comes in.

Simply put, Polygon is an Ethereum scaling platform. Polygon has seen exponential growth over the past year. It's easy to use and doesn't sacrifice the security and decentralization provided by Ethereum. It uses Ethereum's technology, so developers can jump onto Polygon and mainly use the same code and tools.

I'm very impressed by the Polygon Ecosystem. I've been using and building with Polygon; it's time to put my findings into this post.

Here's what we'll be covering:

Why do we need scaling solutions on Ethereum
What is Polygon?
How to create a smart contract on Polygon

Introduction

Why do we need to scale?

Firstly, blockchain is a shared and immutable ledger. On the blockchain, the information is distributed among multiple computers which work together to provide the underlying infrastructure.

Ethereum is a smart contract platform that is built using blockchain technology. Ethereum has become increasingly popular.

First, Decentralized Finance(DeFi) got many people excited about crypto and onboarded the adventurous finance people onto the ecosystem. I missed that stage; it was called "DeFi summer."

Then there was the NFT wave. It was a period that onboarded and is continuing to onboard many to the crypto world. These are also known as images worth millions.

With such demand, scalability becomes a huge issue. Ethereum becomes slow and expensive. The Blockchain can only handle a certain amount of transactions at a specific time, so when many people submit a transaction simultaneously, this creates congestion.

We can summarize the issues with Ethereum as below:

Low throughput
Expensive, not user friendly.
Limited options for specialized apps. It's a general-purpose blockchain; thus, it's not optimized for specific use cases.

The Ethereum team is working on methods to scale the Blockchain. One of the main scaling updates is coming with The Merge. However, Ethereum will still need a set of solutions running on top even with the updates. The vision of Ethereum is to create a solution on a global scale; this cannot be achieved by a single solution, as all systems will have their limitations. Multiple solutions can live in parallel to provide the best experience for the users.

This is where scaling solutions come into play. Scaling solutions are solutions built on top of Ethereum (also called Layer 1) to solve the pain points. Here's a great animation video on scaling solutions.

Polygon started with a vision to bring mass adoption to Ethereum. It wanted to make it easy for developers to build and convenient for users to use. It has quickly become one of the most popular scaling solutions built on Ethereum.

What's Polygon?

Polygon is a full suite of scaling solutions for Ethereum. It makes it easy for developers to build and users to use. Here is the description from the Polygon website:

Polygon is a decentralized Ethereum scaling platform that enables developers to build scalable user-friendly dApps with low transaction fees without ever sacrificing on security.

Polygon is both more efficient and affordable than directly using Ethereum. Two critical needs for adoption. It leverages the Ethereum technology and has solutions that talk to the Ethereum Network.

Three developers founded Polygon in 2017; the project was initially called Matic. Even though it has rebranded to Polygon, the token is still called MATIC. Matic is the cryptocurrency used to pay for transactions on Polygon. Here's a great video on Polygon with animations.

Today there are over +7000 Applications that use Polygon, from popular Decentralized Finance apps to Gaming Applications. OpenSea, Aave and Metamask are some examples.

So, what really is it?

It's a set of platforms and protocols to scale the public blockchains. It set out to offer a solution for Ethereum's scalability issues.

Polygon utilizes the main Ethereum code. So, developers can move their projects onto Polygon with just a few changes.

Polygon is not 1 or 2 scaling solution(s), but instead, Polygon is creating an entire ecosystem of Ethereum scaling solutions. This is because different applications want different things. With Polygon, developers can choose the parts that fit the need of their application; since every choice is a trade-off. This way, applications can prioritize the features they need the most. For example, if you're developing a finance application, you'd want to optimize for security. But on the other hand, speed may be one of the features to prioritize for a blockchain-based game.

What are the Scaling Solutions?

Polygon has different solutions; let's briefly talk about the most popular Polygon offering, that is the Polygon Proof of Stake(PoS) chain.

Source: Polygonscan

Polygon PoS is a scaling solution that uses side-chains for transaction processing and Plasma bridging framework for additional security. It's a solution that compliments Ethereum and achieves high speed and low cost without sacrificing the security from Ethereum itself. Developers can deploy their contract to Polygon, and users can use the Polygon PoS chain instead of directly interacting with Ethereum.

The PoS chain is not the only offering; there are other solutions on the Polygon Ecosystem.

Polygon Hermez: solution mainly used for Payments that uses "zero-knowledge proof" (ZK) technology
Polygon Edge: framework for building Ethereum-compatible blockchain networks
Polygon Nightfall: privacy-focused Ethereum scaling solution for enterprises

Check out more on the Polygon website

Build a Smart Contract on Polygon

Good news: It's just like building on Ethereum! There are very few changes needed. So if you're an Ethereum builder, you are already a Polygon builder. 😎

In the next part, we'll be deploying a smart contract to the Polygon PoS chain. It's the same steps & code from my "Intro to dApp's: Create your dApp backend w/Solidity" post.

Project Tools

Metamask Wallet: Crypto wallet.
Alchemy: Ethereum developer platform. We will be using the Alchemy API to interact with Alchemy's Polygon PoS infrastructure.
Hardhat: Ethereum development environment. It comes as an npm package.

Prerequisites

Choose your IDE and get the "solidity extension." I am using VS Code.
Create an account on Metamask and switch to the Mumbai Test Network.
Get your Alchemy API key. You will need to create an account on Alchemy. When logged in, create an App on the Polygon Test Network(which is Polygon Mumbai). Your App settings should look like the following: Once you've created the App, head over to the app details and get your HTTP URL by clicking "view key" on the top right.
Install node.js.
Get some Mumbai Test Network Tokens. You can get some here.

Building the Smart Contract

Create a project folder and head over to its directory. Install hardhat.

 mkdir eda-sample-smart-contract
 cd eda-sample-smart-contract
 npm init -y
 npm install --save-dev hardhat

In your project directory create a hardhat project by running npx hardhat.

 $ npx hardhat

The setup wizard will show up. Click enter throughout and keep the default options. Hardhat will create a sample project and install the dependencies for you.
Open the project from your code editor. Under the 'Contracts' folder, you should see the default Greeter.sol file. ".Sol" is the file extension for the solidity language, and it's our sample smart contract. I've added the smart contract below with some comments to explain what's going on.

 //SPDX-License-Identifier: Unlicense
 pragma solidity ^0.8.4; // solidity version for the compiler, must be the same as in the settings file

 import "hardhat/console.sol";

 // create the smart contract 
 contract Greeter {

     // create a variable called greeting that will be stored in the contract 
     string private greeting;

     constructor(string memory _greeting) {
         console.log("Deploying a Greeter with greeting:", _greeting); // print to the console 
         greeting = _greeting;
     }

     // create a function to give the greeting message 
     // public: functions are public by default, anyone reading from the contract can call it
     // view: the function will not modify the state, it will only return a value
     // returns: the function declaration tells the type of the return value, here the return type is a string 
     function greet() public view returns (string memory) {
         return greeting; 
     }

     // create a function to change the greeting message 
     function setGreeting(string memory _greeting) public {
         console.log("Changing greeting from '%s' to '%s'", greeting, _greeting); // print to the console
         greeting = _greeting;
     }
 }

Here is where the code starts to change from the Ethereum Project. First, you will need to modify the networks in the hardhat.config.js file to be on Polygon Test Network, the one we will be using is the: Mumbai Test Network. Next, get your Alchemy HTTP URL; it's needed to talk to the Mumbai Test Network from the smart contract. Add it to the hardhat.config.js (see code snippet under step-6).
Add your metamask private key to hardhat.config.js. You can get you private key by clicking Account Details --> Export Private Key from your Metamask extension.

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

 module.exports = {
   solidity: '0.8.4', // make sure the version matches the one in smart contract file 
   networks: {
     mumbai: { // change the network to the Polygon test network 
       url: ' ', // Mumbai testnet url 
       accounts: [' '], // metamask privte key- NEVER SHARE THIS!! It has access to all your accounts
     },
   },
 };

We need to take our contract from our local machine and put it onto the Mumbai Test Network. For this, we will use the sample-script.js file under the 'Scripts' folder. (It's usually called deploy.js; but let's leave it as is for this sample project.) Run the command below to deploy the contract to the Mumbai Test Network.

 npx hardhat run scripts/sample-script.js --network Mumbai

🎉 Once you see the details of your smart contract on the terminal, it means that your smart contract is deployed onto the Mumbai Test Network!

The smart contract address is printed on the terminal. Head over to Etherscan for Polygon TestNet. Search for your contract address, and you'll see the details.

What's next

Check out the Polygon developer page for developer resources to continue building. You can find full suite of resources from the Polygon Team and also curated community resources.

Worth mentioning that Polygon has a Developer Support Program to help developers in the ecosystem. Benefits include getting early access to grants and technical guidance. I haven't been part of the program but could be interesting to check out!

The Polygon has team has always focused on adoption, and they've become one of the most popular platforms for developers. I'm excited for what Polygon is doing and look forward to following closely!

If you have any questions or comments, drop them below, or reach out to me on Twitter! 👩‍💻

My Web3 Journey: Day 100 of #100daysofWeb3

Eda — Fri, 07 Jan 2022 08:46:39 +0000

It's day 100. Oh dear, where do I even start?

Honestly, I would have never imagined I'd be getting into the web3/crypto space at the beginning of 2021 (or at any point in my career). But here we are, 100 days into the web3 challenge that completely got me hooked.

Now, this is my story. I'm by no means an advisor of any sort, and I failed terribly on the way. Nevertheless, I want to share my journey, focusing on what I learned and takeaways.

More down the rabbit hole web3

If you follow me on Twitter or read my articles, you already know that I am pretty much overly attached to web3 at this point.

Where it all started

How I got to web3 is not magical, it's not the promises or community. These are why I'm still here, but I got in as an investor (sounds way cooler than just saying money😀). Then I learned about the technology and community. I was fascinated.

The challenge: #100daysofCode / #100daysofweb3

I started the challenge to learn and code every day using web3 technologies. I had already been learning about web3 for some time, and being a developer, I wanted to understand the technology stack and build myself.

If you haven't read the first half of my journey, I'd highly recommend you to jump to this post. It covers how I got into the web3 world in detail and what I did throughout the first 50 days of the challenge.

Important to mention, it wasn't purely a coding journey for me. I became very interested in technical writing (still surprised that I have such a passion for writing) and started to create content about web3. You can find my posts here.

Worth mentioning is that I did not code or write 100 days straight. I gave breaks, and I'd highly recommend taking breaks on the way because it gets very overwhelming pretty fast.

Why I'm still excited about web3

After the first 50 days, I continued to learn about the web3 landscape. I was learning new technologies every day. This part is the most interesting because these technologies made me realize how siloed I'd become. The challenges and focuses were a lot different than what I was used to being in the web2 world.

This is one of the main reasons I am thrilled to be in the web3 space; I'm always learning and pushing myself. Of course, there are complex problems in the web2 world, but no denying that web2 has invisible boundaries on what you can do and the level of experiments, especially in large cooperations.

On a related note, I wrote a blog post about why I'm excited about web3 in detail; you can check it out here.

Building

In the first 50 days, I created basic smart contracts and learned solidity. The second half looks a lot different. I learned more about the technology stack and tried out protocols to extend my app's functionality; now, my contracts had more going on. I used technologies such as Chainlink, The Graph, Arweave, Ceramic Networks and many more.

Here's a post by Nader covering the web3 tech stack; it's the most comprehensive guide I've come across on this topic. I've bookmarked this post and frequently go back it to because 100 days is not enough.

I've added the resources I used below; there are lots!

The community

Another part that I wasn't expecting was the community aspect. I wasn't part of the web3 or tech Twitter community before starting or, to be honest, any internet community — and didn't plan to be. Now I can't iterate how important the communities, web3 Twitter and Developer DAO, have become.

It can be overwhelming in the web3 world because there are so many new things to learn, the crypto space has a very negative narrative in the outside world, and it's in the experimental stages with no clear guidelines or regulations.

These don't seem like that big of a challenge when you're part of the community. In my case, I was doubting myself and couldn't make bold decisions but seeing so many people around me being excited and creating cool projects made me want to continue my journey. Can testify that social proof is a very powerful influence.

I've come to realize that the web3 community is very small at the moment. Many people tell me that I'm also early (which I now agree with); getting in early on is really beneficial because you can connect with people you take as an example.

To highlight the effect of internet communities, I want to take a moment to mention Constitution DAO. I never thought I'd ever want to buy the US constitution. But somehow, I contributed to doing so and followed the auction with such huge excitement. Basically, a DAO (decentralized autonomous organization) was formed to buy the US Constitution at Sotheby's. The DAO raised over 40 Million Dollars in less than a week! The DAO didn't end buying the constitution, but nevertheless it showed me that DAO's are a thing and can bring together many people to coordinate and work together for a common goal.

The downside

Now I don't appreciate hyped articles and don't want this one to be like that. No space is perfect, and web3 has its flaws. I mentioned the downside of the space in both my previous article and the 50 days article; you can find detailed overviews in those posts. With that, let me also add a short recap here:

No regulations: the space is experimental and at its infancy stages. There's no regulations and/or guidelines to protect users or creators.
Too much going on: it can be hard even to start because there are too many new technologies to learn. From 100 days ago, it seems that there is way more beginner content; I have listed them below.
Monetary Incentives: people have financial incentives. Make sure to understand the motivations of the people and the platforms. Is it for the money or the tech?
The Language: there are too many abbreviations and new terms. Even "web3" itself was a term I learned after getting into the web3/crypto world. Disclaimer: no one calls web2, web2 in that world.

Web3 has many sceptics. I definitely think new ideas should be challenged. However, I'm not a big fan aggressive nature of comments in the space.

My mistakes & takeaways

I am learning, teaching and having fun. Again this is my story, and here are some takeaways from my #100daysofCode/#100daysofweb3 challenge:

Create and build: create content, build apps, write, read, basically do anything you're interested in. Everyone is new here, don't wait until you learn about everything because no one can know everything! It took me a lot of time to become a "doer", but it has been one of the decisions. It will also bring you many opportunities. I didn't apply for a single job and got more offers than I would ever imagine. No one reached out from my LinkedIn profile; they didn't even know my last name or background. But, I was creating exciting content.
Your content engine is key: it's all about the content you consume. The podcast, the tutorials, articles all make up what you learn and produce. Make sure to find the content that you enjoy the most and can get the most out of. There were days where I was on Twitter, just browsing for way too long to find some interesting content. Now I have a clear content engine, which guides me to build my next app or create my next post. It's not a tweet that I may come across on Twitter after realizing I spent hours reading about a random argument on Twitter.
Take breaks: I was overwhelmed. I was in front of my pc for a few days, just staring and not having any motivation. It's not sustainable to cancel all your activities and lock yourself in your room. That's what I was doing. Now I have realized that those events and conversations inspire me and give me ideas and new perspectives. You can go out for a run, meet your friends or read a sci-fi book; doing things outside of web3 will not put you behind. In the country, it'll make you relax and motivate you.
Prioritize: The web3 space moves quickly. Every day there is something new. You don't need to keep up with every news or know every technology in detail. There were days where I tried to keep up with everything going on and other days where I felt that I knew nothing looking at the pile of technologies I hadn't even heard of. One of the essential things is prioritizing and focusing on a single area. Once I started to do that, I became more confident that I was making progress and knew what to do.
Don't forget to document your progress: I wasn't as structured as I wanted to be, the projects were more organized but my learnings were all over the place (notion, word, notes etc.). I'd suggest taking a structured approach because I found myself spending a lot of time finding and reviewing my notes.

Would I recommend starting the challenge?

It wasn't an easy challenge, but the answer is a definite YES!

Modify the challenge to suit your style best. For example, I gave breaks, and I didn't post on Twitter every day. If you like to share every day, that's perfectly fine, but it put extra pressure on me. Additionally, my challenge was not only to build and ship products but it was in between building projects, creating content and learning about web3.

It also doesn't matter what level you are on with coding or web3; this is for personal development. It's really about what you achieve over a specific time, not how you compare to others.

I learned a lot and feel very proud of the outcome; with that, there's so much more to learn!

How to start in the web3 world?

Most of my recommendations from day50 have not changed; I did expand on the content.

Start by doing
I cannot iterate how important it is to understand what you can do in the web3 world before getting in. Do anything related to crypto but DO it. Don't just listen to a podcast or read a blog post.
- Setup your own wallet, exchange some tokens, stake some assets, get an ens name etc.
- Check out RabbitHole, an educational platform focusing on teaching how to use web3 applications.
Read, research, repeat
- Look into the blockchains and protocols websites to get more information.
- UseWeb3 by Wesley. A curated overview of the web3 world. I highly recommend bookmarking this. It has most of the resources I have included here and many more.
- Web3 university: a library of Web3 educational resources
- Podcasts: Bankless, The Defiant, RabbitHole and Real Vision.
- Newsletter: Not Boring Capital Newsletter- It's not only about web3, but most of the pieces are.
- Here is a great web3 reading list by Gaby.
Building
- Buildspace: Learn about web3 by creating projects, they continue to expand and add new projects! They now have Solana and Avalanche projects.
- Nader Dabit: make sure to follow Nader's youtube. He has live streams deep-diving into the technology and the code with many people.
- Scaffold-Eth: It's a tool by Austin Griffith to build decentralized applications. There are some quests here that you can follow along.
- UseWeb3 Tutorials: a curated list of many tutorials and guides
- Web3 university: a library of Web3 educational resources
- Web3 Twitter; here are some of my favorite builders and communities in the space.
Get Involved
There are so many different areas you can get involved in. Join a DAO, be active on Twitter, reach out to people. It's not just smart contract experts or developers that can get involved, but there are different areas from marketing, writing, designing etc.

Find and learn about DAO's on DAO Central
Come and join Developer DAO. We're a community of web3 enthusiasts learning and building in the space.

If you love what you do and having fun, there are many employment opportunities:

Check out this article by Kacie; it's a great overview of what opportunities and how to prepare
UseWeb3 Job Board
Follow the projects and people on Twitter, create a project and reach out to the teams! In the web3 world, Twitter is the new Linkedin. Here's a thread to see who is hiring right now!

So what's next for me? Well, I'm not going anywhere! You'll be hearing more of my adventures in web3 👩‍💻

Thank you for reading! If you have any questions or comments, drop them below or reach out to me from Twitter!

Why I'm excited about web3.0

Eda — Wed, 29 Dec 2021 06:59:04 +0000

You may have heard of web3. It made quite the buzz this year; it seems like people either love it or hate it. Honestly, I didn't know what web3 was until I somehow ended up in the web3 world itself. I didn't even know that the traditional tech world, which I am in, is called the web2 world (ps: no one calls it web2 there).

After months of experimenting, learning and building in the web3 world, I decided it's time to explain how I see web3, why I'm excited about it, alongside some of the challenges.

The background

What even is web1 and web2?

To understand web3, we first need to understand the evolution of the web. The web has evolved a lot since it got into our lives: web1, web2 and web3 as terms to describe the different eras.

Web1 is the first web era, also known as the read-only web. Web1 roughly covers the years between 1990-2005. During this period, users were mainly consumers of the technology—an era when static websites were a thing.
Then came web2. Web2, the read-write web, started around 2005 and is mainly used today. The web became a place where anyone can create content. It became a new collaborative and interactive environment. Social media has been a significant catalyst for web2. It's never been easier to upload a cat photo to Instagram, celebrate birthdays from Facebook and chat via Facetime.

So, it went from only super shady coders doing something on web1 to making it so easy that now everyone can easily use web2.

Here's a great intro video for the eras of the web by Whiteboard Crypto -What is Web 3.0? (Explained with Animations)

What are the issues with web2?

Web2 is highly centralized. In web2, large companies own servers that provide messaging, searching, storing etc. These companies have complete control and ownership over the services they provide.

You need to agree to the terms and services to use the platforms. This makes sense as the companies pay to operate these servers and provide you with certain services. That been said, with every term and condition agreement, we give the ownership and control of our data. Companies use this data to monetize their platform; it's fair to say that many large companies solely exist to collect data. Not to get into many buzzwords, but this is also called the data economy.

Aside from the issues with companies using and selling our data, these entities are the primary targets for hackers. Cyberattacks and data breaches are inevitable when there is a single point of failure.

Last but not least is the control that the centralized cooperations have. They can change the product and the features anytime, affecting others using their platforms. Companies also have the power to censor and block any account.

In this environment, we see web3 emerging.

How did I get into web3?

Before moving on to what web3 is, I want to explain how I ended up here. Because quite honestly, it wasn't due to the issues in the web2 world. I got in as an investor (sounds cooler than just saying money), but I saw all the prices going up and tried to give it a go. You can read more about how I got into web3 in this post. In short, after getting in for the money, I fell in love with the technology and community. I started to learn, build, contribute, and that's how my web3 journey started.

The way I see it is that there are these problems in web2, but there's no denying that it's a working system and has great benefits. The disadvantages feel like something most people accept without diving deep when using web2 platforms. People love to use Instagram, TikTok, Google, Twitter etc. I did too, but once I learned that an alternative exists, I started to dig deeper and ask interesting questions; that was a turning point for me.

Web3

What is web3?

Web3 is mainly described as the decentralized web; it's still a term under construction.

Here is a more detailed definition that I enjoyed from this article by Dave Peck & the PSL Team:

“Web3” is the name* given to a suite of peer-to-peer technologies — particularly blockchains and distributed filesystems (like IPFS)— that are used to build modern “decentralized apps”, or dApps.

Essentially it's a group of technologies that are all decentralized and used to create decentralized applications.

This means that in web3, there isn't any single company in control but instead individual contributors that own and control the underlying technology stack. So basically, now service providers and users become the same person. Decentralization takes away the power from a single entity.

Why would anyone want to become a service provider?

Now, this is where cryptocurrencies come into play.

Cryptocurrencies are the economic incentives given to network contributors (aka service providers). Each contributor provides resources to the network and gets rewarded in cryptocurrencies. Anyone can become a service provider, like you and me.

Consumers pay with cryptocurrencies to use the services. So it's a different economic relationship from the traditional web world that we know. For example, in web2, a user might pay AWS or Microsoft for cloud services; in web3, the money goes to the network participants.

There is value for both the creator and the consumer of the network. It's a relationship based on the protocol rules without any entity in between.

What about this "blockchain" thing?

Today we mainly see the use of decentralized blockchain technology for building web3.

Now two important notes:

A blockchain does not have to be decentralized. I mostly see people take decentralization when they refer to blockchain technology. However, blockchain does not imply decentralization.
Web3 does not have to use blockchain technology. In the context of Ethereum, that is the technology used. However, keep in mind that web3 and blockchain are not the same things.

In short, blockchain is a shared ledger where each transaction is recorded and shared between the participants. Instead of having a central location for information, the information is shared among multiple computers on the network.

There are different layers to the web3 technology stack—which we will not cover in this post. Instead, here's a great post by Nader that I'd highly recommend if you'd like to dive deeper into the tech stack.

Essentially, in web3, there isn't any person or marketplace in the middle, but instead, there are protocols governed by network contributors which have economic incentives to participate.

Why am I excited about web3?

Here are what I'm most excited for:

Individual ownership and control: people can own and control what they create on web3. For example, you can have your self-sovereign identity without relying on any identity provider or you could create a blog post on a user-owned blogging platform where the content is yours.
Trustless: the web2 world is based on trust. We trust the centralized cooperations to provide services and give them control over our data. It's a single point of control and thus trust, which creates a massive power imbalance. Instead, in web3, there are protocols that the users can directly interact with; there isn't any marketplace in between. Users do not need to trust anyone in the middle to utilize the services.
Open and Global Ecosystem: The services and protocol are global and available to everyone regardless of location, age, sex etc. Every single contributor has a specific economic incentive to participate.
Boost of Innovation: advertising is the dominant revenue model for the web that we know of today. Much time and energy is spent on advertising and learning the consumer better to show them the correct clothing item or even certain news. Alongside this, the boundaries of the web2 world are in some ways defined and limited. In web3, there is much room to explore and experiment, it raises many interesting questions, and people can try new things. I'm amazed when I hear about what some projects are trying to do.

Now you may be asking why I did not mention decentralization here. The reason being is that these properties are only possible with decentralization, so it's not the goal itself but the core component to get there.

The more people contribute, the more decentralized the underlying technology becomes. Recall that this technology is very new, so we yet need to understand the degree of decentralization and how to distribute cryptocurrencies in the best way.

What about the cons of web3?

Here are some of the challenges I see for web3:

Regulations: there's no regulatory clarity. Most of the space is experimental without any guidelines. This creates an uncertain environment for everyone participating.
The Language: There seems to be an invisible barrier of entry; at least, that was the case in my experience. There are too many new terminology and abbreviations. Alongside these, the false and overly-optimistic information make it complicated to understand.
Monetary Incentives: Custodial wallets are growing faster than non-custodial; more people seem to be interested in the money than the tech. This does not speak well on the promise of decentralization. Additionally, there are "maxi's" (people who only like their coins and tokens, hate all the others), which creates a lot of intense discussions in the space. It's hard to tell if people believe in a particular tech or if it's their monetary incentives.
The Narrative: there are a lot of opposing views on crypto. I constantly find myself explaining why I'm interested in the technology and then get the response: "but bitcoin is used for illegal activities". It takes time to change this, and we need concrete killer-use cases to do so.

Centralized platforms have been the standard for so long that it is hard to imagine otherwise. However, there's no denying the issues of web2. Web3 is reshaping the web, redesigning at its core, and I'm super excited to see what it will bring!

This post is my take on web3, and I'm sure there's more to learn as we see web3 evolving.

Thanks for reading! If you have any questions or comments, drop them below or reach out to me from Twitter. I'd love to hear from you!

Intro to dApp's: Create your dApp backend w/Solidity

Eda — Fri, 10 Dec 2021 08:41:01 +0000

In the previous post, we talked about creating a dApp frontend w/React. In this post, we will build the backend for our dApp and connect the two pieces.

Before we deep dive into the code, I've laid out some fundamentals for building the application's backend. Then we'll move on to creating a basic smart contract and putting the two pieces together.

Please note: In this article, we will be referring to dApp's on the Ethereum blockchain.

Intro to Decentralized App's (dApp's)

In the most basic form, a dApp consists of a backend (smart contract) and a frontend user interface.

Smart Contracts

A smart contract is a computer program stored on the blockchain. When the conditions of a smart contract are met, the code is executed by the Ethereum Virtual Machine (EVM). It's basically the server-side of the application.

Solidity is one of the most popular smart contract languages for Ethereum.

Transaction & Gas Fee

An Ethereum transaction refers to an action initiated by an account on the blockchain. For example, sending tokens to another account, buying an nft, swapping tokens are transactions on Ethereum.

Each transaction on the blockchain has a cost. So when you want to interact with a smart contract, you need to pay the "gas fee."

Gas is the measure of the unit to denote the cost for a transaction. Accordingly, gas fees are the fees that are paid to the network to process the transactions. On Ethereum, gas fees are paid in ETH and denoted in gwei (10-9 ETH). When there is a lot of demand for the network, the gas fees increase, you can check the gas fees from the Ethereum gas tracker .

Application Binary Interface (ABI)

The Contract Application Binary Interface (ABI) is the interface between two program modules. Simply put, ABI is like the API (Application Programming Interface) in the Ethereum world. It defines the methods and structures to interact with the smart contract.

How to create your own dApp w/Solidity and React

Create your Smart Contract

Project Tools

Metamask Wallet: crypto wallet.
Alchemy: ethereum developer platform. We will be using the Alchemy API to interact with Alchemy's Ethereum infrastructure.
Hardhat: ethereum development environment. It comes as an npm package.

Prerequisites

Choose your IDE and get the "solidity extension." I am using VS Code and am very happy with it.
Create an account on metamask and switch to the rinkeby test network.
Get your Alchemy API key. You will need to create an account on Alchemy. Then when logged in, create an App on the Rinkeby Test Network. Here's how your App settings should look like:

Once created, head over to the app details and get your key by clicking "view key" on the top right.
Install node.js.
Get some Rinkeby Test Network Ethereum. Try the faucet here to get some Rinkeby ETH.

Building the Smart Contract

Create a project folder and head over to its directory. Install hardhat.

mkdir eda-sample-smart-contract
cd eda-sample-smart-contract
npm init -y
npm install --save-dev hardhat

In your project directory create a hardhat project by running npx hardhat.
```
$ npx hardhat
```
The setup wizard will show up. Click enter throughout and keep the default options. Hardhat will create a sample project and install the dependencies for you. Here's how your terminal should look like:

Open the project from your code editor. Under the 'Contracts' folder, you should see the default Greeter.sol file. ".Sol" is the file extension for the solidity language, and it's our sample smart contract. I've added the smart contract below with some comments to explain what's going on.

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.4; // add the solidity version for the compiler
import "hardhat/console.sol";
// create the smart contract 
contract Greeter {
 // create a variable called greeting that will be stored in the contract 
 string private greeting;
 constructor(string memory _greeting) {
     console.log("Deploying a Greeter with greeting:", _greeting); // print to the console 
     greeting = _greeting;
 }
 // create a function to give the greeting message 
 // public: functions are public by default, anyone reading from the contract can call it
 // view: the function will not modify the state, it will only return a value
 // returns: the function declaration tells the type of the return value, here the return type is a string 
 function greet() public view returns (string memory) {
     return greeting; 
 }
 // create a function to change the greeting message 
 function setGreeting(string memory _greeting) public {
     console.log("Changing greeting from '%s' to '%s'", greeting, _greeting); // print to the console
     greeting = _greeting;
 }
}

Get your Alchemy API key; it's needed to talk to the Rinkeby Test Network from the smart contract. Add it to the hardhat.config.js (see code snippet under step-6).

Add your metamask private key to hardhat.config.js. You can get you private key by clicking Account Details --> Export Private Key from your Metamask extension.

require('@nomiclabs/hardhat-waffle');
module.exports = {
solidity: '0.8.4', // make sure the version matches the one in smart contract file 
networks: {
 rinkeby: {
   url: ' ', // rinkeby key 
   accounts: [' '], // metamask privte key- DO NOT SHARE THIS!! It has access to all your accounts
 },
},
};

We need to take our contract from our local machine and put it onto the Rinkeby Test Network. For this, we will use the sample-script.js file under the 'Scripts' folder. (It's usually called deploy.js; but let's leave it as is for this sample project.) Run the command below to deploy the contract to the Rinkeby Test Network.
```
npx hardhat run scripts/sample-script.js --network rinkeby
```

🎉 Once you see the details of your smart contract on the terminal, it means that your smart contract is deployed onto the Rinkeby network! For the next steps, you will need the smart contract address and the ABI. Here is where you can find them:

The smart contract address is printed on the terminal
There is a new folder called artifacts that is generated after deploying the smart contract. The ABI is the json document(Greeter.json) on the following path artifacts/Contracts/Greeter.json.

Connect to your Smart Contract from the frontend

Prerequisites

In this section, we will use the code from the Intro to dApp's: Create your dApp frontend w/React post. Follow the steps there to create your frontend w/React. Make sure you have ethers.js installed.

Building the frontend of your dApp

Add the contract address to App.js.

// add the contract address
const contractAddress = " "

We need to add the contract ABI. Copy the ABI file (greeter.json) from the smart contract and add it under /src in the react project.
Import greeter.json which is the contract abi to App.js.
```
import Greeter from './greeter.json'
```
Import "useRef" from react to store the mutable greeting value to App.js.
```
import { useEffect, useState,  useRef } from 'react';
```
Inside the App construct on App.js define a new variable to keep the greeting message.
```
const userGreeting = useRef();
```

Add the functions to get the greeter message and another to set the greeter message. Have a look at the code below, I have added comments to explain what's going on. Add the code snippet to App.js

const getGreeting = async () =>  {
 // check that there is a wallet connected
 const { ethereum } = window;
   if (ethereum) {
     // provider is a connection to the ethereum node
     const provider = new ethers.providers.Web3Provider(ethereum);
     // signer is used to sign messages and transactions
     const signer = provider.getSigner();
     // connect to the smart contract 
     const contract = new ethers.Contract(edasSmartContract, Greeter.abi, signer);
     // call the greet function on the smart contract
     const message = await contract.greet();
     // pop up the greet message 
     alert(message);
   }
}
const setGreeting = async (event) => { 
 event.preventDefault();
 if (userGreeting.current.value === '') {
   return;
 }
 const { ethereum } = window;
 if (ethereum) {
   const provider = new ethers.providers.Web3Provider(ethereum);
   const signer = provider.getSigner();
   const contract = new ethers.Contract(edasSmartContract, Greeter.abi, signer);
   const transaction = await contract.setGreeting(userGreeting)
   await transaction.wait()
   getGreeting() // go back to the getGreeting() func to give the user the greeting 
 }
}

Next, modify the walletConnected() component to display buttons which call the getGreeting() and setGreeting() functions.

//wallet connected
const walletConnected = () => (
<div>
  <p>Connected to the wallet</p>
  <button onClick={getGreeting}>Greet</button>
  <br/>
  <form onSubmit={setGreeting}>
   <button type="submit">
     Submit New Greeting Message
   </button>
   <br/>
   <textarea
     ref={userGreeting}
     placeholder="add your new greeting message here!"
   ></textarea>
   </form>
 </div>
);

Run the app with the command below. Open http://localhost:3000 to view it in the browser.

npm start

🙌 If everything is working, when you click the "Greet" you should see the greeting message pop up. You can also change the greet message by submitting a new one; it will ask you to sign and pay for the transaction since you are performing an action on the Rinkeby Network. (I've made some changes to App.css to make my UI prettier 😀)

This is a basic introduction to creating your own dApp on Ethereum. As a next step, I'd highly recommend the following resources:

Buildspace: a platform for developers to learn about web3 by creating cool projects. It's a fantastic learning resource where you can also connect with other fellow developers looking to get in the web3 world
Cryptozombies: an interactive platform for making smart contracts in Solidity or Libra.

Hope you enjoyed the article! If you have any questions or comments, feel free to drop them below or reach out to me from Twitter!

Intro to dApp's: Create your dApp frontend w/React

Eda — Fri, 03 Dec 2021 16:17:37 +0000

Intro to dApp's: Create your dApp frontend w/React

I get many dm's from dev's asking me how to get started with web3, hear such questions on twitter spaces and see the conversations on discord. It looks like so many developers are interested in the space.

If you are one of them, you're at the right place! In this post, I'll first try to explain the basics of web3 applications to provide an outline and then guide you through creating your dApp frontend with React.

Please note: In this article, we will be referring to dApp's on the Ethereum blockchain.

Intro to Decentralized App's (dApp's)

What is a dApp?

A dApp is just like any software application- any website or phone app. The difference is that the backend code runs on a decentralized network such as a peer to peer network or a blockchain.

So an application on Ethereum is a dApp.

What are the benefits?

Since the backend code(smart contracts) of a dApp is on a decentralized network, the dApp is free from control and can not be modified/removed by a centralized source. Developers and creators can trust the underlying infrastructure without worrying about being terminated or censored.
Once a smart contract is deployed to the Ethereum network, no one can change it. Therefore, users can trust how it will work since even the person deploying the contract can't change it.
All the smart contracts on Ethereum are public and accessible; it's an open-source ecosystem. This open-source nature allows for composability, so this means that you can re-use parts of the codes from others. You can look at all the smart contracts from Etherscan; here is an example smart contract.

A dApp only implies that the backend code(smart contract) is on a decentralized network. It's important to note that not all of the components of the application have to be decentralized. For example, the application developers decide where the frontend is hosted and where app data is stored.

The decentralized world advocates for making the entire technology stack decentralized and is building it right now!

What are dApp's used for?

Today the most popular categories for dApp's are gaming, financial services and digital goods.

Here are some popular dApp's on the Ethereum blockchain:

Uniswap-swap tokens and provide tokens for liquidity and rewards (Financial services)
Axie-play and earn with your avatars called "Axie" (Gaming)
Decenterland-collect and trade in the virtual world (Virtual world)
Open Sea : buy, sell, trade digital assets (Digital Goods)

There are probably more categories that we have not even discovered yet.

How can I use a dApp?

With most dApp's your cryptocurrency wallet is your first sign in. (Yay! No more username and passwords or connecting with other social media accounts.)

You basically need a cryptocurrency wallet and ETH-which is the native currency for the Ethereum blockchain. The wallet enables you to connect to the network and create a transaction, and you need the ETH to pay for the transaction.

Creating a dApp

A dApp consists of a backend (smart contract) and a frontend user interface in the most basic form. The frontend is the client-side, and the backend is the server-side of the application.

The backend of the dApp is the smart contract. Smart contracts are self-executing computer programs stored inside the blockchain, on Ethereum they are all open and accessible. You can look at them from Etherscan; here is an example of a smart contract. Another important note on smart contracts is that no one can change it once a smart contract is changed. Solidity is one of the most popular smart contract languages for Ethereum.
The frontend of the dApp can be written in any language that can talk to the backend. The frontend can then be hosted on a centralized service or a decentralized service.

In short, dApps are applications with a backend on a decentralized platform and a frontend that connects to it. To use a dApp, you need a cryptocurrency wallet and some cryptocurrency.

Create a dApp frontend w/React & ethers.js

In this project we will be creating a react project and connecting to our crypto wallet which is our interface to the blockchain.

Project Tools

Metamask Wallet: crypto wallet
React: JavaScript library for building user interfaces
ethers.js: Open source JavaScript Client library which contains the tools to talk to the Ethereum blockchain. (Another very popular option is web3.js. You can find a comparison of the two here.)

Please note: This project is only for the frontend of the application. When we want to add the backend piece we will need an Ethereum development environment. Hardhat and Truffle are popular Ethereum development environments. Additionally, to deploy the application to the network we would need to use a blockchain developer platform such as Alchemy or Infura .

Prerequisites

Install metamask and create an account. Add the extension to your browser.
Get node.js

Create D-app frontend

Create a project folder and setup a react app

npx create-react-app edas-dapp
cd edas-dapp
npm start

Install the ethers.js libary
with npm:
```
npm install ethers
```
with yarn:
```
yarn add ethers
```

The following code creates a button that the user can click which will prompt the user to connect to Metamask wallet. I have added the comments to explain what's going on. Add the following code to App.js.

import './App.css';
import { useEffect, useState } from 'react';

const App = () => {

  //state variable to store user's public wallet 
  const [currentAccount, setCurrentAccount] = useState("");

  // check wallet connection when the page loads
  const checkIfWalletIsConnected = async () => {

    // access to window.ethereum
    const {ethereum} = window;

    //check if user has metamask 
    if(!ethereum) {
       alert("Make sure you have metamask");
       return;
     }

    //get the wallet account
    const accounts = await ethereum.request({method: 'eth_accounts'});

    //get the first account
    if(accounts.length !== 0){
      const account = accounts[0];
      console.log("Found account:", account);

      //set the account as a state 
      setCurrentAccount(account);
    }
    else{
      console.log("No account");
    }
  }

  // connect to wallet 
  const connectWallet = async () => {
    try {
      // get the wallet 
      const {ethereum} = window;

      // there is no wallet extension 
      if(!ethereum) {
        alert("Opps, looks like there is no wallet!");
        return;
      }

      const currentNetwork = ethereum.networkVersion;
      console.log("Current network", currentNetwork);

      // request access to account 
      const accounts = await ethereum.request({ method: "eth_requestAccounts"});

      //set the account in the state 
      setCurrentAccount(accounts[0]); 

    }
    catch( error){
      console.log(error);
    }
  }

  //run function checkIfWalletIsConnected when the page loads
  useEffect(()=> {
    checkIfWalletIsConnected();
  }, []);

  //connect to wallet
  const walletNotConnected = () => (
    <button onClick={connectWallet} className="connect-to-wallet-button">
      Connect to Wallet
    </button>
  );

  //wallet connected
  const walletConnected = () => (
    <div>
      <p>Connected to the wallet</p>
    </div>
  );

  return (
    <div className="App">
      <div style={{display: 'flex', justifyContent:'center', height: '50px'}}>
          {currentAccount === "" ? walletNotConnected()  : walletConnected()}
          <br />
      </div>
    </div>
  );
};

export default App;

Now the following code will connect to the latest active network. So if the user was on the Ethereum Mainnet it will connect to Ethereum, if the user was on the Rinkeby Test Network it will connect to that. However, in many cases we need to the user to connect to a certain network.

You can check to see which network the user is connected to and prompt the user with a message to change the network they are on. Modify connectWallet in App.js as below.

const connectWallet = async () => {
 try {
   const {ethereum} = window;

   if(!ethereum) {
     alert("Opps, looks like there is no wallet!");
     return;
   }

   const currentNetwork = ethereum.networkVersion;
   console.log("Current network", currentNetwork);

   //check which network the wallet is connected on 
   if(currentNetwork != 4){
     // prompt user with a message to switch to network 4 which is the rinkeby network on metamask
     alert("Opps, only works on Rinkeby! Please change your //network :)");
     return;
   };

   const accounts = await ethereum.request({ method: "eth_requestAccounts"});
   setCurrentAccount(accounts[0]); 

 }
 catch( error){
   console.log(error);
 }
}

A better way to do this is to directly prompt the user with the request to switch the network. Instead of asking the user to change the network they are connected on. Change the if statement with the following lines.
```
    // request to switch the network 
    const tx = await ethereum.request({method: 'wallet_switchEthereumChain', params:[{chainId: 
'0x4'}]}).catch()
     if (tx) {
       console.log(tx)
     }
```

By default Chain 4 is already defined in Metamask. You can also prompt the user to add a new network which is not already defined. Here is how you can add the Avalanche network. Add the following piece of code just before requesting access to the account.

// define avax network values 
const avax_mainnet = [{
  chainId: '0xA86A',
  chainName: 'Avalanche Mainnet C-Chain',
  nativeCurrency: {
    name: 'Avalanche',
    symbol: 'AVAX',
    decimals: 18
  },
  rpcUrls: ['https://api.avax.network/ext/bc/C/rpc'],
  blockExplorerUrls: ['https://snowtrace.io/']
  }]  
  // request to add the new network 
  const tx = await ethereum.request({method: 'wallet_addEthereumChain', params:avax_mainnet}).catch()
  if (tx) {
      console.log(tx)
  }

🎉 There you go; that's how you can use a crypto wallet in your app! The next step would be to connect to the smart contract and do some cool stuff such as mint you nft, swap tokens etc.

Overall, it's good to know some js and html to put together a well-tailored frontend for your application.

If you have any questions, do drop them below or reach out to me on Twitter!

Create your own NFT collection on Ethereum w/Solidity

Eda — Mon, 29 Nov 2021 07:46:29 +0000

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

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

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

Creating your collection sounds complicated; I thought the same. Frankly, I would have never imagined creating an NFT collection, let alone try to explain it in a 10min article, if it weren't for buildspace . Buildspace is a platform for developers to learn about web3 by creating projects. I signed up for my first project and was amazed at what I was able to build. Check it out here. In this post, we will follow the project from buildspace "Mint your own NFT collection and ship a Web3 app to show them off."

So bare with me; it's just the new terminology that makes things complicated.

Can't you just take a screenshot?

It seems like a lot of people ask this question. I know for one that my friends and family do. By the end of this section, we'll have an answer 😉

NFT

Firstly, NFT stands for Non-Fungible Token.

Non-fungible: Fungibility indicates that a good can be interchanged (a word I googled many times). Non-fungible refers to goods that have unique properties and can not be changed with one another. For example, bitcoin is a fungible asset. If we each have a bitcoin and send them to each other, in the end, we'll have the same thing. On the other hand, a house is non-fungible. If we decide to switch homes, we'll end up with something different.
Token: In short, blockchain is a shared and immutable ledger, and a token is a digital asset living on top of the blockchain.

NFT's are unique digital assets on the blockchain. They are each one of a kind; this allows for tracking the ownership.

Today, most NFT's are on the Ethereum blockchain. However, we are also seeing many projects coming out on Solana and Avalanche.

But what really are NFT's?

The sky is the limit. Any digital asset can theoretically be an NFT. The most popular are Collectibles and Art.

Collectibles, as the name indicates, are a collection of assets in the format of an NFT. Think of these as Pokemon cards or even penny collections. NFT collectibles have the same logic, except they are in the digital world.

The earliest NFT was a collectibles project called CryptoKitties . It came out as a game centered around breeding cats. Each kitty (which is an nft) is unique, and you can breed kitties to create new ones.

Another example of a collectible NFT project is CryptoPunks. There are 10,000 crypto punks with different attributes such as a beanie, big beard, purple hair etc. The characteristics change for each punk, making each a unique CryptoPunks.

Art is self-explanatory. Artists have the chance to create their work on the blockchain and can directly reach their buyers. This process removes the many middlemen in between by directly connecting the buyer and the creator.

Other use cases for NFT's include domain names, gaming, music, ticketing... (There can be many more applications which we have not even discovered yet.)

Smart Contracts & Transactions

NFT's are created by running the code on the smart contract. This process is also called "minting."

ERC-721 is a standard type of smart contract that creates fungible tokens on Ethereum. The way each token is globally unique is with the tokenId field. Therefore, for every smart contract that creates an NFT, the smart contract and the tokenId pair is different.

Once you mint an NFT, you will be able to see it in your crypto wallet. You can then use secondary markets to buy/sell NFT's. Today, OpenSea is the most popular secondary market.

One thing to note is that every transaction on the blockchain has a cost. So when you want to mint, buy or sell an NFT, you need to pay the price called gas fee.

Gas is the measure of the unit to denote the cost for a transaction. Accordingly, gas fees are the fees that are paid to the network to process the transactions.

On the Ethereum blockchain, gas fees are paid in ETH and denoted in gwei (10-9 ETH). Due to the high demand for the Ethereum network, gas fee's are pretty high. Especially when there is a popular NFT project drop, and you could end up paying 100 dollars just for the transaction. Make sure to check the gas tracker before making transactions.

High gas fees are an issue which the Ethereum team and other scaling solutions are working on. High gas fees explain why many projects are coming out on the other blockchains.

🙌 Going back to our screenshot question. The main value proposition of an NFT is trackable and transparent ownership. The owner can prove that they own an NFT. If an NFT gets transferred, the transaction is recorded on the blockchain. It's basically a new way to transfer digital arts or even any asset. So, just like taking a photo of the Mona Lisa is not the same thing as owning the piece. Likewise, taking a screenshot of an NFT is not the same as being listed as the owner on a transparent and immutable ledger.

How to create your own NFT collection?

Project Tools

Metamask Wallet: crypto wallet.
Alchemy: ethereum developer platform. We will be using the Alchemy API to interact with Alchemy's Ethereum infrastructure.
Hardhat: ethereum development environment. It comes as an npm package.
OpenZepplin Contracts: library for secure smart contract implementations. We will be using the ERC271 libary standard.

Prerequisites

(It's the same setup from my previous post, here is a checklist to review the items.)

Choose your IDE and get the "solidity extension."
Create an account on metamask and switch to the rinkeby test network.
Get your Alchemy API key .
Get node.js to use hardhat.

Create your NFT collection

Create a project folder and head over to its directory. Install hardhat.

mkdir eda-nft-collection
cd eda-nft-collection
npm init -y
npm install --save-dev hardhat

In your project directory create a hardhat project by
running npx hardhat. The setup wizard will direct, you can
click enter throughout the setup wizard and keep the default
options.
```
$ npx hardhat
```
Run the command to install the OpenZepplin
implementation for
smart contracts. It has the ERC-721 token standard which
we will extend from.
```
npm install @openzeppelin/contracts
```
Under the 'Contracts' folder create a new solidity
file(file extension is .sol). This will be the file for our
ERC-721 token.

Below you can see a sample ERC-721 token smart contract extended from OpenZepplin. I have added some comments to explain what's going on in the code. Copy and paste it onto your own solidity file.

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.9; // tells the solidity version to    the complier

// get the OpenZeppelin Contracts, we will use to creat our own
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

import "hardhat/console.sol"; // built in hardhat local environment 

contract EdaNFTCollection is ERC721URIStorage {

  // keep count of the tokenId
  using Counters for Counters.Counter; // keep track of the token id's
  Counters.Counter private _tokenIds;

  uint256 public constant maxSupply = 2; // set the max supply of NFT's for your collection

  constructor() ERC721 ("edaNFTCollection", "EDA") { // construct your token, needs name and symbol
    console.log("An NFT has been minted to %s", msg.sender);
}

  function createEdaNFT() public { //function to create nfts

    uint256 newItemId = _tokenIds.current(); // get the tokenId

    require(newItemId < maxSupply); // check if the total supply has been reached 

    _safeMint(msg.sender, newItemId); // mint the nft from the sender account 

    _setTokenURI(newItemId, "https://jsonkeeper.com/b/2KQZ"); // add the contents to the nft 
    // the content of this nft is on the url above. This means that the nft is an off-chain nft
    // if the server with the content changes then the image in the url changes 

    _tokenIds.increment(); // increment the token, so when the next person calls the function it will be the next token in line 

    console.log("NFT ID %s has been minted", newItemId); 

   }
}

We need to take our contract from our local machine and put it onto the Rinkeby Test Network. For this, simply create a deploy.js file under the 'Scripts' folder. Copy and paste the content below onto your file.

const main = async () => {

    const nftContractFactory = await hre.ethers.getContractFactory('EdaNFTCollection'); // get the contract 
    const nftContract = await nftContractFactory.deploy(); // deploy --> convert to computer language
    await nftContract.deployed(); // wait for it to deploy
    console.log("Contract deployed to:", nftContract.address);

    let txn = await nftContract.createEdaNFT() // mint the nft 
    await txn.wait() // wait for the mint

    txn = await nftContract.createEdaNFT() // mint another nft (we set 2 as the max supply, can't mint more)
    await txn.wait() // wait for the mint

  };

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

Get your Alchemy API key, it is needed to talk to the Rinkeby Test Network from our contract. Add your API key to the hardhat.config.json (see code snippet under step-8)

Add your metamask private key to hardhat.config.json. You can get this by clicking Account Details --> Export Private Key from your Metamask extension.

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

module.exports = {
  solidity: '0.8.9', // make sure the version matches the one in smart contract file 
  networks: {
    rinkeby: {
      url: ' ', // rinkeby key 
      accounts: [' '], // metamask privte key- DO NOT SHARE THIS!! It has access to all your accounts
    },
  },
};

Run the command below to deploy the contract to the Rinkeby Test Network.

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

If everything is working, it should deploy the contract and print out the contract address to the terminal.

Head over to Etherscan for the Rinkeby Test Network. Etherscan shows all the transactions and the contracts on Ethereum. When you search for your contract address, you should be able to see the contract details and associated transactions.

Go to your account on Rinkeby Opensea to view the NFT's you just minted.

🎉 There we go! Now we have created an NFT collection on the Ethereum blockchain using the solidity programming language.

Make sure to checkout Buildspace for more projects and sign up for the NFT Collection if you haven't already. You get to build a frontend for your nfts and even make on-chain nft's in the project!

On a final note, the NFT industry is very new. There are a lot of speculations going on, and with little to no regulation, it can be intimating. However, I find NFT's very exciting because, before NFT's, decentralized finance was the primary industry for blockchain. Now we have a completely new application for blockchain technology. So let's see how the space will evolve.

Thanks for reading my article. If you have any questions drop them below and connect with me from Twitter, I'd love to hear from you!

Create your cryptocurrency token

Eda — Tue, 26 Oct 2021 23:19:54 +0000

3 weeks ago, I started the #100daysofWeb3 challenge. As a developer, I had never worked with web3 products and tools before. And what better task than creating my cryptocurrency token.

Honestly, it’s way easier than it looks!

With that, I decided to put together this article to outline the basic concepts of cryptocurrencies (basically it answers the questions I kept asking myself) and guide you through creating your own token on Ethereum.

What do I need to know before creating my token?

Blockchain & Cryptocurrencies

Blockchain is a shared and immutable ledger. On the blockchain, the information is distributed among multiple computers which work together to provide the underlying infrastructure.

Cryptocurrencies(crypto) are digital currencies that are secured by cryptographic functions. Most cryptocurrencies are based on blockchain technology. They are represented by entries onto the blockchain.

Bitcoin, the most popular cryptocurrency, is powered by blockchain technology. Basically, blockchain is the technology that makes bitcoin possible and has applications way beyond bitcoin.

Ethereum, Avalanche and Solana are other platforms that are built using blockchain technology. Different blockchain platforms prioritize different features such as decentralization, cost, speed, security...

Coin vs. Token

Cryptocurrencies can be crypto coins or crypto tokens. The two terms are often used interchangeably however they are two separate terms.

A coin exists on its blockchain. It is a digital representation of money for that blockchain. BTC, ETH or LTC are examples of cryptocurrency coins, they each have their own blockchain.

A token functions on top of an existing blockchain via smart contracts. Unlike a coin, a token usually has a utility associated with it. For example, Uniswap is an exchange protocol built on top of the Ethereum blockchain and has its token called UNI. UNI holders can vote on development proposals and decisions for the platform.

In short, coins have their own blockchain and are used as a medium of exchange whereas tokens live on top of a blockchain and can have different values or utilities.

Smart contracts

Smart contracts are just like contracts in the real world, except they are digital.

A smart contract is a self-executing computer program stored inside the blockchain. When the conditions of a smart contract are met, the code is automatically executed. This removes the intermediaries needed in real-life contracts and creates a trustless environment for users. Trustless means that the users do not need to trust each other because they can rely on the underlying code.

Some smart contract languages are Solidity, Vyper and Java.

Ethereum

Ethereum is an open-source, decentralized blockchain platform with smart contracts. It has its native cryptocurrency coin called Ether(ETH).

Solidity is an object-oriented, high-level language developed for creating smart contracts. It is the main programming language for Ethereum.

ERC-20

ERC stands "Ethereum request for comment" and 20 is the token identifier. It defines a set of rules and functions that apply to all tokens.

ERC-20 is a standard for smart contracts that create fungible tokens on the Ethereum blockchain. A fungible token means that all the tokens are exactly the same. If we each have a UNI token, there is no difference between my token and your token, they have the same type and value in each of our accounts.

There are more standard ERC smart contracts. For example, the standard for creating a non-fungible token(NFT) is ERC-721.

🙌 We have covered the basic concepts for cryptocurrency tokens, now let’s get to create one!

How to create a cryptocurrency token?

Let's do it together! In the project, we will build our token on Ethereum using Solidity. The type of smart contract we will use is ERC20.

Project Tools

Metamask Wallet: crypto wallet. It is a software wallet that you can use as a mobile app or browser extension.
Alchemy: ethereum developer platform. Alchemy has a full suite of products. We will be using the Alchemy API to interact with Alchemy's Ethereum infrastructure.
Hardhat: ethereum development environment. It comes as an npm package and allows you to create the basic setup you need for a smart contract.
OpenZepplin Contracts: library for secure smart contract implementations.

Prerequisites

IDE

I will be using VS Code for this project. If you would like to use VS Code you will need to add the solidity extension. Choose the IDE you like best, even a text editor will do.

Note: Remix Ide is a browser-based ide for Ethereum, its super convenient to get started with as you don't need any setup. (If you use Remix IDE the steps will be different becuase you can directly compile and deploy your code from the UI.)

Metamask Setup

If you don’t have Metamask already you can head over to their website to download the extension and follow the setup wizard to create an account.

Change your network to the Rinkeby Test Network.

Alchemy Setup

Sign up with Alchemy, you can use my referral link and then we can each get $100 of credit on the platform. The tools we will be using are free, but the credit can come in handy for other projects.

Once you log in, from the dashboard click "Create App." Give your app a name and a description. Select the "Rinkeby" network which is a test network.

Create your app and then click "View details" to get the API key which we will be using.

Hardhat Setup

You need node.js on your machine to use hardhat. Install the version for your pc.

Create your token

Create a project folder and head over to its directory.
```
mkdir my-token
cd my-token
```
In your project directory create a hardhat project by running npx hardhat
```
$ npx hardhat
```
Here is what you will see on the terminal:

You can click enter throughout the setup wizard and keep the default options.
Run the command to install the OpenZepplin implementation for smart contracts. It has the ERC-20 token standard which we can extend from.
```
npm install @openzeppelin/contracts
```
Under the 'contracts' folder create a new solidity file(file extension is .sol). This will be the file for our ERC-20 token.

Below you can see a sample ERC-20 token smart contract extend from OpenZepplin. I have added some comments to explain what's going on in the code. Copy and paste it onto your own solidity file.

 //SPDX-License-Identifier: Unlicense
 pragma solidity ^0.8.4; // tells the solidity version to the complier

import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; // inherit the erc20 contract

 import "hardhat/console.sol"; // built in hardhat local environment 

 contract Eda is ERC20 {
     constructor(string memory name, string memory symbol) ERC20(name, symbol) {
         _mint(msg.sender, 100 * (10 ** 18)); // mint tokens: supply 100 tokens, 18 is the decimal 
 }
}

We need to do much as we are extending the functions from the OpenZepplin ERC20 Contract. All we are doing is minting the tokens, which basically means creating them.

Remember the Alchemy API key, we need to talk to the Rinkeby Test Network from our contract. Add your API key to the hardhat.config.json (see code snippet under step-7)

Add your metamask private key to hardhat.config.json. You can get this by clicking Account Details --> Export Private Key from your Metamask extension. The tokens will be added to this account

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

module.exports = {
  solidity: '0.8.4', // make sure that the solidity compiler version is the same as in your contract
  networks: {
    rinkeby: { // defining our test network 
      url: '', //alchemy api key 
      accounts: [' '], // metamask rinkeby account private key
    },
  },
};

All the coding is complete 😀 Now we need to compile and deploy our contract.

Compile your smart contract by running npx hardhat compile. This command will create an 'artifacts' folder in your project directory. It will translate the solidity code into machine-executable code.
```
npx hardhat compile
```

We need to take our contract from our local machine and put it onto the Rinkeby Test Network. For this simply create a deploy.js file under the 'scripts' folder. Copy and paste the content below onto your file.

async function main() {

   const Token = await hre.ethers.getContractFactory("Eda"); // hre: hardhat runtime environment
   const token = await Token.deploy("Eda Token", "Eda"); // call constructor: name and symbol
   console.log("Token address:", token.address); // print the address to the console
 }

 main()
   .then(() => process.exit(0)) /
   .catch((error) => {
     console.error(error); // print the error if there happens to be one 
     process.exit(1);
   });

Run the command below to deploy the contract to the Rinkeby Test Network.

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

If everything is working, it should deploy the contract and print out the contract address to the terminal.

Copy your contract address and head over to the Rinkeby Testnet Explorer to view your contract.

You can add your tokens to your metamask account. By default, you will not be able to see them. Under Assets select 'Import Tokens' and add the contract address. Once you click submit you should be able to see your tokens.

Let me leave you with the Ethereum Developer Resources where you can find great resources to continue developing on Ethereum.

Thank you very much for your time, hope you enjoyed the article. If you want any "eda" tokens or have any feedback, please don't hesitate to reach out!