Forem: Neelansh Mathur

The end, and the beginning! (Polygon Fellowship Finale)

Neelansh Mathur — Thu, 18 Aug 2022 16:26:00 +0000

8 weeks of concentrated effort into the Polygon Fellowship finally concluded with a banger of a week at the Polygon HackerHouse in Bangalore. ✨

This has been a defining experience in both my personal and work life, and I can't wait to tell you about it!

Being in the Beginner Track, I was first educated about common concepts in web3 for a couple of weeks while I develop or start developing my final project's idea.

Here's how the 8 weeks were structured:

Intro to Blockchain and web3 🌱
Smart Contracts 😎
DeFi 📈
Infrastructure and Storage 💿
DAOs 👨‍👩‍👧‍👦
NFTs and the Metaverse 🎮
Project R&D 💪🏻
✨ Polygon HackerHouse ✨

I made blog posts at the end of each week, covering what I learnt in that week. They are available on my Dev.to profile.

There were many mentors to assist us, and a mentor was assigned to a group of 5-6 people each. My mentor is Leibing Guo from CovalentHQ, and he was very excited to hear about our ideas and progress!

Every week was exciting! It was filled with interesting assignments and speaker sessions and the fellows would help each other out frequently as we all learn and grow together.

The speaker sessions were from Industry Experts from various domains in web3 and some were our mentors themselves!
The knowledge they imparted to us is very valuable and it helped me down the road when I was making my final project.

The Project 🌿

All the knowledge culminated into me deciding that my value lies in the Creator Economy, but not directly. I had wanted to develop something similar to the Lens Protocol so badly and did like 30-40% of the work on a mobile app.
But then I realised at the HackerHouse that what I am doing isn't necessarily valuable. Why would I want to reinvent the wheel and compete with something that has no issues whatsoever and has a large community backing? Just because I need to make a project? Nah.

I pivoted.

I found out that the Lens Protocol actually has a very good system of modules that I can use to implement the functionality I initially thought would be my differentiating factor.
I named the project Pollen. Pollen Social, Pollen Modules, Pollen Protocol, etc. Lens Protocol's theme is flowers and gardens. So "Pollen" would be what spreads the reach of the flower to distant lands! 😌

Everything on Lens is an NFT. You follow somebody, you get their follow NFT. You publish a post, that is an NFT. You comment on a post, you guessed it, it's an NFT!

With this comes the potential to have custom logic. For example, before giving a user a Follow NFT, a creator could have a condition that the user should hold a certain NFT, say Bored Apes, otherwise they can't follow the creator.

The possibilities are endless! But my time and energy isn't, so I created a suite of seven modules that would be simple and standard. These would be basic modules that the people using Lens would definitely want but is not there right now.

These are extension modules for logic on Follow and Reference.
Reference Modules basically have logic related to comments or reposts. In my case I enabled giving rewards on repost.

I essentially wanted to build an OpenZeppelin for Lens. Here are the hosted docs: http://pollenprotocol.surge.sh/

I also received positive feedback from the founder of Lens Protocol and Aave himself :)

The Polygon HackerHouse

Finally, the day was here! I'll say this straight-off, meeting someone offline is NOT the same as meeting them online. With all the fellows here, about 50 of them combining Beginner and Buidler Tracks, it felt like this is where I belonged XD.

I got to interact and truly know the other fellows and I feel like I have made friends for life :)

The HackerHouse was in a crazy luxurious 5-star hotel in Bangalore and we lived in suites like the Kings and Queens that we are 👑.

Every day was packed with in-person events in a beautifully decorated event hall. Prominent people like the founders and devs of Quickswap, Biconomy, etc. gave talks and this was huge for us.
Because after the events we were able to sit with them for lunch, dinner or in general and discuss various topics and also get feedback on our projects!

It's like getting life advice from the gods themselves XD 🌤

At the end of the hackerhouse, I gave my presentation. I was a bit nervous but when you go up to the stage and you know what you're doing, everything just flows effortlessly! 🎉
I forgot to mention, I was also loaded with Shwags from the Devfolio and Polygon organizing teams. It's like we were getting goodies EVERY DAY! YAY!

There was a grand After-Party planned by Devfolio where we had a blast and met some more people from the web3 space as it was open to VCs, builders and the like.

Conclusion

It was an unforgettable experience. The connections I made and the project itself got me ahead in ways I couldn't have imagined before. I was a fan of Polygon before but now I can't stop buidling 🔥🔥🔥!

Special thanks to the Devfolio team because I saw first-hand how hard they worked to keep the experience smooth for us fellows, so kudos to them!

Not a day shall pass when I don't miss the HackerHouse and the people there, but life goes on. And my life has been made significantly better by Devfolio x Polygon :')

Top 3 Play-to-Earn Games on the Blockchain to Check Out

Neelansh Mathur — Sun, 24 Jul 2022 18:25:00 +0000

Part of Polygon Fellowship 2022 Week 6

Gaming & The Metaverse have become some of the top movers in the Blockchain space.
Just looking at the Market Capitalization alone, we can imagine how big the industry actually is.

Some of them are super famous like Axie Infinity, one of the pioneers of gaming on the blockchain. Others like Decentraland, Gala and Sandbox also have huge communities and have been on the news multiple times.

Let's review some of them.

Gala Platform

The native token is GALA.
It has launched more than 10 games on its platform, some of which are under development, in beta or releasing soon. They are continuously developing more games for people to enjoy and earn from.
It gives its payments in Gala Coin and some special rewards are in the form of NFTs.

Spider Tanks is a game I found interesting. It is a tank warfare game and it is out in Beta already.

Items have a variety of rarities: Common, Uncommon, Rare, Epic, Legendary and Ancient.
They are essentially ERC1155 NFTs with varying levels of supply that you can own a quantity of.

Overall, I loved their release video and the graphics but wasn't able to play the game, I guess I need to buy one of the Tank NFTs or the game isn't open to all yet.

Decentraland

The native token is MANA (and LAND).
Decentraland is more then just a blockchain gaming platform. It is a Metaverse platform for 3D Virtual Reality content where any user can spend and earn MANA.
MANA is burned to get LAND NFTs which are ERC-721 tokens.

In this Metaverse, you can buy LAND which is 16 x 16 meters in size just like you would in the real world. Once you purchase your land, it has a fixed place and it can be resold like normal NFTs.
Not just for fun, but LAND has grown to be a huge investment as its price now verses when it was launched is significantly higher.

LAND owners can do anything they want with their land and can create anything. There are games being developed in parts of Decentraland which provide incentives you would expect from a play-to-earn blockchain game, but Decentralized largely remains a Metaverse platform with infinite potential.

Sandbox

The native token is SAND.
Like Decentraland, it is a Metaverse + Gaming platform and is based on Ethereum. The biggest backing it has is that of Binance and the fact that it was launched way back in 2012 and is thriving today says something about the ecosystem, which is stable and growing.

Like in Decentraland, Sandbox users can buy parcels with crypto which equate to 1 LAND token which is 96 sq. metre in size.
Players can utilize this land to build whatever they want including games for others to play.
Players are rewarded for collecting resources, rewards and whatever system the game developer chooses to have.

The Sandbox team itself has sponsored development of many games, although like Gala many are in developement or in Beta.
Some are in Open Beta and more are expected to release to the wider public soon.

Unlike Decentraland, Sandbox also has ASSET NFT tokens in addition to LAND, which serve as collectibles in the Sandbox Marketplace.

One more interesting thing about Sandbox is that even developers can directly earn, by just creating digital assets (ASSETs) and selling them on the Marketplace for other developers to use.
There are tools provided like the Voxel Editor and GameMaker which make game development on Sandbox easier.

As more games come out of open beta, I presume the values of all these impressive blockchains will increase and the platform will be more widely used by everyday internet users.

Until then, I'll keep a look out for these and if you find any interesting games on the blockchain, I'm down!

The Bankless DAO - Polygon Week 5

Neelansh Mathur — Sun, 17 Jul 2022 17:59:35 +0000

Part of Week 5: DAOs of Polygon Fellowship 2022

Week 5 is learning about Communities, DAOs, Social Tokens, etc.

The Bankless movement aims to onboard beginners to the world of crypto through Media, Collaborations, Communities and Simpler Finance tools.

Here is a short presentation on The Bankless DAO I created:
https://docs.google.com/presentation/d/1TVf7wl-uOI80paKUK0G-n8ljKjVXxji4_m0BNAouZBo/edit?usp=sharing

DAOs are still an interesting topic for me, especially Social DAOs and Media DAOs.

I also created my own Liquidity pool on Uniswap v3 on Polygon Testnet and received an NFT for my pair. Uniswap v3 is VERY different from Uniswap v2 and I think I need to explore v3 very soon.

I have covered my experience with Uniswap v2 in previous weeks which you can check out too. Primarily, this has been my github repo for smart contract interaction with Uniswap v2:
https://github.com/neelansh15/Uniswapper

See you all next week!

Decentralized Social Network, Subgraphs, IPFS - Polygon Week 4

Neelansh Mathur — Sun, 10 Jul 2022 18:22:00 +0000

Part of Polygon Fellowship 2022.

It's been a crazy week. The craziest, in fact, relative to the previous weeks. This week was all about exploring web3 Infrastructure & Storage using IPFS, Alchemy, Pinata, TheGraph Protocol, etc.

Social Media Dapp

Let's start with the heavy hitter.
The biggest assignment in this week was to build a full-stack Decentralized Social Media App with our own hint of creativity.

The assignment on Polygon Academy is given here: https://academy.polygon.technology/module-8-wizard-challenge/final-asssignment

The statement says:

Submit a full stack social media dapp as your final assignment.
The dapp lets a user post and receive images to an anonymous network of contributors. There will be a feed of all images.
No need to add extra functionality like likes and comments, just basic push-pull data submission. Use ethereum to point to images and store them on IPFS. Use polygon as an L2 for this. Submit your assignment below.

Here is what I think the normal approach will be:

Accept image, title, description, etc. and store this metadata on IPFS
Store the IPFS URLs of posts in a Smart Contract per user, maybe in an array
Query this array of urls to get user's posts
(Optional) Use Subgraphs or Moralis to index these posts

This works. But I had been thinking about creating Posts as NFTs in some way, inspired by reading about the Lens Protocol.

So, here is my ingenious approach!

ERC1155 ProfileHub creates a ProfileNFT for a user (Token + another ERC1155 contract)
Store user's post image on IPFS
Store user's post metadata on IPFS with the image URL from previous step. Metadata is according to the OpenSea Standards.
ERC1155 ProfileNFT's Mint function can be called by the user with the IPFS URL of the NFT as argument.
Indexing is not directly necessary as many services already index NFTs on OpenSea! 🌊

So in this approach, There is a central ProfileHub collection which mints a Profile Token and creates another collection called ProfileNFT for each user.

Flow:
ProfileHub Collection => ProfileNFT Token + ProfileNFT Contract
ProfileNFT Contract = User's Posts as Tokens with Traits

The benefits of this approach is that you can view your posts even on OpenSea! It has all the advantages of a regular NFT.

IPFS

There are multiple ways to upload an image to IPFS. You can do it either manually or programatically.

I decided to create an API using NodeJS and Fastify that accepts user's image and uploads it to IPFS using Pinata's Node SDK.
It seems a bit overkill but I had to create this for my Social Media Dapp anyways so it can be reused now.

A MAJOR issue I had was with taking user's image. Normally, multipart images work with frameworks like Express and Fastify, but here the issue was that even after getting the image, Pinata's SDK wasn't accepting the file Buffer 😵‍💫
After a LOT of hours of on-and-off debugging, I found out that there is a small hack we need to do to the file's Readable Stream to make it work with Pinata.
I wonder why nobody has covered this at all. I only found this out from a stackoverflow question that was not that much related to my problem.

The overall code (which I turned into an NFT creation tool for my social dapp later on) uploads an image to IPFS, then uploads the metadata with image url to IPFS to serve as an NFT.


    const image = await (req.body as any).image
    if (!image) reply.send({ error: "No image file" })
    if (!(req.body as any).name.value || !(req.body as any).description.value) reply.send({ error: "Missing name or description fields" })

    const readableStream = Readable.from(await image.toBuffer())

    // IMPORTANT: This is the only fix for Pinata to work. It needs a 'path' property in the Readable Stream
    // @ts-ignore
    readableStream.path = image.filename

    try {
        const imageResult = await pinata.pinFileToIPFS(readableStream)
        const imageURL = BASE_GATEWAY + imageResult.IpfsHash
        const data = {
            name: (req.body as any).name.value,
            description: (req.body as any).description.value,
            image: imageURL,
            external_url: "https://github.com/neelansh15",
            attributes: [
                {
                    trait_type: "Likes",
                    value: 0
                },
                {
                    display_type: "date",
                    trait_type: "Posted on",
                    value: +new Date / 1000
                }
            ]
        }
        const result = await pinata.pinJSONToIPFS(data)
        const nftURL = BASE_GATEWAY + result.IpfsHash

        reply.send({ ...result, url: nftURL })
    }
    catch (e) {
        console.error(e)
        reply.send({
            error: e
        })
    }

Here, the BASE_GATEWAY is https://gateway.pinata.cloud/ipfs/.

Welp, many more things to come. Especially the Social Media Dapp, an idea I plan to expand upon in the future.

DeFi & LoanShark - Polygon Week 3

Neelansh Mathur — Sun, 03 Jul 2022 21:06:44 +0000

Part of Polygon Fellowship 2022.

Decentralized Finance (DeFi) has been the most interesting topic in blockchain not just for me but for many folks, simply because it provides a new way of dealing with finances that we never saw before.

In this post, I'll share what I created in the DeFi space as part of my fellowship and a brief about my research into some interesting topics.

Borrowing Dapp

The base for this project was an assignment in Polygon Academy. The assignment merely gives us the statement:

Build a borrowing dapp that let's a user submit Ether to a smart contract as collateral and receive stablecoin as a loan. Have this be a web interface with text field input and a button to submit. Get creative!

As you can see, there is a very basic problem statement given, which leaves us with a lot of room for creativity!

So let's think of a smart contract that loans a certain stablecoin at a fixed ratio in return for Ether/Matic. Then when the user has to repay, a small fee will be taken from the Ether that will be returned to the user.
This ratio and fee can be updated by the owner.

What I also thought is, why not let the stablecoin be changed? But then, the existing loans should have been repaid.
So, we can introduce another functionality that is whether the loan contract is active or not. If it is not active, borrowing won't take place but user's can repay their stablecoin to get back the ether.

I am calling this contract LoanShark. If you have played GTA Vice City you will be very familiar with this 🙂

For my smart contract example, I have chosen to create my own ERC20 token called SharkUSDC/sUSDC.
I thought of creating my own stablecoin for this exercise, but decided against it for now. I think it would be a good future prospect, so definitely check out my upcoming posts!

Also, since you can use any ERC20 token, you can set an actual stablecoin for loans and then transfer the coins to the contract and it will be operational.
With this approach, the drawback in my current iteration of code is that since the supply is not in our control, anyone can repay a lot of stablecoin to get ether since a mapping is not there. This can be an upgrade soon.

Challenges

There were a lot of issues to deal with on the Smart Contract side of things.

First of all, there was a problem with multiplication when I was calculating the amount for borrow/repay. Multiplying two uint256 variables results in 10¹⁸ being multiplied twice. This cost me a lot of time to figure out. To solve it I just divided the final result once by 10¹⁸.

The second issue is something I haven't been able to resolve yet. I tried verifying my contract by using Hardhat's Verify Task which always works. It worked for my ERC20 token but didn't work for my LoanShark contract.
LoanShark takes three things in its constructor:

Stablecoin address
Ratio
Fee Address is passed as a string, and fee is passed as 0. All good, they all work. But then ratio cannot be zero. And to pass it as "1" for One-to-One ETH-Stablecoin mapping, I have to multiply it with 10¹⁸ so that it is stored correctly.

This didn't work on the command line. Can't pass this large of a value.

Then I came across a hardhat article that describes how we can pass complex arguments for verification.
We can pass arguments by exporting it from an arguments.js file.

An Example is my own arguments.js:

const { parseEther } = require("ethers/lib/utils");

module.exports = [
    "0x1AfE5e07f6c6f092494DA8423708c412939B6906",
    parseEther('1'),
    0
]

Unfortunately, for whatever reason, this was passed to Etherscan but did not get verified. 😞

I'll update if this issue is resolved, but this is heartbreaking. I need to see the green tick of my verified contract on etherscan. ✅

UPDATE: It got verified! The fix was to convert the BigNumber returned from parseEther to a string with the toString method of BigNumber. Passing the value as a string myself didn't work, but this did.
You can access the verified contract at: https://goerli.etherscan.io/address/0x2162Ba3A993BC8442CEE02340693D1818bbB6826

Links

Check out the site at http://loanshark2.surge.sh.
Devfolio project: https://devfolio.co/projects/loanshark-cd70

Uniswapper

In my post about Week 2, I mentioned that I had been working on Uniswapper, my contract that handles swapping by using Uniswap's contracts. I fiddled with it a bit more in the Add Liquidity part and got it to work perfectly as I wanted:
Deposit just ETH and it will split evenly and add liquidity.

A problem before which I didn't think would happen is leftover tokens. I read and understood that in some uniswap functions if you provided say more ETH than necessary for the transaction, it will refund that ETH back to the user. But here the user is the Smart Contract and not the actual user, so we need to refund both the ETH and the Tokens in case this happens.

Chainlink

In the DeFi world, everything runs around the price of assets. Oracles (plural, not the company) are used to get price data on-chain or off-chain.
A widely-used protocol is the Oracle Chainlink which brings off-chain data to the blockchain. So you can actually compare prices with real-world values like fiat currencies USD/EUR and actual listed stocks.

You can use Oracle's latestAnswer variable in their PriceConsumerV3 contracts by calling it from the frontend or from your Solidity Smart Contracts.

There have a great tutorial here if you want a quickstart.

My implementation is here: https://github.com/neelansh15/Chainlink-Price-Consumer

Research Topic

We had to research on an assigned web3 project. My assigned project is Polymarket, a decentralized betting and information platform. I might create a separate post for that, so stay tuned!

Deadman's Switch, Uniswapper - Polygon Week 2

Neelansh Mathur — Mon, 27 Jun 2022 15:13:57 +0000

Part of my journey at the Polygon Fellowship 2022.

Blockchain is an interesting piece of technology. The theme for this week was Smart Contracts.

Smart Contracts are the backbone of the Ethereum ecosystem. All the business logic of your application is written in Smart Contracts cannot be modified after being deployed. (Proxies are a small exception).

Let's explore what I built.

Deadman's Switch

The name is very badass 😂. Reminds me of the movie Pirates of the Caribbean: Dead men tell no tales. 🏴‍☠️.

What happens if a smart contract is holding funds, but the owner of the fund dies or is unable to access their wallet for whatever reason?

A deadman's switch requires that the owner calls the still_alive function periodically at a set interval, say every 10 blocks.

If the owner hasn't called still_alive when they should have, then the rescueFunds function can be called that will transfer all the funds in the contract (like Ether) to a preset emergency address.
This ensures that funds are not forever locked in the contract.

You can check out my implementation of the Deadman's Switch at my Github repository: https://github.com/neelansh15/Deadmans-Switch.
It is deployed on Goerli at https://goerli.etherscan.io/address/0x8C51Aec2eAf32852DeD8D89a75Ffd499ed7E7547.

Uniswapper

I wanted to learn more about the DeFi ecosystem, and what better way to start than with Uniswap! The pioneer in this space.
I took ETH & USDC as a good starting pair and was able to do a couple of things:

Get ETH-USDC pair data using UniswapV2Factory and UniswapV2Pair
Swap ETH for USDC using UniswapV2Router
Add Liquidity to ETH-USDC, with a twist. Instead of providing both the tokens, you just have to send ETH and the contract will calculate the required USDC amount from the reserves data, swap ETH for the required USDC and then add liquidity to the Uniswap V2 Pool of ETH-USDC.

More Uniswap functionality can be added and I will redeploy as that happens.
Check out the code that makes it possible: https://github.com/neelansh15/Uniswapper
Deployed at: https://goerli.etherscan.io/address/0xF5ca8778edab3C08897791A37c03AE0ccE525115

Bridging Tokens

You can actually bridge your ERC20 tokens from Goerli to Polygon Testnet or from Polygon Mainnet to Ethereum by using the Polygon PoS bridge!
What it allows you to do is submit your ERC20 token on say Goerli, and it will map it to the Polygon Testnet so that your tokens can be bridged between the two chains!

I created an ERC20 token called HILL and I am waiting for the approval from Polygon. According to their site, it usually takes 3 days to a week to approve it.
Hopefully mine is done soon!

I also learnt about DeFi in a session hosted by the Devfolio and Polygon teams. In fact, that is what the contents of next week is going to be! Very excited to learn more about the DeFi ecosystem and build on top of it.

How is building in web3 different from building in web2?

Neelansh Mathur — Mon, 27 Jun 2022 14:24:06 +0000

Part of my learning process at the Polygon Fellowship 2022

Most of you are familiar with apps being built with a frontend and backend, using the countless languages and frameworks out there.

What is up with web3? What exactly is the technological difference in web2 and web3? Let's explore that.

Paradigm of web2 vs web3

Frontend

web3 doesn't reinvent the internet. In fact, it supplements it. You still need a website, UI design and other frontend principles in order to use Decentralized Applications (Dapps).

The difference is in the new concept of:

Wallet Connection (Ex: MetaMask, WalletConnect)
Smart Contract Interaction (Ex: EthersJS)
Handling wallet and transaction states

You may have also noticed a trend in many dApps, especially Decentralized Finance (DeFi) apps, they have:
1) Central Card Layout
2) Gradient cards, backgrounds

It is hard to trace back exactly who started this, but Uniswap is the pioneer that may have popularized this.

Backend

Think of the backend components in web2. API routes, databases, server-side processing, etc. They are what you start working on when you create, say, a social media app, an e-commerce site, etc.

Now in web3, you have the blockchain technology as your backend. Your data will directly or indirectly come from smart contracts instead of APIs and Databases.

The Smart Contracts handle all the business logic and some amount of storage. For large storage, IPFS can be used.

Does blockchain tech replace the backend?
Absolutely...Not 👀
As I said, web3 is an addition, supplementary and will not replace existing tech.

In major blockchain applications, getting data from smart contracts can cost time and sometimes fail if the RPC is unresponsive. You would still want a database and API to query data collected from smart contracts from, say, events.

Examples: The Graph, Moralis.

The database doesn't have to be centralized, there are decentralized solutions available too.

Going forward, you can learn solidity from the official docs or check out free courses from Buildspace and CryptoZombies.

Conclusion

There are conceptual differences in building blockchain applications, but it cannot exist without the existing infrastructure of web2. It is an interesting piece of technology which I think is unlocking new ways we look at governance, money and decentralization.

Follow me to get updated on my blockchain journey as part of the Polygon Fellowship 2022 :)

What I learnt from my first week of Polygon Fellowship

Neelansh Mathur — Sat, 18 Jun 2022 18:10:49 +0000

It is interesting what all can happen in such a short time. In half a month, I have completely switched tracks over to the world of web3.
Started as a freelance frontend developer for a blockchain company a year ago, picked up some solidity and made a few interesting projects.

On 28th and 29th May, I attended the Warpspeed hackathon, met some really cool people and won a prize while I was at it.

After that, I applied for the fellowship and in a few days I get to know that I am accepted!

I didn't choose web3, web3 chose me
Me, probably

The first week is the learning phase where we start with the very basic concepts of blockchain development.
I'm here to share with you what I learnt from some of the workshops held by mentors from Polygon, what I learned from the assignments and beyond.

Let's start.

Block Explorers 🧭
Every blockchain has its own block explorer which helps with tracking and providing information about transactions.

For example, look at this transaction on polygonscan, a block explorer for Polygon: https://polygonscan.com/tx/0xa464f99be231de2637fe4d9d66d8c06ec4805c099fcb0d0f4e37b5960d861da2.

Here, I am adding USDT and USDC to a liquidity pool on Quickswap (I'll talk about Quickswap in a while), and I can see the transaction hash, gas fees, tokens transferred, token action and much more!

Polygonscan is useful for understanding what a transaction did on the blockchain.

Decentralized Exchanges (DEXs) 💸
A DEX is similar to a centralized exchange like Binance or Coinbase. It facilitates the management of assets on the blockchain.

A common theme you will see across some of the DEXes like Uniswap, Quickswap or Dfyn is that the Swap page is always the first.

Swapping allows you to exchange an existing ERC20 token for another one. For example, you can swap your MATIC for USDT, WBTC, etc.
The conversion rate is determined by the DEX and varies from one DEX to another.

Liquidity Pools 🐳
For swapping to take place, there has to be a pool where both of these assets are present in sufficient amounts. If you're swapping USDT for USDC, there should be a USDT-USDC pool on the DEX you're using that can take your USDT and give you USDC.

But where does the liquidity in the pool come from?

The answer is that users provide the liquidity. When you swap, a small fee is deducted which goes towards paying the people who provided liquidity in the pool.
You can become a liquidity provider too and earn just by supplying your idle tokens to a pool!

How much fees a user gets for providing liquidity depends on their share in the pool. Go back to the transaction I shared above in the block explorer section, you will see that I get UNI-V2 tokens in return for my deposited USDT & USDC. These are called Liquidity Pool Tokens or LP tokens or LPTs. They represent the shares you have in the pool.

Example of a pool I provided liquidity to on Quickswap:

You can see that Quickswap charges 0.25% fees on swaps and passes it onto the liquidity providers. This may vary depending on different DEXes.

After you have your LP tokens, you can invest in various instruments like farms or staking to further increase your returns.

Writing a Smart Contract 📄
The task was to write a simple hello world contract, taken from the tutorial by the Ethereum foundation, and deploy it on the Goerli Testnet.
I have used hardhat and solidity before, so this was a breeze. The smart contract would store a string message and be able to update the message.

I would recommend following the official tutorial by the Ethereum Foundation if this is new to you: https://ethereum.org/en/developers/tutorials/hello-world-smart-contract/

Minting an NFT 🦄
I have written a separate article on minting NFTs on Opensea: https://dev.to/neelansh15/how-to-mint-an-nft-on-opensea-in-5-minutes-36c3

This wraps up the assignments part. There were sessions held by mentors from Polygon who shared valuable insights, some of which I'll share in brief.

Quadratic Funding 📈
This is related to raising funds. Suppose you're raising funds and a company is matching the donations made by the public.

The grants by company is calculated according to a given formula. The practical impact of this is that more preference is given to a project which raises say $1000 from 100 people than a project that raises $1000 from 20 people.
This is great because more number of people want the first project to succeed and naturally it should be given a higher grant.

Great article for reference and implementation example: https://devfolio.co/blog/experiments-with-inout7/

Americana.af
Link: https://americana.af/
This is a project that aims to turn real-world items into NFTs. These real-world items can then be bought and sold as NFTs.

Dynamic NFTs
NFTs (Non fungible tokens) have traits like Color, Background, Health, etc. In a normal world, static NFTs are just fine. But there are many cases where a dynamic nft is needed.

The best example is web3 games. Say your character is an NFT which has health, power, age, etc. These traits will change as you progress in the game and thus need to be dynamic.

This also brings me to the next topic: Upgradable Smart Contracts.

Upgradable Smart Contracts
I had an idea about this once that what if we redirect a smart contract to a new one in order to update the code like we can do in web2.
Turns out, the concept of upgradable smart contracts by using Proxies exists! I haven't implemented it but I found the openzepplin docs to be of great help: https://docs.openzeppelin.com/learn/upgrading-smart-contracts

DAOs (Decentralized Autonomous Organizations)
DAOs are the standard for governance on the blockchain. Every DAO has a fixed set of rules that govern the decision-making of the organization, including how the voting takes place.

In a DAO, people who hold the tokens of that DAO are assigned some voting power. It can be in a static 1:1 ratio (1 token = 1 vote) or it can be derived from a formula or it can be mapped according to how long the user has been holding the token.

Proposals are created in these DAOs which decide the direction that it should take, according to its community members.

Once a proposal has been voted upon, the results are automatically calculated and the verdict is produced.

Example DAO: https://uniswap.org/governance
You can create DAOs for Non-profits here :) => http://lowpoly.surge.sh/
It is a project I made in college with my teammates.

I think I've covered the major topics that I recall. There are other smaller topics worth checking out like Infura/Alchemy and RPC endpoints, zkrollup, How Polygon works (layer, settlement, etc.), IPFS, Filecoin, etc.

This week has been phenomenal. I've learned quite a few things, interacted with mentors from Polygon and interacted with fellow members of the fellowship.

Looking forward to learning more and reporting next week. ✨

The journey has just begun! 🚀

How to Create an NFT on OpenSea in 5 minutes

Neelansh Mathur — Thu, 16 Jun 2022 09:11:59 +0000

So, you have an image and you want to convert it into an NFT, maybe to explore what it is all about or to sell it for profit.

I'm Neelansh, currently a part of the Polygon Fellowship program of 2022. I am documenting what I am learning and sharing it with the community 💜.

Let's start.

Prerequisites

You need to have MetaMask or a similar ethereum wallet first. You can get one as a chrome / firefox extension here: https://metamask.io/.

It is also available as a mobile app.

Connect Wallet to Opensea

Go to https://opensea.io/ and connect your MetaMask wallet.

Creating a Collection on Opensea

Before minting an NFT, you need to create a collection in which the NFT will reside.

Go to https://opensea.io/collections and click create collection.

You only need to set three things:

Logo image, Name and the Blockchain.

Set the logo image to anything, you can use your NFT image here as well.
Change the blockchain to Polygon as it is way cheaper than Ethereum to Mint and move assets around.

It is optional, but you might want to look at the Creator Earnings too and add a percentage and your wallet address (which you can get from MetaMask) to collect Royalty fees whenever someone resells your NFT.

It is also a good idea to add more token payment options, like USDC on Polygon which many people use and will make it easier to buy your NFT.

Once this is filled, click Create and your first collection is made! 🎉

But it looks quite empty right now. Let's fix that.

Creating an NFT on Opensea

Click create in the Navbar.

Upload your image, give it a nice name and change the blockchain to Polygon.

You can leave all the other details out if you don't intend to use them. We just want a basic NFT.

Click create, complete the captcha and you're done!

You have just minted your very own NFT on the Polygon Blockchain 🥳

My NFT looks like a Cadbury Chocolate Wrapper XD.

There are a lot of customizations and features you can add to your future NFTs. Read up more about Traits and different types of NFTs.

You can put your current NFT up for selling right away as well.

Thank you for reading, let me know if you have any questions and I'd be happy to answer them!
Right now I do feel like eating chocolate, so brb :)

How to Create your own Token on the Ethereum Blockchain

Neelansh Mathur — Thu, 23 Sep 2021 16:20:18 +0000

Learn the basics of Solidity and HardHat while creating your very own transferrable token on the Ethereum Blockchain!

In this article, you will learn how to use HardHat and write a simple Solidity contract to deploy your custom Token.

Before we start, let's look at the basic terms.

Smart Contract: A program on the blockchain
Solidity: The language to write smart contracts with. If you know JavaScript or similar languages, you'll be very comfortable writing Solidity

Environment for writing Smart Contracts

There are just three basic steps for creating any smart contract:
Write, Compile and Deploy.

We have multiple options to choose from for the environment. The most popular ones are Truffle and HardHat. They both help with writing, compiling, and deploying our smart contracts to the blockchain.

We shall be using HardHat since it is very easy to get started with. Their docs are very concise, so I would recommend giving it a read.

Prerequisites

NodeJS + npm installed. I am using v14.17.6 LTS.

Steps

Initialize npm project

Create a new directory and run npm init -y to initialize a new npm project.
Install HardHat

npm install --save-dev hardhat

Install hardhat as a dev dependency. Now we can access the hardhat command-line tools with npx hardhat [command].

Create empty configuration file

Run npx hardhat and select the option to Create an empty hardhat.config.js file.
The reason for starting with an empty config is that the Hardhat flow is really simple and starting with a boilerplate might leave out valuable insights.
Install required dependencies

To install the other dependencies, run

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

This command can be found on HardHat's official docs also.

Writing the smart contract Create a directory called contracts, and inside it create a file called Token.sol. Your structure would be /contracts/Token.sol.

HardHat knows to look inside the /contracts directory for your smart contracts. .sol is the file extension for the Solidity programming language.

Open Token.sol in your code editor. If you're using VS Code you will need the solidity extension by Juan Blanco.

Before writing the code (which is short and sweet btw), let's go over the concept of the Token you are about to create:

Each token has a name, symbol, total supply and owner.
The owner is the account that will initially be used to deploy the contract. This will be your personal MetaMask (Recommended) or other crypto wallets. It will hold all of the fixed supply of tokens which can then be distributed to others.
We will need Key-Value pair mappings to store token balances for each address.
We will need two basic functions, one to allow transfers between accounts and one to check the balance of an individual account.

Keeping all of these things in mind, let's start by writing the contract itself.

Writing the Token Code

The first line of every solidity file will specify the version of solidity to use for the compiler.

My compiler uses 0.8.7 at the time of this writing, and I'm updating the same in the hardhat config since that has a previous version written by default instead of my compiler's latest version.

// Token.sol
pragma solidity ^0.8.7;

Contract and variables

Next, keeping the conceptual points in mind, we will declare a contract that looks like a JS/TS class declaration and define the variables inside it. Notice how the code is very similar to JavaScript or TypeScript.

pragma solidity ^0.8.7;

contract Token{
    string public name = "Neelansh Manifesto Token";
    string public symbol = "NMT";
    address public owner;
    uint public totalSupply = 1000000;
    mapping(address => uint) balances;
}

You can define your own name and symbol for the token. Don't use special characters like a quotation mark.

The total supply is being defined as 1 million, or 1,000,000.

string and uint data types are self-explanatory. The address data type stores the hexadecimal address of a crypto wallet.

The mapping type is also very simple. It is like an object in JavaScript and maps addresses to their corresponding integer token balances.
It's javascript equivalent would be:

const balances = {
    1: 1000, // Address (assume integer) mapped to token balance
    2: 5000,
    ...
}

Constructor

Every contract once deployed on the blockchain lives in there forever.

So the contract is initialized only once, and that is when the constructor is called. All we need the constructor to do is set the owner of the contract and assign the total supply of coins to the owner.

Since you will be deploying using your personal MetaMask account, your account will be the owner and hold all the tokens.

constructor(){
        owner = msg.sender;
        balances[msg.sender] = totalSupply;
}

msg.sender is the address of the contract or wallet that is executing the transaction and is automatically injected in every contract.

Functions

We need to write functions to transfer tokens between accounts and get the balance of an individual account. The functions are again similar to JS/TS except for some differences which are out of scope for this article.

The complete code will look like this:

pragma solidity ^0.8.7;

contract Token{
    string public name = "Neelansh Manifesto Token";
    string public symbol = "NMT";
    address public owner;
    uint public totalSupply = 1000000;
    mapping(address => uint) balances;

    constructor(){
        owner = msg.sender;
        balances[msg.sender] = totalSupply;
    }

    function transfer(address to, uint amount) external {
        require(balances[msg.sender] >= amount, 'Not enough tokens');
        // Deduct from sender, Add to receiver 
        balances[msg.sender] -= amount;
        balances[to] += amount;
    }

    function balanceOf(address account) external view returns (uint) {
        return balances[account];
    }

}

Compiling Contract

Once you've saved your contract, it's time to compile it for deployment.

npx hardhat compile

Testing

It is almost always required to write JavaScript tests for your contracts, but we'll skip it otherwise this article may as well be a book 📖

Configuration before Deployment

Before you deploy, you need:

Private Key of your account from MetaMask. Click on the three-dot menu and go to Account Details > Export Private Key
API URL from Infura Create an account on infura.io. Create a new project, go to settings, change the endpoint to Rinkeby and copy the HTTPS endpoint URL.

Now in your hardhat.config.js file, use the private key and API URL like this:

/**
 * @type import('hardhat/config').HardhatUserConfig
 */

require('@nomiclabs/hardhat-waffle')

const API_URL = "https://rinkeby.infura.io/v3/74685a5d02de4ec9b17b6fee80738970"
const PRIVATE_KEY = "YOUR_PRIVATE_KEY"

module.exports = {
  solidity: "0.8.7",
  networks:{
    rinkeby: {
      url: API_URL,
      accounts: [`0x${PRIVATE_KEY}`]
    }
  }
};

Be sure to replace the API URL and private key with your own.

We are adding 0x before the private key to make it a hexadecimal address. The account you used for the private key will deploy the contract and our constructor will add the token balance to it.

The require for hardhat-waffle injects ethers into our scripts, which is a JS library we need for our deployment script.

Now we are ready to deploy! 🥳

Deploying the Token

We need a short script to help us deploy our contract. Create a file called deploy.js in a new folder called scripts/ and write the following code into it:

async function main(){
    // Not necessary, but just to see the account deploying from
    const [deployer] = await ethers.getSigners()
    console.log("Deploying contracts with the account", deployer.address)

    const balance = await deployer.getBalance()
    console.log("Account balance", balance.toString())

    // Main stuff
    const Token = await ethers.getContractFactory("Token")
    const token = await Token.deploy()

    console.log("Deployment address: ", token.address)
}

main()
.then(() => process.exit(0))
.catch((e) => {
    console.error(e);
    process.exit(1);
})

Final

To finally deploy your token, run

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

Our token has been deployed! But hold on, we still need to see it in MetaMask. Copy the deployment address and store it somewhere.

Adding our Token to MetaMask

Go to MetaMask and the assets tab. At the very bottom, click on Add Token.

Paste in the deployment address of your token as the Token Contract Address, it should automatically fetch the symbol of your token! 💯

YAYYY! Your token is deployed and visible in MetaMask! You can send these tokens to your friends and family and have fun with your very own token on the blockchain! 🎉🎉🎉🎉🎉

Conclusion

This was a very simple token. There are standards like the ERC-20 token standard upon which most serious tokens are based upon, so that would be a good topic to learn after this.

I am no blockchain expert, but I am sharing the knowledge I gain as I go along my journey 😄

If you face any errors let me know either here or on Twitter @mneelansh15

How to Make a Scrollable List in HTML & CSS

Neelansh Mathur — Tue, 24 Aug 2021 13:02:24 +0000

So you are making an application and have a huge list displayed on let's say a modal or popup. You've seen it so many times, how do you make the list scrollable as you please? The answer is just two lines of CSS.

The concept is to set a fixed height and set overflow to either scroll or auto.

Note: This article covers how to make the list scrollable, not the list itself. You can find the code for the list in the Github repository mentioned in this article.

Now, observe what happens when you use the below code:

height: 300px;
overflow-y: auto;

When you have fewer elements than the max display capacity of the list, it'll still take up the rest of the space as it has a fixed height.

So, the best way then is to use max-height so that we remove any unnecessary space.

max-height: 300px;
overflow-y: auto;

And with multiple elements in the list:

There you have it! A practical example explaining this basic concept.

Github repository: https://github.com/neelansh15/css-listview

Example with VueJS and ChanceJS

If you're wondering about the code behind the card and the data, then I've sprinkled some Vue 3 in it along with ChanceJS and Lorem Picsum for random name and image generation.

And of course a neat amount of simple CSS :) (available in the Github repository)

<div id="app" class="container">
        <div class="card">
            <div class="card-header">
                <h2>Contacts</h2>
            </div>
            <div class="card-content">
                <div v-for="(contact, i) in contacts" :key="contact.name" class="contact">
                    <div><img :src="contact.image" class="profile-image" /></div>
                    <div class="names">
                        <h3>{{contact.name}}</h3>
                        <p class="status">{{ contact.status }}</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
    <script src="https://unpkg.com/vue@next"></script>
    <script src="http://chancejs.com/chance.min.js"></script>
    <script>
        const App = {
            data() {
                return {
                    contacts: []
                }
            },
            mounted() {
                const chance = new Chance()
                this.contacts = []
                for (let i = 0; i < 10; i++) {
                    this.contacts.push({
                        name: chance.name(),
                        status: (i % 2 === 0) ? 'Online' : 'Offline',
                        image: 'https://picsum.photos/200?random=' + i
                    })
                }
            }
        }
        Vue.createApp(App).mount("#app")
    </script>

Clone, run the code and experiment if you want to!

If you want to learn how to make this from scratch or make another component from scratch, mention it in the comments or on my twitter!

This article was really simple, but if need be I can cover more complex topics, all depending on what you want to learn about, so let me know in the comments!

Made with 💖 by Neelansh Mathur ( Github )

Blockchain in Javascript: Transfer Ether between Accounts

Neelansh Mathur — Mon, 07 Jun 2021 09:19:33 +0000

When I started learning about the Ethereum blockchain, the biggest eureka! moment I had was when I sent Ether between two accounts. What is fascinating is the simplicity of doing so in Javascript!
In this article you'll learn how you can do the same in like 2 min.

Initial Setup

Test Ethereum Blockchain

Ain't nobody gonna buy actual Ether for learning this. We need a test blockchain with test accounts, preferably preloaded with ether.

For this, you can use either a combination of infura.io (test blockchain) + Metamask.io (test/actual accounts) or the really simple Ganache for both test blockchain + test accounts + test ether. You can install Ganache here.

When you run Ganache, it will look something like this:

You'll get multiple accounts preloaded with 100 Ether each. I've made a few transactions already on my first two accounts hence the ether difference.

NodeJS

You can do what I'm about to show you even without NodeJS by using a CDN of the library we're using: web3. See https://web3js.readthedocs.io/en/v1.3.4/getting-started.html.

But NodeJS makes things a bit simpler. And you can also add express if you want to create an API.

If you want to follow along with the same code as mine, make sure you have NodeJS installed.

The good stuff

Now that you have a test blockchain running with accounts overflowing with Ether, let's get down to business.

Initialize a new javascript project:

yarn init
or
npm init

and create a new file main.js.

We'll be using a library called web3.js, which is the Javascript SDK for interacting with the Ethereum Blockchain. Ethers is an alternative.

Install the web3.js library:

yarn add web3
or
npm install web3

Remember your running Ganache instance? Copy the RPC URL which should be in the top bar. It'll mostly be http://127.0.0.1:7545.

Moving forward

In the main.js file, we'll now require the web3 library and initialize a new object by passing the URL we got from Ganache.

const Web3 = require('web3')
const web3 = new Web3("http://127.0.0.1:7545")

Select any two accounts from Ganache and store their addresses in two variables from (The account we'll be sending ether from) and to (The account we'll be sending ether to). Mine will be different than yours.

For simplicity, also create a variable named value for storing the amount of ether to transfer. Let's say we want to transfer 1 ether, then the variable will look like:

const value = web3.utils.toWei("1", "ether")

Notice we are using web3.utils to convert 1 ether to Wei. Wei is the smallest unit of Ethereum cryptocurrency. 1 ether is 10 to the power 18 times one Wei 🤯

We need to convert to Wei since the function we're about to use accepts values in Wei.

We're going to simply call web3.eth.sendTransaction and pass it the from address, to address and the value, and we're good to go!

web3.eth.sendTransaction({from, to, value}, function(error, result) {
        if(error) console.log(error)
        else console.log(result)
});

The final code will look like this:

const Web3 = require('web3')
const web3 = Web3("http://127.0.0.1:7545")

// Use your local Ganache accounts for this
const from = "0x6056aD120bDC5a382A1E780fC5A4C1CDDbA98dF4"
const to = "0x3168B2b9DEc1F8886bDbCf99359d7185652F1164"

// Amount to transfer. Here, 1 ether
const value = web3.utils.toWei(1, "ether")

web3.eth.sendTransaction({from, to, value}, function(error, result) {
        if(error) console.log(error)
        else console.log(result)
});

Now when you run your code with node main.js, it should return a transaction hash if the transfer was successful.

Check Ganache, it'll reflect the change and you've successfully made a transaction on the Ethereum blockchain! 🥳🥳🥳