DEV Community: Ali Murtaza Memon

How does Chainlink collect data from Off-Chain Sources? — Data Feeds Explained

Ali Murtaza Memon — Sat, 01 Apr 2023 16:28:58 +0000

Smart contracts are an exciting innovation in the blockchain space that enables the automated and trustless execution of complex agreements between parties. However, smart contracts are limited by their inability to access off-chain data, which can have a significant impact on the outcome of the contract. That’s where Chainlink’s Data Feeds come in.

Chainlink Data Feeds provide secure and reliable access to real-world data sources that smart contracts need to function correctly. This allows smart contracts to access off-chain data, such as market prices, weather conditions, or other external events that can impact the contract’s outcome. By integrating Chainlink’s Data Feeds, smart contracts can execute more complex use cases and unlock new possibilities that were previously impossible.

In this blog, we will take a closer look at Chainlink’s approach to collecting data from off-chain sources, the role of consensus in ensuring data accuracy, and how this data is provided to smart contracts. We’ll explore how Chainlink’s Data Feeds are helping to unlock new possibilities in decentralized applications.

CHAINLINK ARCHITECTURE

Chainlink uses two architectural models such as the Off-Chain Reporting and Decentralized Data Model, to retrieve data from off-chain sources and transfer it to smart contracts.

Off-Chain Reporting

Chainlink leverages Off-Chain Reporting (OCR) to ensure decentralized data collection from off-chain sources. OCR involves multiple node operators who are responsible for providing data for specific data feeds. Protocol execution occurs predominantly off-chain over a peer-to-peer network between Chainlink nodes. The nodes periodically elect a new leader node, which drives the remainder of the protocol. During communication, a lightweight consensus algorithm runs in which each node reports its data observation and signs it.

The leader node routinely requests followers to provide freshly signed observations, which it aggregates into a report. It then sends this report back to the followers and asks them to verify its validity. If a required number of followers approve the report by sending a signed copy back to the leader, the leader assembles a final report with the quorum’s signatures.

Subsequently, the leader node submits a transaction with the aggregated report to the on-chain aggregator. Each report comprises many nodes’ observations and must be signed by a quorum of nodes.

All nodes monitor the blockchain for the final report to eliminate any single point of failure during transmission. If the designated node fails to confirm its transmission within a specified period, a round-robin protocol takes effect so that other nodes can also transmit the final report until one of them is confirmed.

Submitting only one transaction per round delivers numerous advantages, including reduced network congestion from Chainlink oracle networks, lower gas costs for individual node operators, improved scalability for node networks, and more timely updates for data feeds, as each round no longer needs to wait for multiple transactions to confirm before a price is confirmed on-chain.

Decentralized Data Model

The decentralized Oracle network contains three components:

An Aggregator Contract
A Proxy Contract
A Consumer Contract

An Aggregator Contract

After the report is conveyed to the on-chain aggregator, it undergoes a verification process wherein the aggregator confirms that a requisite number of nodes have signed the report and also checks the validity of these signatures. Subsequently, the aggregator publishes the median value to the consumer contracts along with a block timestamp and a round ID.

Aggregators are updated by the oracle network only if one of two threshold conditions is met:

Deviation Threshold: A new aggregation round is initiated by the nodes when the off-chain value of a price feed deviates from the on-chain value by an amount greater than the defined deviation threshold (each price feed has a different deviation threshold value which you can see at data.chain.link). This ensures that the updated values of the price feed are accurately reflected on-chain. For example, in the case of ETH/USD if the off-chain price deviates from 0.5 % then the new data aggregation round starts and repeats the same process.
Heartbeat Threshold: In addition to the deviation threshold, a new data aggregation round is also initiated when the heartbeat threshold is reached, even if the price deviation remains within the deviation threshold. The heartbeat threshold is the specified time interval between two consecutive data updates.

A Consumer Contract

The consumers are our smart contracts which inherit the aggregator interface (for example AggregatorV3Interface) and calls one of the exposed functions of the data to feed the aggregator.

A Proxy Contract

Proxy contracts are on-chain proxies that point to the aggregator for a particular data feed. Using proxies enables the underlying aggregator to be upgraded without any service interruption to consuming contracts.

Conclusion

In conclusion, Chainlink provides a decentralized infrastructure that enables smart contracts to securely access off-chain data sources. This is achieved through a network of independent node operators that retrieve and verify data from various sources. By using a decentralized approach, Chainlink eliminates the single point of failure and ensures the reliability and accuracy of the data. This allows smart contracts to be executed with confidence, unlocking a wide range of new use cases and applications for blockchain technology.

This comprehensive guide aims to provide assistance to developers of all skill levels and is intended to be beneficial for a wide range of developers. The information provided is intended to be easily understandable and actionable for all readers.

If you found this content helpful, please consider giving it a clap and leaving any feedback for future improvements. Your suggestions and comments are greatly appreciated and will help make these articles even more valuable for you and other readers.

Be sure to follow me to receive updates on my future articles and stay informed of new content.

Thank you

@alymurtazamemon

Deploy Smart Contract On Any EVM Chain using thirdweb

Ali Murtaza Memon — Fri, 24 Mar 2023 19:07:25 +0000

“Exploring the Deployment of Smart Contracts on Various EVM Chains with thirdweb”

Blockchain technology has opened up a new world of possibilities for developers to create decentralized applications that can revolutionize various industries. Smart contracts are an essential component of these decentralized applications as they enable developers to build trustless systems that can execute automatically without the need for intermediaries.

Ethereum Virtual Machine (EVM) is a popular blockchain platform that supports the execution of smart contracts. However, with the rise of other EVM-compatible blockchain networks like Binance Smart Chain and Polygon, developers now have more options to choose from. In this blog, we will explore how to deploy smart contracts on various EVM chains using Thirdweb.

Thirdweb is a blockchain infrastructure provider that offers a suite of tools and services for developers to easily build and deploy decentralized applications (DApps) on various blockchain networks. It provides a user-friendly interface for interacting with blockchain networks, allowing developers to create or import, and deploy smart contracts and DApps with ease. Thirdweb also offers hosting solutions, data storage, and other developer tools to make the development and deployment process smoother and more efficient.

Create a Project

Let us delve into the process of creating a smart contract from the ground up using the thirdweb framework, and subsequently deploying it to any Ethereum Virtual Machine (EVM)-compatible blockchain.

Navigate to the desired directory where you wish to initialize the project in your terminal and execute the following command:

npx thirdweb create contract

After executing the aforementioned command, a verbose message from the thirdweb framework will appear on your terminal prompt. The message will prompt you to enter a name for your project. Please enter a name of your choice. For this example, we will use thirdweb-demo.

Subsequently, you will be prompted to select the framework of your choice to create your smart contract. For the purpose of this demonstration, we will be selecting Hardhat.

Following the selection of the framework, you will be prompted to enter the name of your smart contract. In this example, we will be utilizing the basic Box smart contract for demonstration purposes, and thus we will name it accordingly.

**Improve the feature — thirdweb Team:* The thirdweb team, I would like to bring to your attention that the name prompt feature does not appear to be functioning as intended. Upon execution, an empty contract labeled “MyContract” with a file name “Contract.sol” is generated, instead of using the name provided through the prompt. It would be beneficial if this feature were to be updated such that the file and contract name are derived from the user input provided through the prompt.*

Following the previous step, you will be prompted to select the type of smart contract you wish to utilize. Several options will be presented to you, including ERC20, ERC721, and ERC1155 compatible contracts. For this demonstration, we will be selecting the “Empty Contract” option.

Upon selecting the desired smart contract type, the necessary project dependencies will be installed automatically. Once the installation process is complete, you may proceed to open the project in your preferred code editor. For the purpose of this article, we will be utilizing VSCode.

Deploy Any Smart Contract

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


contract Box {
    uint256 private value;

    event ValueChanged(uint256 indexed value);

    function store(uint256 _value) external {
        value = _value;
        emit ValueChanged(_value);
    }

    function retrieve() external view returns (uint256) {
        return value;
    }
}

After opening the project in your preferred code editor, please navigate to the “contracts” directory and rename the default Contract.sol file to Box.sol. Once renamed, please replace the contents of the file with the provided Box smart contract code.

Additionally, you will need to ensure that the Solidity version specified in the hardhat.config.js file is compatible with the version utilized in your smart contract(s). In this case, since the provided Box smart contract code is written in version 0.8.17, we will need to update the version specified in the hardhat.config.js file to match. For example, we would update the version from 0.8.9 to 0.8.17 to ensure compatibility.

Deploying

yarn deploy

After successfully compiling the code, the smart contract can be deployed to any blockchain utilizing the thirdweb framework. To do so, please execute the above command.

That’s it! 🥳 This command does the following:

Compiles your contract
Uploads your contract source code (ABI) to IPFS
Opens the dashboard for you to select one of the supported networks to deploy to

Please note that in the event that the dashboard does not open automatically, you may access it manually by clicking on the provided link within the terminal.

Upon accessing the dashboard, you will be presented with the details of your smart contract, as well as the network settings. By default, the network will be selected based on the network selected within your Metamask wallet. However, you may also choose to select a different network from the available options within the dropdown menu.

In the event that your preferred network is not available within the dropdown menu, you may select the “Configure Networks” button to access a list of available networks. From here, you may search for and add your preferred network to the list of available networks.

Furthermore, you also have the option to add custom networks by providing the relevant information within the “Custom Network” tab. This allows you to connect to and deploy your smart contract on any network of your choosing, regardless of whether it is listed within the preconfigured options or not.

Once you have successfully configured your desired network, it will be available within the dropdown menu for selection. From here, you may select the network and proceed to deploy your smart contract on it.

Upon selecting the “Deploy Now” button, the deployment process for your smart contract will commence. A pop-up from your Metamask wallet will appear requesting your confirmation to proceed with the deployment. Upon confirming, the smart contract will be successfully deployed and another signature request will appear, allowing you to add the deployed smart contract to the thirdweb dashboard for further interaction and management using the dashboard’s features.

Manage Your Smart Contract — thirdweb Dashboard

Upon successfully adding your smart contract to the thirdweb dashboard, the dashboard for your contract will be automatically opened, displaying all the relevant details and options for interacting with your smart contract through the dashboard.

Overview Tab

In the Overview tab of the contract dashboard, you can see a list of all the events emitted by your Box smart contract, along with their timestamps. This can be useful for tracking the state changes and activity of your smart contract over time. Additionally, you can view any extensions that are available for your smart contract, which can add additional functionality and features to your smart contract.

You can view the details of your Box smart contract, including its functions, events, and variables, as well as its current state and transaction history, on the contract dashboard within the thirdweb dashboard. From there, you can interact with the smart contract by calling its functions, sending transactions, and monitoring its events and state changes in real time.

0x55...3b6 | sepolia

Build web3 apps easily with thirdweb's powerful SDKs, audited smart contracts, and developer tools—for Ethereum & 700+ EVM chains. Try now.

thirdweb.com

Build Tab

In the Build tab, you can find information on how to interact with your smart contract using various programming languages and frameworks such as JavaScript, React, Python, and Unity. It provides code snippets that illustrate how to read and write to the smart contract using these languages or frameworks. This can be useful for developers who want to integrate their smart contracts with their existing projects or application.

Explorer Tab

It is important to note that the Explorer tab provides an overview of the functions available in the smart contract, both the read-only functions (also known as constant functions) and the write functions.

When you click on a write function, such as the store function in our Box contract, the Explorer tab will display information about the function, including its name, input parameters, and whether it is payable or non-payable. It will also provide a text field where you can input the data that will be passed to the function when it is executed.

By providing the required input data and clicking the execute button, you can directly interact with the smart contract and execute its functions from the thirdweb’s dashboard, without the need to write any code.

Events Tab

The Events tab provides a list of events that are triggered by your smart contract. When you execute the store function from the Explorer tab, the event triggered by the function can be seen in this tab.

Sources Tab

Additionally, the thirdweb dashboard provides Settings and Sources tabs that offer additional functionality. In the Settings tab, you can view and modify the project-related settings. The Sources tab, on the other hand, allows you to access the source code of your smart contract, as well as its ABI.

In the sources tab, you can also verify your smart contracts on Etherscan with just one click, directly from the thirdweb dashboard.

Note: Please note that I am showing you my previously deployed smart contract on the Goerli network since the option to verify contracts on Sepolia is currently unavailable.

Importing Any Contract on thirdweb’s Dashboard

Furthermore, Thirdweb provides the functionality to import any previously deployed smart contract on the blockchain into the Thirdweb dashboard for further usage and interaction.

You can view your contract here;

Contracts Dashboard: https://thirdweb.com/dashboard/contracts

Clicking on the “Import Contract” button will bring up a popup window where you can enter the address of the deployed contract and select the network it was deployed on.

After clicking the “Import” button, thirdweb will retrieve comprehensive information about the targeted smart contract and display it in the dashboard, allowing for seamless use of the contract.

NOTE: It is critical to ensure that the smart contract being imported is verified in order for thirdweb to retrieve relevant details accurately. As a result, it is strongly advised that the contract be verified before beginning the import process.

You can read more about this feature from thirdweb’s blog post on ‘Any EVM, Any Contract’

Conclusion

In conclusion, thirdweb provides a user-friendly and efficient platform that enables developers to deploy smart contracts on any EVM chain seamlessly. By leveraging thirdweb’s robust features and capabilities, users can easily import, deploy, and interact with smart contracts, regardless of the underlying blockchain network. With thirdweb’s intuitive interface, developers can focus on building and refining their smart contract applications, while leaving the complexities of blockchain technology to the platform. As such, thirdweb offers an accessible and reliable solution for anyone seeking to harness the potential of smart contracts on EVM chains.

This comprehensive guide aims to provide assistance to developers of all skill levels and is intended to be beneficial for a wide range of developers. Despite its length, the information provided is intended to be easily understandable and actionable for all readers.

Be sure to follow me to receive updates on my future articles and stay informed of new content.

Thank you

@alymurtazamemon

What are Oracles? & How is Chainlink Leading to Provide Optimal Solutions?

Ali Murtaza Memon — Sun, 19 Mar 2023 19:41:28 +0000

“Understanding the Role of Data Connectivity in Decentralized Applications and Chainlink’s Innovations in Meeting Industry Demands”

Smart contracts cannot access real-world data directly because they are executed within a blockchain network, which is a self-contained environment that operates independently of external systems. The purpose of a blockchain network is to maintain a distributed ledger of transactions that is secured through cryptography and consensus algorithms. To access data from external sources, smart contracts need to rely on intermediaries known as oracles.

What is an Oracle?

An oracle is a mechanism in blockchain technology that connects the blockchain to off-chain data sources such as APIs or real-world events.

A blockchain is a distributed database that relies on participant consensus to validate transactions and keep a single version of the truth. Blockchains, on the other hand, are typically isolated from external data sources and cannot directly access information from the outside world. This limitation can be problematic for applications that require information from external sources to execute smart contracts or other blockchain operations.

An oracle acts as a connector between the blockchain and external data sources, allowing blockchain applications to access real-world data. Oracles typically receive data from off-chain sources and transmit it to the blockchain in a format that smart contracts and other applications can use.

Key Considerations for Choosing a Blockchain Oracles

Despite the number of options available in the Web3 space, selecting the right Blockchain Oracle solution provider is a critical step for the success of your decentralized applications.

Here is a list of factors to consider:

Decentralization: It is a crucial factor to consider when selecting a Blockchain Oracle solution provider. Centralized oracles can pose a significant risk, as they have the power to control the data utilized in your dapps. This can be especially problematic for applications such as DeFi, where the financial assets of users are at stake.
Data Quality: It is critical to ensure the accuracy and dependability of Oracle data consumed by dapps. It is critical to ensure that the data is of high quality, up to date, and derived from reliable and authenticated sources. Failure to do so may seriously damage the financial assets of your users, and will risk the dapp’s success.
Security: Ensuring the security of the data provided by an oracle that feeds into your decentralized applications (dapps) is very important. A compromised oracle solutions provider not only compromised its own solutions but also endangers the integrity of your dapps and their users. Such a scenario is commonly referred to as an “Oracle Attack” in the blockchain industry. To safeguard against this risk, it is important to opt for a decentralized oracle with a proven track record of security and robust measures in place to protect both their systems and the data provided to your dapps.
Cost: As we know that each blockchain transaction has a real financial cost, it is critical for dapp developers to choose an oracle solution provider that not only satisfies the above-mentioned requirements but also takes into account the particular requirements and preferences of their dapps and user base.

While there may be additional factors to consider, the above-mentioned criteria are the primary considerations that should guide the selection of an oracle for your dapp.

How is Chainlink Leading to Provide Optimal Solutions?

The Chainlink Network is composed of the highest-quality, Sybil-resistant oracle nodes that are operated by leading DevOps and security teams, such as Deutsche Telekom’s T-Systems, who have decades of experience running mission-critical infrastructure. The security-reviewed and tamper-resistant nodes that comprise Chainlink oracle networks are highly transparent. Their performance metadata is made publicly available to users and can be found on-chain or on third-party sites such as market.link.

Chainlink also employs a defence-in-depth approach where multiple security solutions are used in combination to increase oracle network robustness and reliability. This includes privacy-preserving cryptography like DECO, trusted hardware such as Town Crier, crypto-economic security through implicit/explicit staking, and much more.

We previously discussed the importance of decentralization, high-quality and up-to-date data, security, and cost-effectiveness in an oracle solution provider. In each of these areas, Chainlink has made significant strides to offer optimal solutions for dapps.

Here are some of the ways:

Decentralized Oracle Network: The Chainlink Network is made up of multiple decentralized oracle networks running simultaneously and independently of one another. For example, if a smart contract requires data about the price of ETH/USD, instead of relying on one individual blockchain oracle to pull price data from one API source, the smart contract can use a decentralized oracle network to have multiple oracle nodes pull data from several different API sources and then aggregate the result. Through decentralized computation, Chainlink-powered decentralized oracle networks provide users superior security and reliability guarantees on the inputs and outputs of their smart contract, ensuring that both on-chain and off-chain components of a decentralized application are tamper-proof end-to-end.
Reputation System: By rewarding nodes for good behaviour and punishing them for bad behaviour, Chainlink’s reputation system encourages nodes to provide accurate data. This makes it possible to guarantee that nodes only offer reliable, high-quality data.
Multiple Data Sources: Chainlink aggregates data from multiple sources to ensure that the data is accurate and trustworthy. This helps to mitigate the risk of any single source being compromised or providing incorrect data.
Data Verification: Chainlink offers a variety of data verification methods, including cryptographic proofs and on-chain verification, to ensure that data is accurate and has not been tampered with.
Audits: Chainlink is subjected to regular audits by reputable third-party firms to ensure the system’s security and lack of vulnerabilities. This helps to ensure that data quality and system reliability are maintained.

Chainlink’s Products

Data Feeds

Chainlink Data Feeds are decentralized oracle networks that provide aggregated financial market data used by leading DeFi applications such as Aave, Synthetic, Compound, and more. Powered by a multitude of professional, security-reviewed oracle nodes and premium data aggregators, these purpose-built price feeds provide broad market coverage on a wide array of assets and enable developers to rapidly create innovative smart contract applications that require a secure source of external market data.

Chainlink Data Feeds are a community resource sponsored by a large collection of users and Chainlink, creating highly secure and decentralized oracle networks through the aggregation of user fees. With each additional user, existing and future users gain the benefits of a more cost-efficient and secure oracle network than they could afford on their own. As the DeFi ecosystem has grown, Chainlink Data Feeds have become a widely adopted solution that is lowering the barrier to creating highly secure financial smart contract applications.

Verifiable Random Function (VRF)

Chainlink VRF brings secure random number generation to the blockchain. Chainlink VRF solves the difficult problem of providing an on-chain source of randomness that is publicly verifiable to be authentic and tamper-proof. Many smart contracts are augmenting the value they can create by utilizing Chainlink VRF, specific applications such as gaming dApps that must prove to their users that their source of randomness is provably fair and resistant to manipulation from any external entity. Chainlink VRF enables and accelerates the development of smart contracts focused on blockchain gaming, security, layer-two protocols, and various other use cases.

Automation

Chainlink Automation is a decentralized solution that enables projects to run key smart contract functions and DevOps tasks automatically in a highly reliable, trust-minimized, and cost-efficient manner. Individual developers, teams, and DAOs can utilize Chainlink Automation as an off-chain computation layer to reliably perform key functions and unlock advanced utility.

A decentralized network of nodes provides trust-minimized and reliable automation with no single point of failure, mitigating risks around manual interventions or centralized servers. Projects using Chainlink Automation are able to reduce time spent on DevOps, eliminate automation infrastructure costs, and build faster and more efficiently.

Functions

Chainlink Functions provides our smart contracts with access to a trust-minimized compute infrastructure. Our smart contract sends our code to a Decentralized Oracle Network (DON), and each DON’s oracle runs the same code in a serverless environment. The DON aggregates all the independent runs and returns the final result to our smart contract. Our code can be anything from simple computation to fetching data from API providers.

Chainlink Functions provides access to off-chain computation without having to run and configure our own Chainlink Node. To pay for requests, we fund a subscription account with LINK. Our subscription is billed only when the DON fulfils our request.

APIs

Connecting to any API with Chainlink enables our contracts to access any external data source through Chainlink’s decentralized oracle network. Making smart contracts compatible with off-chain data adds to the complexity of building smart contracts. Due to that, Chainlink has created a framework with minimal requirements, yet unbounded flexibility, so developers can focus more on the functionality of smart contracts rather than what feeds them. Chainlink’s decentralized oracle network provides smart contracts with the ability to push and pull data, facilitating the interoperability between on-chain and off-chain applications.

Whether our contract requires sports results, the latest weather, or any other publicly available data, the Chainlink contract library provides the tools required for our contract to consume it.

Conclusion

In conclusion, oracles play a crucial role in enabling smart contracts to access and interact with external data sources, making them more powerful and versatile. However, the accuracy and security of these oracles are critical for the success and adoption of decentralized applications, especially in the rapidly growing DeFi space.

Thank you for reading this article, which provides an introduction to oracles, Chainlink, and its products. In future articles, we will delve deeper into Chainlink’s products and explore their technical implementation.

Be sure to follow me to receive updates on my future articles and stay informed of new content.

Thank you

@alymurtazamemon

Becoming a Blockchain Developer: A Step-by-Step Guide for Beginners

Ali Murtaza Memon — Mon, 30 Jan 2023 15:07:01 +0000

“From Zero Knowledge to Building Decentralized Applications”

Blockchain technology has taken the world by storm, and it’s no surprise that many individuals are interested in becoming blockchain developers. However, the journey to becoming a skilled blockchain developer can be overwhelming, especially for those starting with zero knowledge. With the plethora of information and resources available, it can be difficult to determine the best path to follow.

As a result, it’s common for aspiring blockchain developers to have questions about which programming language to learn first, whether to start with front-end or back-end technologies, and whether it’s possible to dive directly into Solidity without prior programming experience.

As a professional in the field, it’s essential to guide and support those who are eager to join the blockchain industry. In this article, I aim to provide a comprehensive roadmap for individuals who are looking to break into blockchain development and help them navigate the journey from zero knowledge to building decentralized applications. By covering the key skills and technologies required, this guide will serve as a valuable resource for anyone seeking to start a career in blockchain development.

Note: It is important to acknowledge that this guide is solely based on the my personal experience in becoming a blockchain developer and there may be alternative methods available.

1. Need-Based Learning

With five years of experience in software development, I have come to understand that it is not feasible or necessary to attempt to acquire knowledge of every tool, technology, or programming language in the constantly evolving field of software engineering. The sheer volume of information and advancements renders it impossible to retain proficiency in all areas. Thus, it is more efficient and effective to adopt a need-based approach to learning, focusing on acquiring skills and knowledge as they become necessary in one’s work.

2. Learning Programming Fundamentals

Adhering to a need-based approach to learning, proficiency in a programming language is deemed a foundational requirement for those aspiring to become software engineers or blockchain developers.

For this reason, it is critical to invest time and effort in strengthening your programming fundamentals before venturing into the frontend, backend, or blockchain development.

However, I do not recommend starting with JavaScript or Solidity as a first programming language. JavaScript may not be well suited for practising fundamental programming concepts and Solidity’s additional complexities could hinder the development of a strong understanding of programming fundamentals.

Instead, I would suggest you begin by learning C++ or Java ( with a particular emphasis on Java) to familiarize yourself with programming basics and engage in extensive practice to master fundamental programming concepts.

Here you can find The Most Popular Coding Challenge Websites.

I know you want to become a blockchain developer and this thing will take lot of your time but believe me for strong buildings foundation is very important.

At this stage, it is expected that you have attained a robust grasp of programming concepts and have engaged in substantial hands-on practice, completing at least 100 to 500 coding exercises on the above websites.

I would also recommend you learn and practice Data Structure & Algorithms (if you have time) before going further.

I took this course Data Structures and Algorithms: Deep Dive Using Java but you can select any other (This is not promotional).

3. Learning Blockchain Fundamentals

Having mastered the fundamentals of programming, the next step is to delve into the fundamentals of blockchain technology and gain a comprehensive understanding of its core concepts.

For that, I would recommend downloading this free guide Certified Blockchain Business Foundations (CBBF).

In addition to this guide, you can also look for other courses on Coursera, YouTube or any other platform.

4. Learning JavaScript & Solidity Programming

Prior to embarking on a blockchain development course, it is advisable to gain proficiency in JavaScript and Solidity. The majority of blockchain development tools utilize JavaScript, and the ability to write smart contracts requires a solid understanding of Solidity.

JavaScript Course: JavaScript Algorithms and Data Structures

Solidity Course: Solidity: Beginner to Intermediate Smart Contracts (only Starting 5 Lessons)

5. Blockchain Development Courses

It is worth mentioning that up until this point, we have not covered front-end development technologies. This is in line with the principle of need-based learning, as we have not yet encountered a requirement for such knowledge in the context of blockchain development.

However, it should be noted that certain portions of the courses to be discussed may touch upon front-end technologies. These lessons, while informative, are not crucial for you to pursue as a blockchain developer and can be disregarded if desired.

Learn Blockchain, Solidity, and Full Stack Web3 Development with JavaScript — 32-Hour Course

Ethereum Development Bootcamp — Alchemy

6. Frontend Technologies — Full Stack Blockchain Development

At this stage, you will have acquired expertise in smart contract development and will be capable of deploying, testing, and verifying contracts using Hardhat. If you are solely interested in solidity development, you can proceed to the next section and focus on creating smart contracts for portfolio projects. However, if you wish to delve into frontend application development for your smart contracts, it is recommended to familiarize yourself with these technologies in the following sequence.

Learn HTML and CSS

Learn Flexbox for free

Learn CSS Grid for free

Learn React for free

Advanced React

Tailwind Crash Course

Next.js React Framework Course

Note: It is important to engage in sufficient hands-on practice using React.js before developing projects utilizing Next.js.

Upon completion of these courses, you will have acquired the necessary skills to develop front-end applications for your smart contracts and assemble full-stack blockchain projects. It is now time to build your portfolio.

7. Build Your Portfolio

Having attained proficiency in various programming languages, tools, and frameworks, it is now time to put acquired knowledge into practice by developing portfolio DApps.

You can get the ideas from these platforms:

Buildspace

SpeedRunEthereum

Road to Web3

Conclusion

In conclusion, becoming a blockchain developer requires a solid understanding of programming fundamentals, followed by learning the basics of blockchain technology and the necessary languages and tools. This process involves developing strong programming skills through practice, deep diving into blockchain, and then learning JavaScript and Solidity. Building a portfolio of full-stack blockchain projects is the final step in this journey and will help demonstrate your skills to potential employers. With dedication and effort, anyone can become a blockchain developer and make a positive impact in this growing field.

Be sure to follow me to receive updates on my future articles and stay informed of new content.

Thank you

@alymurtazamemon

Verify your Smart Contracts on Etherscan Programmatically using Hardhat

Ali Murtaza Memon — Sat, 28 Jan 2023 16:24:16 +0000

A step-by-step guide to verifying your smart contracts on Etherscan using Hardhat

Verifying your smart contracts is a crucial step in ensuring the transparency and trustworthiness of blockchain-based applications. Making the contract’s code publicly accessible and providing proof of deployment on the blockchain allows for independent verification of the contract’s functionality. This not only builds trust among users but also increases the contract’s visibility and credibility.

In addition to that, having a verified contract can make it more easily discoverable by potential users and can help to increase the contract’s visibility and credibility.

In this article, we will explore the process of programmatically verifying smart contracts on Etherscan using the Hardhat. By the end of this guide, you will have a thorough understanding of how to use Hardhat to automate the contract verification process on Etherscan, thus streamlining the smart contract deployment process.

Let’s delve into the details and learn how to verify smart contracts on Etherscan using Hardhat.

The process of programmatically verifying smart contracts on Etherscan can be accomplished using the Hardhat in two different ways.

Writing a custom verification script using Hardhat, which can be run at any time to verify contracts on Etherscan
Implementing a professional approach to automatically verify smart contracts upon deployment to the testnet or mainnet.

As previously discussed in Learn to Deploy Smart Contracts more Professionally with Hardhat article, managing smart contract scripts can present challenges for developers as a project grows in size and complexity. As the project scales, the complexity of managing smart contract scripts also increases, making it a headache for developers to keep track of the changes and maintain the integrity of the project.

In order to fully understand and implement the second approach for automating the verification process, it is recommended that you first read the above article.

Projects Configuration for Verification

Create a new Hardhat Project
Remove the default contract, script and test files provided by Hardhat. These files can be found in the contracts/, scripts/, and test/ folders, they should be removed to avoid confusion and potential errors.
Get the API Key from Etherscan https://etherscan.io/.
Create the .env file at the root location.
Add the .env file inside the .gitignore file. Make sure you must follow this step because later we will add the PRIVATE_KEY in this file.
Create an Etherscan API key variable inside .env the file and add your key as a value for this variable like this ETHERSCAN_API_KEY=DR9....
Install the dotenv a package so we can load the env file variables in our scripts. Run the command in the terminal npm i --save-dev dotenv --force.
Import the dotenv package inside the hardhat.config.js or hardhat.config.ts file like this require(“dotenv”).config() (JavaScript) or import “dotenv/config” (TypeScript).

Add the Sample Smart Contract for Verification

This smart contract will be utilized for verification purposes.

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

contract SimpleStorage {
    uint private storedData;

    function set(uint x) public {
        storedData = x;
    }

    function get() public view returns (uint) {
        return storedData;
    }
}

Create a file called SimpleStorage.sol inside the contracts folder and add this to it.
Compile the smart contract by running the command npx hardhat compile

Writing a Custom Verification Script

To verify the functionality of this smart contract, it must first be deployed on a specific network. Utilizing the deployed contract’s address, the smart contract can then be verified on Etherscan.

To do this Create a file called verify-simple-storage.js or verify-simple-storage.js inside the scripts folder and add this code inside it;

Note: Please note that both JavaScript and TypeScript code will be provided throughout this article. Kindly select the appropriate code examples based on the language being utilized in your implementation.

// JavaScript
import { ethers, network, run } from "hardhat";

async function verifyContract() {
    const chainId = network.config.chainId;

    const simepleStorageFactory = await ethers.getContractFactory(
        "SimpleStorage"
    );

    const args = [];

    console.log(`Deploying...`);
    const simpleStorage = await simepleStorageFactory.deploy(args);
    await simpleStorage.deployed();
    console.log(`Deployed!`);
    console.log(`Simple Storage Address: ${simpleStorage.address}`);

    console.log(`Waiting for blocks confirmations...`);
    await simpleStorage.deployTransaction.wait(6);
    console.log(`Confirmed!`);

    // * only verify on testnets or mainnets.
    if (chainId != 31337 && process.env.ETHERSCAN_API_KEY) {
        await verify(simpleStorage.address, args);
    }
}

const verify = async (contractAddress, args) => {
    console.log("Verifying contract...");
    try {
        await run("verify:verify", {
            address: contractAddress,
            constructorArguments: args,
        });
    } catch (e) {
        if (e.message.toLowerCase().includes("already verified")) {
            console.log("Already verified!");
        } else {
            console.log(e);
        }
    }
};

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

// TypeScript
import { ethers, network, run } from "hardhat";

async function verifyContract(): Promise<void> {
    const chainId = network.config.chainId!;

    const simepleStorageFactory = await ethers.getContractFactory(
        "SimpleStorage"
    );

    const args: any[] = [];

    console.log(`Deploying...`);
    const simpleStorage = await simepleStorageFactory.deploy(args);
    await simpleStorage.deployed();
    console.log(`Deployed!`);
    console.log(`Simple Storage Address: ${simpleStorage.address}`);

    console.log(`Waiting for blocks confirmations...`);
    await simpleStorage.deployTransaction.wait(6);
    console.log(`Confirmed!`);

    // * only verify on testnets or mainnets.
    if (chainId != 31337 && process.env.ETHERSCAN_API_KEY) {
        await verify(simpleStorage.address, args);
    }
}

const verify = async (contractAddress: string, args: any[]) => {
    console.log("Verifying contract...");
    try {
        await run("verify:verify", {
            address: contractAddress,
            constructorArguments: args,
        });
    } catch (e: any) {
        if (e.message.toLowerCase().includes("already verified")) {
            console.log("Already verified!");
        } else {
            console.log(e);
        }
    }
};

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

Let me explain what’s going on; (I am going to explain JavaScript but the Concepts are the same for both).

async function verifyContract() {}

As simple we are creating a verifyContract JavaScript function.

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

Calling it inside the script so the code gets executed when we run the script.

const chainId = network.config.chainId;

Within the function, we utilize the network object provided by Hardhat to obtain the chainId of the network. This obtained chainId is then utilized to verify the smart contract exclusively on either testnets or mainnets.

const simepleStorageFactory = await ethers.getContractFactory(
        "SimpleStorage"
    );

By utilizing the getContractFactory function from the ethers.js library, we can instantiate a factory object for our smart contract.

The getContractFactory function in the Ethereum JavaScript library ethers.js is used to create a contract factory object for a specific contract. This factory object can then be used to deploy new instances of the contract to the Ethereum blockchain. The factory takes the ABI (Application Binary Interface) and bytecode of the contract as input. The ABI is a JSON representation of the contract's interface, which describes the functions and events that the contract exposes. The bytecode is the compiled code of the contract that gets deployed to the blockchain. Once the factory is created, it can be used to deploy new instances of the contract by calling the deploy method and passing in any necessary constructor arguments.

const args = [];

console.log(`Deploying...`);
const simpleStorage = await simepleStorageFactory.deploy(args);
await simpleStorage.deployed();
console.log(`Deployed!`);
console.log(`Simple Storage Address: ${simpleStorage.address}`);

The variable args represents the list of arguments for the smart contract constructor. However, in this instance, it is left empty as the SimpleStorage contract does not require any arguments to be passed during instantiation.

We use the deploy function of the contractFactory to deploy the smart contract, passing in any necessary arguments as specified. This results in the instantiation of the simpleStorage object, representing the deployed smart contract.

console.log(`Waiting for blocks confirmations...`);
await simpleStorage.deployTransaction.wait(6);
console.log(`Confirmed!`);

We use the wait function of the deployTransaction of the smart contract instance to wait for a confirmation of 6 blocks. Waiting for block confirmations before verification of the smart contract ensures that the contract is properly recorded on the blockchain and its bytes codes are available for verification.

// * only verify on testnets or mainnets.
if (chainId != 31337 && process.env.ETHERSCAN_API_KEY) {
    await verify(simpleStorage.address, args);
}

This section of the code establishes that the verify function should only be called under certain conditions: the network must not be hardhat or localhost and an Etherscan API key must be present in the environment file. Once these conditions have been met, the verify function is invoked, passing in the appropriate contract address and arguments.

Why can we not Verify for the Hardhat network?

As Hardhat is a local network, running exclusively on the user’s machine, it does not have a corresponding public blockchain for Etherscan to utilize for the verification of smart contracts.

solidity: "0.8.17",
networks: {
    hardhat: {
        chainId: 31337,
    },
    localhost: {
        chainId: 31337,
    },
},
etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY,
},

At this step, It is important to ensure that the networks object within the hardhat configuration file contains Hardhat and Localhost networks with a chainId of 31337, and that an etherscan object is also present.

If you are using the most recent version of Hardhat that includes the @nomicfoundation/hardhat-toolbox plugin then the verify task is included by default. However, if this is not the case, it is necessary to install the hardhat-etherscan plugin and configure it within the Hardhat configuration file in order for the verification process to be performed. Read more about it here Migration away from hardhat-waffle.

await run("verify:verify", {
    address: contractAddress,
    constructorArguments: args,
});

We utilize the run function provided by Hardhat to execute the verify task, passing in the appropriate contract address and smart contract constructor arguments. This step completes the process of verifying the smart contract on the Etherscan.

As seen in the code, we are calling the verify:verify subtask, which is a part of the larger verify task. This subtask specifically handles the verification of the smart contract on the Etherscan. It is important to note that the verify task contains various other subtasks that are not called in this particular instance.

try {
    await run("verify:verify", {
        address: contractAddress,
        constructorArguments: args,
    });
} catch (e) {
    if (e.message.toLowerCase().includes("already verified")) {
        console.log("Already verified!");
    } else {
        console.log(e);
    }
}

We have wrapped the execution of the run function within a try-catch block to handle any errors that may occur. In the event that the smart contract has already been verified, an error will be thrown and using the error message, we are informing the user that the contract has already been verified.

// JavaScript
npx hardhat run scripts/verify-simple-storage.js --network goerli

// TypeScript
npx hardhat run scripts/verify-simple-storage.ts --network goerli

By executing the above command, we will be able to deploy the smart contract and subsequently verify it on Etherscan after waiting for 6 block confirmations. This allows for easy verification of the smart contract on the Ethereum blockchain.

// JavaScript
goerli: {
    chainId: 5,
    url: process.env.GOERLI_RPC_URL,
    accounts: [process.env.PRIVATE_KEY],
    saveDeployments: true,
},

// TypeScript
goerli: {
    chainId: 5,
    url: process.env.GOERLI_RPC_URL,
    accounts: [process.env.PRIVATE_KEY!],
    saveDeployments: true,
},

It is important to note that before running the above command, the Goerli network should be added to the networks object in the configuration file. Additionally, the GOERLI_RPC_URL and PRIVATE_KEY environment variables should be defined in the env file to ensure proper deployment and verification on the Goerli network.

The GOERLI_RPC_URL, which is required for connecting to the Goerli network, can be obtained from a platform such as Alchemy. The PRIVATE_KEY, used for signing transactions, can be retrieved from a wallet service like MetaMask.

Note: It is important to keep in mind that the private key should be kept secure, and never shared with anyone. Additionally, it is important to ensure that the env file containing the private key is added to the .gitignore file before committing any code to a version control system, to prevent the private key from being accidentally exposed to the public.

Automated Verification of Smart Contracts

Using the above script approach deploying and verifying smart contracts can be a straightforward process when working with a small number of contracts. However, as the number of contracts increases, this manual approach can become unwieldy and time-consuming for developers. The repetitive nature of running deployment and verification commands for each individual contract can pose a significant challenge for large-scale projects. A more efficient and scalable approach is needed to effectively manage and deploy a large number of smart contracts.

It is important to note that in order to fully grasp this approach, a basic understanding of deploying smart contracts using the hardhat-deploy plugin is required. If you are not familiar with this method, it is recommended that you first read Learn to Deploy Smart Contracts more Professionally with Hardhat article before proceeding.

A best practice is to create a separate file for the verification function. This allows the function to be easily imported and reused across multiple files, making the deployment and verification process more efficient and streamlined.

Create a utils folder at the root location of the project. Within this folder, create a file named verify.js or verify.ts. Add the above verify function inside this file and export it.

// JavaScript
const { verify } = require("../utils/verify");

// TypeScript
import verify from "../utils/verify";

Import the verify function in your deploy file.

// JavaScript
const args = [];
const simpleStorage = await deploy("SimpleStorage", {
    from: deployer,
    log: true,
    args: args,
    waitConfirmations: chainId == 31337 ? 1 : 6,
});

// * only verify on testnets or mainnets.
if (chainId != 31337 && process.env.ETHERSCAN_API_KEY) {
    await verify(simpleStorage.address, args);
}

// TypeScript
const args: any[] = [];
const simpleStorage: DeployResult = await deploy("SimpleStorage", {
    from: deployer,
    log: true,
    args: args,
    waitConfirmations: chainId == 31337 ? 1 : 6,
});

// * only verify on testnets or mainnets.
if (chainId != 31337 && process.env.ETHERSCAN_API_KEY) {
    await verify(simpleStorage.address, args);
}

Execute the verification function, providing the deployed contract’s address and any constructor arguments utilized during the deployment process.

npx hardhat deploy --network goerli

With this approach, a single command can be used to deploy and verify all of the smart contracts located within the deploy folder. This streamlined process eliminates the need for manually deploying and verifying each individual contract, resulting in a more efficient and manageable development process.

Conclusion

In conclusion, verifying smart contracts on the Ethereum blockchain is an essential aspect of building trust and transparency in blockchain-based applications. By making the contract’s code publicly accessible and providing proof of deployment on the blockchain, developers can increase the visibility, credibility, and discoverability of their contracts. Verifying smart contracts is not just a good practice for blockchain-based application development, but it is also a way to increase the user’s trust and adoption of the application.

Be sure to follow me to receive updates on my future articles and stay informed of new content.

Thank you

@alymurtazamemon

Learn to Deploy Smart Contracts more Professionally with Hardhat

Ali Murtaza Memon — Sat, 21 Jan 2023 13:00:23 +0000

“A Step-by-Step Guide for Advanced Smart Contract Deployment”

Hardhat is an open-source development environment for Ethereum smart contracts. It allows developers to test, debug and deploy their contracts on a local Hardhat network, providing a safe and secure environment for experimentation and development.

One of the key features of Hardhat is its built-in Hardhat network, which allows developers to deploy and test their contracts without the need for a live network. This eliminates the risk of deploying untested code to the mainnet and incurring costly errors.

But when it comes to deployment, this is what their statement is;

There are no official plugins that implement a deployment system for Hardhat yet. We are working on it.
In the meantime, we recommend deploying your smart contracts using scripts, or using the hardhat-deploy community plugin.

This means either we can use this type of Hardhat script to deploy our smart contracts.

EXAMPLE OF Lock SAMPLE CONTRACT;

const hre = require("hardhat");

async function main() {
  const currentTimestampInSeconds = Math.round(Date.now() / 1000);
  const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
  const unlockTime = currentTimestampInSeconds + ONE_YEAR_IN_SECS;

  const lockedAmount = hre.ethers.utils.parseEther("1");

  const Lock = await hre.ethers.getContractFactory("Lock");
  const lock = await Lock.deploy(unlockTime, { value: lockedAmount });

  await lock.deployed();

  console.log(
    `Lock with 1 ETH and unlock timestamp ${unlockTime} deployed to ${lock.address}`
  );
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

or we can use the hardhat-deploy community plugin to deploy our contracts more professionally.

When working with smart contract scripts, there are several scenarios where the script process can become a headache for developers. Here are a few examples:

When deploying a large number of smart contracts, the process can become quite cumbersome, especially when using the default Hardhat deploy script. The script must be run individually for each contract, which can be time-consuming and prone to errors ( One approach to mitigate this issue is to create a separate script that can deploy all of the contracts together. While this can be an effective solution, it may not be ideal in situations where only a subset of the contracts need to be deployed. In such cases, it would be necessary to manually select which contracts to include in the deployment script, which can be time-consuming and prone to errors).
When testing smart contracts, it is often necessary to deploy the contracts on a test network before running the tests. This can be a time-consuming and error-prone process, especially when dealing with complex projects with a large number of smart contracts. Hardhat provides a way to manage this process with fixtures, but even with this feature, developers still need to write deploy fixtures functions at the start of the test script. This can be a headache when dealing with complex projects with many smart contracts.

To mitigate these issues, it is important to adopt a more professional approach in order to overcome the challenges and headaches that can arise during the deployment process.

The solution? “The hardhat-deploy community plugin, as suggested by Hardhat documentation, provides a comprehensive solution for streamlining the deployment process of smart contracts, eliminating the challenges and headaches that can arise during the process.”

Let’s explore the process of deploying smart contracts utilizing the Hardhat Deploy community plugin, and learn how to effectively utilize its features to streamline the deployment process.

Here is an example of a basic smart contract written in Solidity:

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

contract SimpleStorage {
    uint private storedData;

    function set(uint x) public {
        storedData = x;
    }

    function get() public view returns (uint) {
        return storedData;
    }
}

This contract, called SimpleStorage, has two functions: “set” and “get”. The “set” function allows you to store a value (in this case, a uint, or unsigned integer) in the contract’s storage, and the “get” function allows you to retrieve the stored value.

To deploy this contract using the hardhat-deploy plugin, you will first need to set up a local development environment. Follow these steps:

Install Node.js and npm (Node Package Manager) on your computer.
Install Hardhat by running the command “npm install -g hardhat” in your terminal.
Create a new directory for your project and navigate to it in your terminal.
Run the command “npx hardhat” to set up a new Hardhat project in your current directory. This will show you these options;
Select the “Create a JavaScript project” or “Create a TypeScript project” option.
Upon executing the command, the plugin will prompt for the root location of the project. Simply press the tab key to confirm the default location and press Enter.
The plugin will then prompt for the inclusion of a .gitignore file, you can choose to add it by typing ‘y’ or to skip it by typing ’n’ depending on your preference.
The plugin will then prompt to install the @nomicfoundation/hardhat-toolbox plugin, you can choose to install it by typing ‘y’ or to skip it by typing ’n’ depending on your requirement.

With the local development environment now set up, we can proceed with deploying the contract utilizing the Hardhat Deploy plugin. Before doing so, it is recommended to remove the default contract, script and test files provided by Hardhat. These files can be found in the contracts/, scripts/, and test/ folders, they should be removed to avoid confusion and potential errors.

In order to utilize the Hardhat Deploy plugin, it must first be installed. To do this, run the command in the terminal or command prompt.
```
npm install -D hardhat-deploy
```
The Hardhat Deploy plugin recommends installing hardhat-deploy-ethers to access additional features related to deployments as ethers contract. However, it is important to note that as hardhat-deploy-ethers is a fork of @nomiclabs/hardhat-ethers, other plugins might have a hardcoded dependency on @nomiclabs/hardhat-ethers. To ensure compatibility, it is recommended to install hardhat-deploy-ethers by following the command
```
npm install — save-dev @nomiclabs/hardhat-ethers@npm:hardhat-deploy-ethers ethers
```

Add the following statement to your hardhat.config.js:

// JavaScript
require('hardhat-deploy');
// TypeScript
import "hardhat-deploy";

Now if you run the command npx hardhat --help it will reveal a new task available, named 'deploy', which will be used to deploy the smart contracts.used to deploy the smart contracts.
To proceed with the deployment process, a new folder named ‘deploy’ should be created, and a new file, named 01-deploy-simple-storage.ts or 01-deploy-simple-storage.js, should be created within it. It is important to ensure that the SimpleStorage contract is added to the ‘contracts’ folder and named SimpleStorage.sol before proceeding. The structure will look like this (I am using Typescript);

Why are we adding the 01 prefixes to the file?
The inclusion of numerical prefixes, such as ‘01’, before the file names serves the purpose of indicating the sequence in which the deployment scripts should be executed when utilizing the ‘npx hardhat deploy’ task command. This ensures that all scripts present within the ‘deploy’ folder are executed in a specific order. Although this is a simple example with one smart contract, it is important to note that when working with multiple smart contracts, this method allows for a clear and organized structure, ensuring that the contracts are deployed in a specific sequence.
The following code should be added to the previously created deployment file, depending on the language being used, either JavaScript or TypeScript.

// TypeScript
import { DeployFunction, DeployResult } from "hardhat-deploy/dist/types";
import { HardhatRuntimeEnvironment } from "hardhat/types";
import { network } from "hardhat";

/**
 * * Important Notes
 *
 * * In order to run `npx hardhat deploy --typecheck` command we need to add `import hardhat-deploy` in `hardhat.config.js` file.
 *
 */

const deploySimpleStorage: DeployFunction = async (
    hre: HardhatRuntimeEnvironment
) => {
    const { deploy } = hre.deployments;
    const { deployer } = await hre.getNamedAccounts();
    const chainId = network.config.chainId!;

    const simpleStorage: DeployResult = await deploy("SimpleStorage", {
        from: deployer,
        log: true,
        args: [],
        waitConfirmations: chainId == 31337 ? 1 : 6,
    });
};

export default deploySimpleStorage;
deploySimpleStorage.tags = ["all", "simpleStorage"];

// JavaScript
const { network } = require("hardhat");

module.exports = async (hre) => {
    const { deploy } = hre.deployments;
    const { deployer } = await hre.getNamedAccounts();
    const chainId = network.config.chainId;

    const simpleStorage = await deploy("SimpleStorage", {
        from: deployer,
        log: true,
        args: [],
        waitConfirmations: chainId == 31337 ? 1 : 6,
    });
};

module.exports.tags = ["all", "simpleStorage"];

Let me explain what’s going on; (I am going to explain JavaScript but the Concepts are the same for both).

const { network } = require("hardhat");

This line of code imports the network from Hardhat, which will be used to automatically detect the network being used, whether it is localhost, testnet, or mainnet, from the command used.

module.exports = async (hre) => {

The code exports a deploy function, which will be passed an object, known as the Hardhat Runtime Environment, by the Hardhat Deploy plugin.

const { deploy } = hre.deployments;
const { deployer } = await hre.getNamedAccounts();
const chainId = network.config.chainId;

The hre object is used to extract the deploy function from the deployments, which will assist in deploying the smart contract with specified options. The deployer is obtained through the hre’s getNamedAccounts function, and the chainId is obtained from the network.

The deployer is a label assigned to the first account on the network. To utilize this feature, the hardhat.config.js file needs to be configured accordingly, as outlined below (Make sure it contains both JavaScirpt and TypeScript versions, select only one).

// TypeScript
const config: HardhatUserConfig = {
    solidity: "0.8.17",
    defaultNetwork: "hardhat",
    networks: {
        hardhat: {
            chainId: 31337,
        },
    },
    namedAccounts: {
        deployer: {
            default: 0,
        },
    },
};

// JavaScript
module.exports = {
    defaultNetwork: "hardhat",
    networks: {
        hardhat: {
            chainId: 31337,
        },
    },
    namedAccounts: {
        deployer: {
            default: 0
        },
    },
}

With the deployer obtained, the smart contract can now be deployed using the deploy function provided by hre.deployments.

const simpleStorage = await deploy("SimpleStorage", {
    from: deployer,
    log: true,
    args: [],
    waitConfirmations: chainId == 31337 ? 1 : 6,
});

In this step, the smart contract’s name is provided as the first parameter of the deploy function. The second parameter of the deploy function is an object that contains additional information for deployment.

from: field within the object specifies the address of the deployer or owner of the contract.
log: field within the object, if set to true, will log information about the deployed smart contract’s address in the terminal.
args: field within the object, is an array that contains the parameters required for the smart contract’s constructor. Since our smart contract in this example does not have a constructor, an empty array is passed.
waitConfirmations: field within the object specifies the time delay for waiting for the confirmation of the transaction of the deployed smart contract. Here, the condition to wait for 1 block confirmation for the Hardhat chain, and 6 block confirmations for testnets or mainnets is added. This is a recommended practice.

With all necessary setup and configuration completed, the smart contract can now be deployed by executing the following command in the terminal.

npx hardhat deploy

// deploy on goerli - make sure to setup goerli network in hardhat.config.js file before running this command.
npx hardhat deploy --network goerli

// deploy on any network - just add the network in hardhat.config.js file.
npx hardhat deploy --network <network-name>

The same process should be followed for deploying any additional smart contracts. Once the initial setup is completed, all contracts can be deployed simultaneously using this single command.

With the Hardhat Deploy plugin, the need to run individual deployment scripts for each smart contract on the Hardhat node is eliminated. The plugin automatically deploys all smart contracts when the Hardhat node is opened, as demonstrated in the example provided.

With this setup in place, there is no need to redeploy your smart contract each time it is used in other scripts. By including the following line of code, the instance of the previously deployed contract can be accessed and utilized.

const { deployer } = await getNamedAccounts();
const simpleStorage = await ethers.getContract("SimpleStorage", deployer);

// now you can call your smart contract public function and variable with just this instance.

What if we only want to deploy selective deploy scripts from the deploy folder?

Do you remember this line we added at the end of our 01-simple-storage.js file?

module.exports.tags = ["all", "simpleStorage"];

In scenarios where only a specific set of smart contracts from the ‘deploy’ folder are intended to be deployed, the Hardhat Deploy plugin offers the capability to selectively deploy those contracts by providing their tags names as arguments to the command npx hardhat deploy --tags <tag-name>, this allows for a more efficient deployment process by enabling the selective deployment of only the necessary smart contracts.

Use Deployed Smart Contracts in Tests

An additional benefit of using the Hardhat Deploy plugin is the ability to ensure the deployment scripts are executed in tests as well.

By calling await deployments.fixture(['MyContract']) in your test, the same deployment is used for all tests, which eliminates the need to replicate the deployment procedure.

To deploy all smart contracts before running tests, an ‘all’ tag feature can be added to all deployment scripts, and this await deployments.fixture(['all']) can be added to the test file. This enables the deployment of all contracts before the tests are executed, ensuring that the test environment accurately reflects the deployed state of the smart contracts.

The 'tag' feature, as well as dependencies, also simplify the process of writing complex deployment procedures. The plugin also allows for the organization of the deploy scripts into sub-folders and execution in a logical order.

Conclusion

Overall, Hardhat Deploy is a powerful and versatile tool that can greatly simplify and streamline the deployment process for smart contracts. It is widely used by developers and organizations in the Ethereum community and can be a great addition to your development workflow.

Be sure to follow me to receive updates on my future articles and stay informed of new content.

Thank you

@alymurtazamemon

Best Resources to Learn Blockchain Development in 2023

Ali Murtaza Memon — Tue, 03 Jan 2023 16:11:23 +0000

Blockchain technology is a decentralised ledger that records transactions between parties efficiently and in a verifiable and permanent way.

This is not just some future-tech buzzword: it’s happening now, and it’s changing the world.

I’ve put together a list of resources to help you learn about blockchain technology in 2023!

1. Crypto Zombies

CryptoZombies is the largest education platform for blockchain development, it’s been around for 4+ years, with over 400k registered users that have finished multiple courses.

CryptoZombies was the first tutorial on the internet for NFTs and is still very relevant to the new crop of web3 developers looking to enter the industry today. Currently, the CryptoZombies curriculum is mostly focused on Ethereum and Solidity development but is a lot of demand for content targeting other chains such as Binance, TRON, and even projects like Chainlink.

In-browser step-by-step lessons take you from the very basics of Solidity to creating your own fully-functional blockchain-based game. Even by the end of Lesson 1 (which can be completed in one sitting), you’ll know enough to officially call yourself a blockchain developer!

If you starting out with zero knowledge about Solidity, Tokens Standards and Blockchain, then you can start your blockchain development journey with Crypto Zombies courses. At the start, I would recommend you to just take 5 lessons of the Solidity: Beginner to Intermediate Smart Contracts course and then move on to the next resource I have mentioned to get the most in less time.

#1 Solidity Tutorial & Ethereum Blockchain Programming Course | CryptoZombies

CryptoZombies is The Most Popular, Interactive Solidity Tutorial That Will Help You Learn Blockchain Programming by Building Your Own Fun Game with Zombies — Master Blockchain Development with Web3, Infura, Metamask & Ethereum Smart Contracts and Become a Blockchain Developer in Record Time!.

cryptozombies.io

2. Learn Blockchain, Solidity, and Full Stack Web3 Development with JavaScript — 32-Hour Course

After learning the basics of Solidity from Crypto Zombies you continue this course. This course will start with the Fundamentals of Smart Contracts and Why they are needed for the future. In addition to that, it will cover the basics of transactions, gas, accounts, etc.

This course will give you a full introduction to all of the core concepts related to blockchain, smart contracts, Solidity, ERC20s, full-stack Web3 dapps, decentralized finance (DeFi), JavaScript, TypeScript, Chainlink, Ethereum, upgradable smart contracts, DAOs, the graph, moralis, Aave, IPFS, and more.

After this course, you will be a Blockchain Wizard and ready to create any Decentralised Application you want.

3. Alchemy University

Alchemy University is the ultimate ecosystem for learning how to build and interact with web3. Their goal is to teach you everything you need to know to start building in web3, from hands-on, comprehensive bootcamps to starter code that expedites your workflow.

They are offering 3 different paths and you can continue with anyone based on your level of experience;

1. JavaScript Fundamentals

JavaScript foundation is very necessary in order to understand things and become a Blockchain Developer so if you do not know about it or lagging with some concepts then you can start this course first to build your foundations of programming and then continue Blockchain.

This JavaScript crash course covers the basics of programming through advanced topics like asynchronous requests and promises. The most used developer tools and libraries for Ethereum are JavaScript based, making it a key foundation for web3 development.

2. Ethereum Developer Bootcamp

This Bootcamp will take you from the ground up with strong fundamentals that will provide you with the ability to adapt to this rapidly evolving ecosystem. This Bootcamp places a heavy emphasis on learning by doing. You will build a full Proof-of-Work blockchain, many smart contracts and several decentralized applications.

Anything you learn conceptually, you will prove to yourself through coding exercises. They have crafted an IDE and collaborative classroom tool to provide you with the ultimate Bootcamp experience.

I personally recommend starting 3 lessons no matter your experience level, these fundamentals are super awesome.

3. Road to Web3

Road to Web3 is a free 10-week program for learning Web3 development. You’ll get to build dApps in DeFi, NFTs, Staking, and more!

This is an amazing course to learn and build the portfolio DApps for your future jobs.

Alchemy University

Fast track your web3 career through courses, projects and code. Totally free.

university.alchemy.com

4. SPEEDRUN ETHEREUM

Speedrun Ethereum is a challenging based platform which gives you the option to learn by building quick projects on Ethereum. Some of the projects are Simple NFT Example, Decentralized Staking App, Token Vendor, etc.

They have an amazing playlist on youtube that transitions you from Web2 to Web3.

speedrunethereum.com

5. Buildspace

Buildspace is another awesome platform which provides project-based learning on Ethereum and other different chains such as Solana.

It provides different courses such as Intro to Solidity: Ship an Ethereum dApp, Build your own Ethereum NFT Collection, Build a DAO, etc.

This is another awesome platform where you can build amazing projects for your portfolio that can help you get into the blockchain space.

buildspace.so

6. LearnWeb3

LearnWeb3 is another Web3 platform that provides different tracks for each level of developers out there. Each track contains many articles that cover tons of topics required for web3. If you are totally new you can start with their Freshman track which can provide a solid ground for your web3 journey.

They have other three tracks, Sophomore, Junior, and Senior which can help you learn advanced topics with the flow.

LearnWeb3 - Become a Web3 Developer for free!

LearnWeb3 is a free platform to take you from zero to hero in Web3. Join 90k+ developers in our mission to make learning permissionless and collaborative.

learnweb3.io

7. BANKLESS ACADEMY

Bankless Academy is on a mission to ensure every web3 Explorer is ready for their crypto-verse voyage.

Using the Academy platform you’ll be taking a confident first step into the new frontier, before diving down your own unique learning path and preparing to blaze new trails across blockchain space.

Bankless Academy

Level up your knowledge of Web3 and DeFi

app.banklessacademy.com

8. Developer DAO Academy

D_D Academy is an open-source education platform created by the Developer DAO.

They seek to empower learners with knowledge and tools that can be applied to real-world projects while promoting a healthy learning environment.

In addition to that, Developer DAO is one the best community out there, which can help you grow your web3 carrier along with other link-minded people.

Developer DAO Academy | Learn Web3

D_D Academy is on a mission to educate coders to the exciting possibilities of building web3 Open Source.

school-of-code.vercel.app

9. Ethereum Developer Resources

ethereum.org is the official website of Ethereum to help you build with Ethereum with the documentation on foundational concepts as well as the development stack. Plus there are tutorials to get you up and running.

Inspired by the Mozilla Developer Network, they placed great developer content and resources there. Everything here is open-source and ready for you to extend and improve.

Ethereum Developer Resources | ethereum.org

Documentation, tutorials, and tools for developers building on Ethereum.

ethereum.org

Conclusion

Alright, so these were all the amazing resources that I know can create a great impact and give the push the start your blockchain development journey.

Definatly you do not have to go throw each and every resource I mentioned just explore and continue with the one which makes you feel interested. Every person is different some likes to watch videos and some likes to read due to that I have mentioned all these for your choice.

Knowledge grows by sharing it with others! I have devoted my time to helping others out there with the knowledge and resources I have. Make sure to do the same and share this with the ones who are starting their carrier in the blockchain space.

Thanks
@alymurtazamemon