DEV Community: Pari Tomar

Web3 Development: Learn what is ETH2.0 and how it impacts you

Pari Tomar — Tue, 28 Jun 2022 04:15:11 +0000

TL;DR

ETH2.0 is a phased release
Current merge is only a PoW to PoS move
PoS’s primary benefit: No more energy wasted by uncle blocks
Planned for 2023: Sharding
Sharding is likely to have a huge impact on our development practices
Finally: Notes from Consensus 2022 in Austin, Texas (Read below)

Ethereum, the most popular blockchain platform, has been planning a major software update for a long while. This update is known as ETH2.0.

There are a 1000+ articles on what and why about this ETH2.0, but after scanning through them for a day, we figured the current state of our understanding was ‘unconfirmed’. If you are in the same boat, then welcome to our dumb-friendly and easy-to-get-a-grip article on ETH2.0.

PoW to PoS (you already knew about this)
We are quite confident that you already know that ETH2.0 is a transition from a proof-of-work consensus mechanism to a proof-of-stake model. A quick refresher:

With the ground zero set-up; let’s understand:

about the Merge
why it is such a big deal for Web3 space, and
most importantly why should you care about this at all

How does Ethereum work currently?
We all know that the current Ethereum Mainnet runs on the proof-of-work, aka PoW architecture; this is the same as the other largest blockchain network BitCoin. To not bore you to death, we are skipping the nuances of PoW and focusing on the most important lesson learned from PoW:

As the number of transactions in the blockchain increase, the computational power required to confirm the transactions also increases, which leads to higher power consumption.

While you will read almost everywhere that this “HIGH” energy consumption is ‘the’ problem, we will shout out loud that NO, it is not ‘the’ problem (unpopular opinion). ‘The’ main issue is the uncle blocks. Now again, we are choosing to not bore you to death with the nuance of uncle blocks, but cutting the story to the point:

Uncle blocks (or Ommer) are created when two or more miners create blocks at nearly the same time. Only one block can be mined and accepted as canonical on the blockchain. The others are uncle blocks, which are not included but still provide a reward to their miners for the work done

source: https://info.etherscan.com/

In short, these ‘mining’ efforts are “wasted”. Let us repeat this: “wasted”.

It is the energy consumption in the rat race of mining that is ‘the’ energy guzzler.

Now that we have understood the villain in the story. Let’s introduce the hero: ETH 2.0 or The Merge. 🦸

I know what ETH2.0 is; tell me something that I do not know! 🙀

Main: Energy efficiency, less computational work = less energy used (our knight in shining armor)
Others: Lower barriers to entry (that’s not to say that just anyone can be a validator, but it is better)
Others: Reduced centralization, tied in with the last point, easier entry means higher decentralization
**Others: **Security is increased as 51% of attacks are more expensive

Power Ranger
Currently, Ethereum uses 113 terawatt-hours of electricity per year. That is as much as what the Netherlands consumes in a year.

According to Digiconomist, a single Ethereum transaction can consume as much power as an average US household uses in more than a week.

This has become a huge concern for the people as it has started showing its impact on the environment.

Power Power Power!

It is estimated the PoS will use 99.5% less energy than PoW.

That is it; literally, that is the BIGGEST benefit of the merge that happened on Ropsten. See here 👉 Link

No. You were not.

ETH2.0 is a colloquial term and is used to represent one more BIG change: Sharding. Sharding is a technically heavy topic. In a one-liner, sharding is the ability to run a “chain of chains”. Zilliqa (based on our limited knowledge) was the first blockchain to execute sharding.

Try to bask in the light of this image to imagine how sharding looks like

source: Link

So what is the status of sharding?
Being your friend, we suggest you do not hold your breath for this. This is planned for somewhere in 2023.

Should I care about sharding?
Yes. Sharding is expected to have a huge impact on our development practices. So keep an eye out for that.

Benefits of sharding?

Higher throughput: which means the time taken to process transactions will be way lesser than the current 13 secs (average)
Reduction in Gas Costs

Impact of ETH2.0 on Mining and Markets

We all know that mining is an income generation venue. At present, a miner gets 2 ether per block plus all the priority fees contained in the block. Based on our research we found that per day the number of ETH mined and provided to miners is north of 12,000+ ETH.

On the basis that all of this ETH arrives at the exchanges for liquidation, there will be sell pressure every single day.

Based on this source

We require around $10M of new money every day to keep the price flat. Therefore, after the Merge, the value will be reduced to $8M for existing holders to sell their ETH to prevent the price from going up.

Thank you again Korpi for this insight.

As a Web3 developer, what impacts me?
The current PoW to PoS has minimal impact. The block time is expected to be shortened from 13 seconds per block to 12 seconds.

As a result, smart contracts that use block production speed as a measure of time will run one second faster after the Merge takes place.

Is that it?
No. Read the sharding portion above again. With sharding, a lot of changes are expected. But we just don’t know what all of these are yet.

What does this change mean for the newcomers?
For the newcomers to this space, this represents the best opportunity to jump in and start participating.

It’ll be cheaper to start a DAO or launch a project. Or, if you’re more interested in contributing to the network as a validator, the new mechanism is making it even easier for you to participate with reduced hardware requirements.

If you were concerned about the environmental impact of blockchain technologies, the reduced impact of the second-largest blockchain in existence is being cut so you can feel maybe a twinge less guilty about using it (if you’re in the category you should also check out this article).

Or, if you’re a security skeptic then maybe you might be feeling unsure about this. After all, PoS is less tested under the heat of battle than PoW.

On the other hand, ETH 2.0 was designed with security at the forefront of consideration; requiring a minimum of 16,384 validators, Vitalik is pretty confident in it as well.

This number of validators certainly seems like it’s enough to adequately call it decentralized and the cost of a 51% attack against the network would cost many billions of dollars in staked ETH.

Notes from Consensus 2022 in Austin, Texas
Members of the core team that were at Consensus 2022 participated in a panel about the ETH merge and I was able to pull two major areas to highlight from this.

First, regarding the frustrations voiced over the continual setbacks in finalizing the merge, the team pressed on the need for patience as research takes time to conduct and test. With security and stability being vital to the success of the merge, the team is taking the precautions necessary. If something does go wrong during the merging process the team will stop the merge and postpone it again.

Secondly, when the issue of centralization was pressed the team responded that the update will effectively break up the Ethereum mining cartels that have dominated the market, leading to greater decentralization. Further, staked ETH centralization is a problem that will need to be solved by a combination of human and technical methods. Every layer of the ecosystem will have to continue to grow to mitigate the centralization of ETH.

Authors (open to feedback): 👇

Mike Bivens, Pari Tomar and Amateur-Dev

Hardhat or Truffle? As a beginner blockchain developer, which one do I pick

Pari Tomar — Thu, 02 Jun 2022 13:40:32 +0000

In a blockchain developer’s life, one of the major pain point is to find the best-suited framework or tool for him/her. People spend days or weeks finding the right tool for them.

Similarly, in the Blockchain world, one of the major debate is on choosing between Hardhat or Truffle.

These development environments help developers to manage many of the tasks that are inherent to developing decentralized applications and smart contracts.

If you just starting out your career in the blockchain world and, just like us, albeit sometime back, are wondering which one to choose: Hardhat or Truffle, then you’re at the right place!! 🥳🥳 In the below paragraphs, we have discussed both these frameworks and have proceeded further to do a small comparison of sorts.

Hardhat Tool

Hardhat is an Ethereum development environment for developers that allows performing frequent tasks.

Other than just deploying and running tests, Hardhat also provides some more features that make it more powerful and unique.

Let's consider these features one by one.

Hardhat Network

Hardhat comes built-in with Hardhat Network, a local Ethereum network node designed for development providing multiple features like automated error messages, mainnet forking, and, mining modes.

So if you’re using Hardhat, then by default you’re already using Hardhat Network. It mines a block with each transaction that it receives, in order and with no delay.

Plugins

Next up is Plugins.

Plugins, in simpler words, are extensions that can be loaded on a program to improve its functionality.

There are 30+ plugins used in development with Hardhat which is why it is considered the backbone of Hardhat.

We have listed some of the popular plugins below with their functionalities:

@nomiclabs/hardhat-ethers: It allows developers to inject ethers.js into the Hardhat Runtime Environment.
@nomiclabs/hardhat-waffle: It allows you to add a Waffle-compatible provider to the Hardhat Runtime Environment.
@nomiclabs/hardhat-etherscan: It automatically verifies contracts on Etherscan
hardhat-gas-reporter: Gas reporter helps to acknowledge the gas usage per unit test and average gas usage per method.
Testing

Hardhat provides a very simple procedure for testing smart contracts, providing developers to write automated tests when building smart contracts.

Hardhat provides great documentation for understanding testing methods with Hardhat.

If you’re new to Hardhat Testing, try our previous article to get a better understanding of Hardhat Testing.

The Universe of Truffle Tools

Like Hardhat, Truffle is also a development environment dedicated to Ethereum blockchain.

Truffle is a highly popular development framework and provides a large community behind the tool.

For decentralized applications development, the developer uses Truffle Suite.

The Truffle Suite is an ecosystem for Web3 development that consists of three different tools: Truffle, Ganache, and Drizzle

Truffle: It is a development environment that uses the EVM for smart contract development.
Ganache: Ganache is a tool used to set up your own local Ethereum blockchain that you can use to deploy and test your smart contracts.

Other than that, Ganache enables developers to avoid paying unnecessary gas fees during the developing process.

Drizzle: Drizzle is a collection of frontend libraries with a Redux store as its basis.

With this, the frontend development becomes a lot easier for the developers.

Truffle offers several different features like:

Smart Contract Management:

Truffle helps you manage the artifacts of the smart contracts so that you can focus on the other parts of the development process and spend less time on the file organization.

Scriptable Migration and Deployment:

With Truffle, you can write deployment scripts that allow you to account for the fact that your Dapps will change over time.

Powerful Interactive Console:

Truffle provides 2 different consoles to choose the best tool for your needs.

(A) Truffle Console: A basic interactive console connecting to any Ethereum client. To launch the console, use the truffle console command. When you load the console, you'll immediately see the following prompt:

Truffle console will let you connect with the contracts deployed on the EVM client and interact with the contracts in a manner similar to the one that you would use through javascript.

(B) Truffle Develop: An interactive console that also spawns a development blockchain. It serves the same purpose as the hardhat node

You can simply launch the Truffle Develop by using the truffle develop command

Truffle Dashboard:

Recently, Truffle has introduced Truffle Dashboard, providing an easier way to use your existing Metamask wallet for your deployments and transactions. Using Truffle Dashboard is not only easy but is a plug and play. You can use the Truffle Dashboard inside any Hardhat projects also. Truffle has provided great documentation to follow along and use Truffle Dashboard in your project.

Which one is more powerful?

Let us compare some of their features and get a final answer to our question!! 💪

1. Debugging

Solidity is hard to debug. You just get an error message when something breaks and more often than not, it is painful to debug what exactly went wrong.

Thankfully, Hardhat introduced something known as the console.log feature for Solidity.

So you can simply import the console plugin and can use it inside your functions.

This is what it looks like:

Add some console.log inside the function

The logging output will show when you run your tests:

The EVM created by hardhat specifically supports this feature and hence is native to Hardhat Node. This feature alone is a heavy pro for Hardhat.

On the other hand, Truffle has been improving its debugger and it also has some plugins for it but Hardhat is considered a more easier and powerful tool used for debugging.

2. Libraries (Ethers and Web3)

Hardhat uses ethersjs by default but can be easily modified to use Web3. Whereas, Truffle uses Web3 as default plugin for development.

You can also use Etherjs with Truffle but it is considered to be trickier and hard to implement.

While ethers-js and web3-js are similar, there is a very high uptick in the number of developers using ethers-js as default; this should presumably give you some hint on what you could / should consider for developing.

3. Local Ethereum Network node

Hardhat comes inbuilt with Hardhat Node. However, it does not have a GUI for developers to see account info in real-time.

Truffle, on the other hand, uses Ganache which has to be set up separately. However, it comes with both a CLI and a GUI version allowing flexibility for the developer.

If you prefer the GUI you should choose Ganache.

4. Deployment

For deploying a contract, Hardhat uses basic javascript scripts to deploy, so it’s easier to get started with it and is relatively simple to use.

Whereas, Truffle uses a migration-based deployment procedure (which are js files themselves, but have a sequential order of execution) which is a bit more complicated for a beginner, but can be helpful in the long term keeping in mind that your deployment needs might change in the future.

But for ease of getting started with deployment, hardhat definitely takes the prize.

5. Testing

To perform various tests, both Truffle and Hardhat use the Chai assertion library and Mocha as their testing framework but hardhat also includes waffle. They’re both strong when it comes to testing.

6. Statistics

Before Hardhat was launched, Web3 was the most popular framework for testing out smart contracts.

Later on, now you can see that the trend changes over time, and Hardhat has gained more popularity as compared Truffle.

According to the NPMJS Statistics, Truffle has almost 30k weekly downloads. Whereas, Hardhat has around 86k weekly downloads, which is twice as compared Truffle’s.

7. Community

Truffle’s Github community is quite active and helpful, whereas Hardhat provides a Discord server for their community support. It must be noted that the entire Truffle offering is supported by Consensys and hence you can expect a “support helpdesk” treatment. Hardhat too is developed and managed through an organization: the Nomic Foundation and has an amazing and equally good support system through its discord server.

Conclusion

It is really hard to say which is the best. The choice of Truffle vs Hardhat comes down to one’s own preferences and use cases, as they both are two powerful tools.

If you’re absolutely new to both frameworks, then you should definitely explore both of them and decide which one is the best for ‘you’.

However, we hope this article was able to give you an insight into the differences between them and was able to help you to find which one to use.

Tell us which framework do you prefer over the other by tagging us on Twitter at @uv_labs

Give us a clap if you liked our work.

Authors (open to feedback): 👇

Pari Tomar, Mayon Francis and Amateur-Dev

How can you become a Blockchain Developer in 2022

Pari Tomar — Tue, 24 May 2022 14:26:20 +0000

We all agree that ‘Blockchain’ is in trend these days.

Apart from its value add as a technology, it is now also one of the most promising and demanding areas in the software development domain.

If you are thinking to work on building your career in the Blockchain aka Web3 space, congratulations you are on the right path. If you are still considering and are also thinking on how can you build a career in the Blockchain space, specifically, as a developer, read along.

Trust us. Anyone and Everyone can become a blockchain developer, once you put your heart and mind to it. If you put in the right amount of effort, we kid you not, you should be able to start your career in the blockchain before the end of 2022!!!

Reasons why one should become a Blockchain Developer

Less competition in the Job Market

There are still not many Blockchain developers out there. Interested developers started to learn the concepts and apply their knowledge to space from 2016. Therefore, you will not have lots of competitors in the blockchain area.

Higher Salaries

There are thousands of active projects in the space but on the other hand, there are very few expert developers in the space. This means that if you are an expert blockchain developer in 2022, you will have endless opportunities.

Running Personal Blockchain Projects

As a Blockchain developer, you will be able to design, develop, test and deploy various solutions in the future as a 100% personal project.

In this article, we’re going to create the most productive roadmap to becoming a Blockchain Developer.

“Becoming a Blockchain Developer” won’t be just about smart contracts, it’s also about deployment and testing, and sometimes the front-end is included too.

So without wasting any more minutes let’s just begin with our Roadmap! ⭐

1. Web Development as a Prerequisite

First of all, in order to create attractive decentralized applications, you’ll have to learn Web Development and programming of the apps as a prerequisite.

Web Development is crucial because most organizations require blockchain developers to create apps that people with no or minimal knowledge of blockchain could use.

Thus, here are some resources for learning Web Development in 2022:

These resources will help to get a great understanding of Web Development and its functionalities.

2. Basics of Blockchain

Now you know how the back-end and the front-end work simultaneously in any application.

Next up, you will have to understand the Basics of Blockchain.

Understanding the Terminologies like:

(A) Distributed

(B) Mining

(D) Merkle Tree

and many more

To understand the Basics of Blockchain, the following are some resources that would help you out:

Before diving into various programming languages, it is important for us to understand how the Blockchain is working which will make it easier for us to understand the further steps.

3. Ethereum Blockchain

Although there are several types of Blockchain Platforms like IBM and Hyperledger Fabric. But we are going to use the Ethereum blockchain because Ethereum is one of the oldest and most established blockchain platforms.

For a general overview of how Ethereum works, you can use the following resources provided by its official website hosts:

These resources are full of lots of beginner-friendly content. So you may find them helpful.

4. What is a Smart Contract?

A Smart Contract is simply a program that runs on the Ethereum blockchain. They are a type of Ethereum account.

This means they have a balance and they can send transactions over the network.

If you're just getting started or looking for a less technical introduction, we recommend introduction to smart contracts article to you.

Ethereum has developer-friendly languages for writing smart contracts, such as:

Solidity
Vyper

Solidity is considered the most popular language for writing smart contracts.

If you’re new to the language the official Solidity documentation is a good resource to have handy.

You can also learn the language by playing Crypto Zombies.

Or learn by implementing using some of our articles:

5. Frameworks for Ethereum Blockchain

Next up, there are a few popular frameworks that are generally used by blockchain engineers.

Some of them are:

Hardhat: Hardhat is a development tool used to compile, deploy, test and debug your Ethereum software.

It helps developers manage and automate the recurring tasks that are inherent to the process of building smart contracts and dapps.

Hardhat is one of the most popular tools used by the Blockchain developer.

If you’re new to Hardhat, read their Documentation where they have explained everything about it from scratch.

Truffle: Truffle is an alternative to Hardhat. And it is not only used as a development tool but also used for built-in smart contract compilation, providing an interactive console for direct contract information.

Read Truffle’s documentation to know more about it.

Brownie: Brownie is a framework that builds applications for the EVM but is Python-based, meaning it supports the programming language Vyper, a Python smart contract language.

Brownie also supports Solidity.

It handles deployment, and testing and also supports a mainnet fork.

Read their documentation where they have explained it thoroughly.

Openzeppelin: Openzeppelin is a toolkit with plugins that help build smart contracts faster.

To use any of the smart contracts in Openzeppelin, you must import them into your own smart contract.

It is one of the most popular plugins used by blockchain developers.

6. Tools that’ll help you grow as a Blockchain Developer

Geth: Geth or Go-Ethereum has 3 interfaces that we use for blockchain development:

JSON-RPC server, an interactive console, and Command-Line.

Although it comes with built-in access to testnet Rinkeby, it also allows users to network a local cluster of nodes to create their own Ethereum network.

MetaMask: MetaMask is a browser plugin that serves as an Ethereum wallet. It allows users to store Ether and other ERC-20 tokens, enabling them to make transactions to any Ethereum address.

You can download the Metamask extension using this link.

Remix IDE: Remix IDE is an open-source web and desktop application. Remix is used for the entire journey of contract development with Solidity language as well as a playground for learning and teaching Ethereum.

Node as a Service: Node service providers run distributed node clients behind the scenes for you, so you don’t have to. These services typically provide an API key that you can use to write to and read from the blockchain.

There is a huge debate on whether we should run our own node or use a provider. To know more about it, read our article: *Web3: Should I use Infura / Alchemy or Run a Node?*

Popular Node Services are:

Out of all these node providers, Alchemy is one of the most popular node providers used by blockchain developers.

You can read more about Alchemy here

7. IPFS

Ethereum can be used in code storage in all smart contracts. But is not designed for storing a large amount of data. For this reason, we need a different methodology to store a large amount of data in a decentralized way.

Hence, IPFS is a distributed system for storing and accessing files, websites, applications, and data.
To persist data on IPFS we have to work with a pinning service, which will ‘pin’ your data for you.

Moreover, there are various pinning services that exist to store data on IPFS like Pinata, Web3.storage, and Infura.

8. Practice has the man / woman perfect

The best way to understand anything is by implementing it.

Therefore, here are a few tutorials for the people who are new to the Blockchain Domain.

You can follow along with these tutorials and can add them to your resume and can land into a Great Job!! 😀

Tell us how do you think about this Roadmap by tagging us on Twitter at @uv_labs

Give us a clap if you liked our work.

Authors (open to feedback): 👇

Amateur-Dev and Pari Tomar

Fork 🍴 the F*ing Ethereum Blockchain! Transfer tokens from Vitalik’s Account ;)

Pari Tomar — Sat, 21 May 2022 05:18:09 +0000

Creating a copy of something that already exists is known as Forking

In Blockchain, forking the Ethereum mainnet (or for that matter any testnet) locally means having a copy of the main Ethereum blockchain running on our local computer. Pro tip: there is literally 0 sense for you to fork a testnet; should you think otherwise; let us know.

When we fork 🍴 the mainnet, we have the current state of the blockchain running locally on our system, including all contracts deployed on it and all transactions performed on it.

💣 we have the F*ing mainnet right in our local node; isn’t that 🆒 ?

Why do we need forking?

When working on projects requires interaction with contracts that are already deployed on the mainnet (and obviously the state that they have), forking the mainnet is practically the ONLY feasible option .

Honestly, we have 2 options for testing:

Creating a mock which executes all the necessary functions of already deployed smart contracts. (But this will not potentially give you the same state.) OR
Forking the mainnet.

Creating a mock contract is not the best option because of the following reasons:

Rewriting the existing contract for testing is not such a great practice; also, sometimes it is not one contract but a suite of contracts; and
Executing multiple transactions in order to create the same state in our mock environment is really really difficult! Trust us, it is really difficult!

Hardhat and its relationship with Forking

Hardhat allows us to fork the mainnet by updating a few lines of code in our config file.

In order to get a better grip on mainnet forking, let us run you through an example, in which we will fork the mainnet and transfer Vitalik’s UNI token to our address 😉 .

💻 Let’s dive into the coding! 💻

1. Create a project and initialize it

Use the following commands on your CLI to initialize your project.

mkdir Mainnet-Forking && cd Mainnet-Forking
npm init -y

Install the required dependencies for the project, run

npm install --save hardhat @nomiclabs/hardhat-ethers @nomiclabs/hardhat-waffle ethers

2. Initialize your Hardhat project

To initialize your Hardhat project, run npx hardhat command in your CLI, and create an empty config.js file.

Customize your hardhat.config.js file

We can start an instance of Hardhat Network that forks mainnet. This means that it will simulate having the same state as mainnet, but it will work as a local development network and will allow us to interact with the deployed protocols and test interactions locally.

To execute that update the hardhat.config.js to as follows:

Note: Replace the <key> component of the URL with your personal Alchemy API key. Also, adding blockNumberis optional, but recommended

We recommend Alchemy, because we will need to access a node with archival data for this, and Alchemy provides a free plan for it.

Hardhat allows you to specify a block number. This means that the state of the chain will act as if we were at that given block.

3. Create a Transfer script

Create a new folderscripts in your root directory, and then create a file inside it, named transfer.js
Create an async function, main, and define the ABI.

ABI or Application Binary Interface defines the methods and structures that you can simply use to interact with that binary contract.

Use the following code in your transfer.js script

async function main() {
const abi = [
// Read-Only Functions
"function balanceOf(address owner) view returns (uint256)",
    // Authenticated Functions
"function transfer(address to, uint amount) returns (boolean)",
   ];
}

Magic Time 💫

Now, we’re going to customize the Hardhat Network’s behavior with the help of hardhat_impersonateAccount

You can impersonate an address and use some tokens from that address to test your function. In other words, it allows us to act as if we were the owner of the given account.

Hardhat has provided great documentation on impersonateAccount.

For our transfer script, we’ll be impersonating Vitalik’s address 😎

Use the following code to impersonate his account and assign it as the signer.

const vitalik_address = "0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B";
const uniToken_address = "0x1f9840a85d5af5bf1d1762f925bdaddc4201f984";
const my_address = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
    // impersonating vitalik's account
    await hre.network.provider.request({
        method: "hardhat_impersonateAccount",
        params: [vitalik_address],
    });

    const signer = await ethers.getSigner(
        vitalik_address
    );

Now, we’ll create an abstraction of the UNI contract in order to use the transfer function.

In order to execute the transfer function, we need to provide two arguments:

the address to which we need to transfer the amount
and, the amount we want to transfer

Use the following code:

// uniswap contract
const uniToken = new ethers.Contract(
        uniToken_address,
        abi,
        signer
    );
const vitalik_Balance = (await uniToken.balanceOf(vitalik_address)).toString()

await uniToken.transfer(
        my_address,
        ethers.BigNumber.from(vitalik_Balance)
    );

Here, we have defined the variable vitalik_Balance which stores the total balance of the UNI token in his wallet. Therefore, we’ll be transferring his entire balance to our account.

To check the balance of UNI Token, in your account, after the transaction is done, add the below code to your transfer.js.

// uniswap contract
if ((await uniToken.balanceOf(my_address) == vitalik_Balance)) {
        console.log(`Wohoo!! You now have ${ethers.utils.formatEther(vitalik_Balance)} UNI Tokens!`)
    }

Then call the main function.

Your final transfer.js should look similar to:

It’s time to run the script!!! 🥳

Open your CLI and run the following command:

npx hardhat run scripts/transfer.js

Within a few seconds, you should see the following:

CLI Showing UNI Tokens

You can see that we got a balance of 1615.57647 UNI Tokens in our account (1615576470000000000000 wei, converted to ethers).

Isn’t this amazing!? How we impersonated Vitalik’s account and transferred the token to our address!

In the next article, we’ll continue with mainnet forking and will try swapping the tokens using Hardhat!

Don’t worry, if you get any error messages, you can ask us by tagging @uv_labs on Twitter.

Again, all the code that we just ran through is over here 👉 Github repository. Do give us a star, and clap if you liked our work.

Authors (open to feedback): 👇

Amateur-Dev and Pari Tomar

Learn how to sell your NFTs at the best price using the Dutch Auction Model

Pari Tomar — Sat, 21 May 2022 04:54:37 +0000

Auctions are a popular method to sell out the NFT collection drops at the best price possible.

There are a couple of auction techniques present in order to sell your NFT collection, but Dutch Auction is different from other techniques and is used more often.

Unlike a regular auction, in Dutch Auction, prices start very high and then slowly drop at predetermined time intervals.

In simpler words, in a Dutch Auction, the price of an NFT starts at an initial price (ceiling) and drops by a fixed amount periodically (eg. 0.1 ETH every 10 min) until it hits the lowest price it can go (the resting price)

Why Dutch Auction is so popular?

One of the reasons can be linked to the gas wars on the blockchain.

Gas wars are the spike in the blockchain gas fees that occurs when a high volume of transactions is initiated around the same time on blockchains like Ethereum, which has a low transaction throughput.

The Dutch auction style is used to redirect the excess minting fee from the miners towards the artists or channeled to fund specific charities or a community DAO.

So without anymore time, let’s write the Dutch Auction smart contract to sell our NFT!

Prerequisites:

In order to mint our NFT and sell it using Dutch Auction, we are going to create an NFT contract using one of our previous articles, and copy the contract from there.

Refer to this article or github repo to get the NFT smart contract.

Create a new file in your Remix IDE named as NFT.sol and paste the contract we used above.

Now we are good to go!

Let’s do some Dutch Auction 😎

1. Write our Smart Contract

Create a new solidity file in your Remix IDE and name it as DutchAuction.sol

Create an IERC-721 interface and then initialize your Dutch Auction contract.

Use the following code for reference:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

interface IERC721 {
    function transferFrom(
        address _from,
        address _to,
        uint _nftId
    ) external;
}
contract DutchAuction { }

Once you’ve initialized your contract, we are going to define some variables that we have to use in our contract.

First, we are going to define the duration of the auction. That means the auction for the NFT will be expired after that duration. And we will define the duration for 2 days.
Next, we need to store the address of the NFT and its ID. Therefore, we will use IERC721 interface to store the NFT.

We made this variable immutable so that its value does not change once the contract is deployed.

Then, we going to store the address of the seller. Thus we will define the variable seller which will be storing the seller’s address.
The Dutch Auction needs a starting price. So we are going to define a variable startingPrice
We also need the timestamp of when the auction starts and when the auction ends. Therefore, we will define 2 variables, startAt and expiresAt which will store the respective values.
Lastly, we will define the discountRate. DiscountRate will determine the rate at which the price decrements, starting from the startingPrice.

uint private constant DURATION = 2 days;
IERC721 public immutable nft;
uint public immutable nftId;
address public immutable seller;
uint public immutable startingPrice;
uint public immutable startAt;
uint public immutable expiresAt;
uint public immutable discountRate;

Next, we will initialize these state variables in a constructor.

Inside it, we are going to pass in the _startingPrice, _discountRate, _nft, and _nftId.

constructor(
        uint _startingPrice,
        uint _discountRate,
        address _nft,
        uint _nftId
    ) { }

Inside the constructor, we will set the seller to the deployer of this contract. And once the NFT will be sold, we need to transfer the ETH to the seller, therefore we will make it payable.

seller = payable(msg.sender);
We will take the input from the user to get the startingPrice, discountRate, startAt and expireAt. So, we will write it as:

startingPrice = _startingPrice;
discountRate = _discountRate;
startAt = block.timestamp;
expiresAt = block.timestamp + DURATION;
We will also check whether the price of the NFT is always greater than zero or not.

_startingPrice >= _discountRate * DURATION, "Starting Price is less than the discount offered"

_discountRate * DURATION is the maximum amount of price deduction that is applied to the startingPrice

Lastly, we set the NFT using the input. So we can say:

nft = IERC721(_nft);
nftId = _nftId;

Now since our constructor is complete.

Next, we’re going to define 2 functions that we will be using further: currentPrice() and buyNow()

Using currentPrice(), we will know the price of the NFT at that particular instance of time.

For that, we will write:

function currentPrice() public view returns (uint) {
        uint timeElapsed = block.timestamp - startAt;
        uint discount = discountRate * timeElapsed;
        return startingPrice - discount;
}

Next, using the buyNow() function, the user will be able to buy the NFT.

function buy() external payable {
require(block.timestamp < expiresAt, "Auction expired! :(");
uint price = currentPrice();
require(msg.value >= price, "ETH is less than the price");
nft.transferFrom(seller, msg.sender, nftId);
selfdestruct(seller);
}

In this function, first, we’ll check whether the auction is expired or not.

If the auction is not expired, then we will get the current price and store it inside the price variable using the currentPrice function.

Next, we will check that the amount we have sent is greater than or equal to the price.

Once we know that the msg.sender has sent enough ETH to buy the NFT, we will transfer the ownership of the NFT using the 3 parameters: seller, msg.sender, nftId.

Last but not the least, we have used the selfdestruct() function to close the auction. Therefore, we will pass the seller address inside the function.

Guess what?

We have completed our Dutch Auction Smart Contract!! 🎊

Your contract should look like this 👇

Next, we’re going to test our Dutch Auction smart contract by selling our NFT. 😮

2. Mint our NFT using its tokenURI

Remember we created a file NFT.sol at the first place of this article?

Now we will deploy that NFT and then call the mint function using its tokenURI.

Once we have minted our demo NFT. Next we are going to deploy our Dutch Auction contract.

3. Deploy the Dutch Auction contract

Compile the Dutch Auction contract and then deploy it.

There are some parameters we have to pass in order to deploy our contract.

We will get the startingPrice to 1000000, discountRate at 1*,* the address of the NFT which we deployed just a while before and lastly, we have to provide the ***tokenId* which is equal to 1.

Once you’ve added the parameters, hit the Deploy button to deploy our contract.

Once our Dutch Auction contract is deployed. Next thing we’re going to do is approve the Dutch Auction to spend our NFT.

For that, we will open our NFT under Deployed Contracts and execute the approve function.

We need to pass the Dutch Auction’s deployed address and the tokenId of the NFT to run the approve function.

So now our DUTCH AUCTION HAS STARTED!!

To check whether the Dutch Auction has started or not, open the deployed Dutch Auction contract and run the currentPrice function several times. You’ll notice everytime you run the function, you’re getting a decremented price value.

Now its time to sell our NFT.

4. Sell our NFT using Dutch Auction contract

First, run the currentPrice function and copy the price value.

And then switch to some other account, from which you want to buy the NFT and paste the price value under the value option.

And then run the buyNow function.

GUESS WHAT!?

You just sold your NFT using Dutch Auction!! 😍

If you go back to your NFT contract and run the ownerOf function, you can see the owner of the contract is updated.

And this is how we can sell our NFT using the Dutch Auction!!!

If you liked the article, do give us a clap. 👏

And don’t worry, if you get any error message, you can ask us by tagging @uv_labs on Twitter.

Authors (open to feedback): 👇

Amateur-Dev and Pari Tomar