DEV Community: Sourin🥑 | Web 3.0 & Blockchain🚀

Complete Shell Scripting Guidance

Sourin🥑 | Web 3.0 & Blockchain🚀 — Sat, 02 Sep 2023 05:25:06 +0000

Shell Scripting Tutorial

Welcome to the Shell Scripting Tutorial repository! In this tutorial, you'll learn the fundamentals of shell scripting, a powerful skill for automating tasks, managing systems, and more. Whether you're a beginner or have some programming experience, this guide will help you understand the basics of shell scripting.

All source codes: https://github.com/heysourin/Shell-Scripting
Video Reference (In Hindi): https://www.youtube.com/watch?v=TtGM9GfBuok&t=13429s

What is a Shell?
Different Types of Shells
What is Shell Scripting?
Key characteristics and functions of a shell include
Shebang
Output in the Terminal
How to Create a Shell File?
How to Save the File from Editor?
How to Run Shell Scripts?
Comments
Variables
Array
User Input
Arithmetic operatings
Conditionals
- if-else
- elif
- choice
- Logical Operators
- Ternary Operator
Loops
- for loop
- for loop Iteration on Files
- for loop on an Array
- while loop
- until loops
- Infinite loop using while loop
- Infinite loop using for loop
- Reading a File using While Loop
Functions
- Function with Arguments
- Arguments passing directly on the shell
Break, Continue, and Sleep
- Break
- Continue
- Sleep, Exit, and $?
Connectivity Check
Checking if a File and Directory Exist
- Directory
- File
Bash Variables
Login as Root User
Redirection
Log Messages
Debugging
Running a File in the Background
Automation

What is a Shell?

A shell is a command-line interface (CLI) program that provides a user-friendly way to interact with an operating system (OS) or a computer system. It serves as a bridge between the user and the kernel (core of OS) by interpreting and executing commands entered by the user or by scripts.

Different Types of Shells

Bash (Bourne-Again Shell): Bash is one of the most widely used shells and is the default shell on many Linux distributions. It is a powerful and versatile shell that supports scripting, interactive use, and command-line automation.
Zsh (Z Shell): Zsh is known for its extensive customization options and interactive features. It offers advanced auto-completion, syntax highlighting, and theming. Many users prefer Zsh for its user-friendly experience.
Fish (Friendly Interactive Shell): Fish is designed to be a user-friendly shell with a focus on interactive use. It provides helpful features like auto-suggestions, syntax highlighting, and an easy-to-understand scripting syntax.
Dash: Dash is a minimalistic POSIX-compliant shell optimized for scripting. It is often used as the default /bin/sh shell on many Unix systems because of its speed and efficiency.
Tcsh: Tcsh is an enhanced version of the C shell (csh) with additional features like command-line history, command-line editing, and job control. It's popular among some Unix users.
Ksh (Korn Shell): The Korn Shell is known for its scripting capabilities and is compatible with the Bourne Shell (sh). It offers advanced scripting features like associative arrays and floating-point arithmetic.
Ash (Almquist Shell): Ash is a lightweight and efficient shell that adheres to the POSIX shell standard. It is often used in embedded systems and as the basis for other shells like Dash.
Csh (C Shell): The C shell is an early Unix shell with C-like syntax. It offers some unique features but is less commonly used today, especially for scripting.
PowerShell: While primarily associated with Microsoft Windows, PowerShell has also been developed for Linux and macOS. It is a powerful and object-oriented shell designed for automation and system administration.

etc

What is shell scripting?

Shell scripting is a way to automate tasks and create programs using shell commands. A shell script is a sequence of commands that can be executed in a shell environment. Shell scripts are commonly used for system administration, automation, and other tasks.
All the commands execute sequentially.
Some important tasks engineers do with shell scripting is file manipulation, program execution, user interaction, automation etc.

Key characteristics and functions of a shell include

Command Interpretation: The shell interprets commands entered by the user and translates them into instructions that the operating system can understand and execute.
Command Execution: It runs programs, utilities, and scripts on behalf of the user. This includes both built-in shell commands and external programs.
Scripting: Shells support scripting languages that allow users to automate tasks by writing sequences of commands in script files.
I/O Redirection: Shells allow users to redirect input and output streams (e.g., redirecting output to a file) to manipulate and process data.
Variables: Users can create and manipulate variables to store and retrieve data within the shell environment.
Control Structures: Shells support conditional statements (e.g., if-else), loops (e.g., for, while), and other control structures for scripting and automation.
Environment Management: Shells manage environment variables, which are used to store configuration information and data that can be accessed by programs and scripts.
Customization: Users can customize their shell environment by defining aliases, setting prompts, and configuring various settings.

Shebang

A shebang, also known as a hashbang or pound-bang, is a special character sequence at the very beginning of a text file. It is used in Unix-like operating systems to specify the interpreter that should be used to execute the script or program contained in the file.
Whenever we try to execute a script, we have to instruct the Linux machine which interpreter or shell it should be using. It is possible that, in some machines 'bash' is not the default shell.

#!/bin/bash

In this case, it indicates that the script should be executing using bash shell.
It is not mandatory, but it is a good practice.

Output in the Terminal

#!/bin/bash

echo "hello world"

echo "hello world": This is the main command of the script. It uses the echo command to print the text "hello world" to the standard output (usually the terminal or console).

How to create a Shell File?

touch fileName.sh then vi fileName.sh: It will create a file then open 'vi' editor on the shell where you can edit and create your shell scripts.
Or you can directly do vi fileName.sh it will do the samen, create the file and open it on the editor.

How to save the file from editor?

Whenever you finish writing the script, you press esc button then type :wq. It will save changes and quit the editor.

How to run Shell Scripts?

bash fileName.sh will allow you to run the script. Make sure your file is in the same directory that you are currently in (on your shell) or you provide proper path-directory before the file-name

PS. Below I am going to teach Shell Scripting. You will have to save easch file and run with the command I mentioned above.

Comments

#!/bin/bash

echo "Before comments"

#Single line comment

<<comment
This 
is 
a 
multi
line 
comments

comment

echo "After comments"

#: The hash symbol (#) at the beginning of the line is used to indicate a single-line comment in Bash. Any text following the # on the same line is considered a comment and is not executed as code.
<<comment at the beginning and comment at the end of the comments are used for multiline comments. Any text in between these two things will be comsidered as comment and is not executed as code.

Variables

#!/bin/bash

#Script to show how to use variables    

a=10 #do not use space in between

name="Ryle"

age=45

echo "My name is $name and age is $age"


name="Phoenix" #variables are reassignable

echo "My name is $name"

##----------------------------------------##
#var to store the output of a command

HOSTNAME=$(hostname) #`hostname` shows your pc name

echo "Name of this machine is $HOSTNAME" 

CURR_DIR=$(pwd) #current directory

echo "Current directory is $CURR_DIR"

a=10: This line assigns the value 10 to the variable a. In Bash, you can create variables without explicitly declaring their types. Variables can store numbers, strings, or other data types.
name="Ryle" and age=20: These lines assign values to the variables name and age. name is assigned the string "Ryle," and age is assigned the number 20.
echo "My name is $name and age is $age": This line uses the echo command to print a message that includes the values of the name and age variables. The $name and $age inside the double-quoted string are used to insert the values of the variables into the string.
use readonly keyword for constant variable.

Array

This is how arrays are written in shell scripting file.

#!/bin/bash

#Array

myArray=(12 21 Hello "Ryle Phoenix" 44 14)

echo "${myArray[0]}"

echo "${myArray[2]}"

echo "${myArray[3]}"

echo "Value at 3rd index: ${myArray[3]}"

echo "All the values in array: ${myArray[*]}" #prints all the values


## Array length:

echo "length of the array: ${#myArray[*]}" #prints the length

# Getting Certain elements

echo "Values from index 2 to 4: ${myArray[*]:2:3}" #how it works: {myArray[*]:start:how_many_elements_you_want}



# Update an array with new values: will get added at the end

myArray+=(New 30 40)
echo "Values of new array are: ${myArray[*]}"

Signle words can be stored without semicolons(""). Now, save and run the file using bash fileName.sh command, you will see the desired output.

Strings

#!/bin/bash

myVar="Hey there!!!"

myVarLength=${#myVar}
echo "Length of the myVar is $myVarLength"


#Uppercase
echo "In uppercase: ${myVar^^}"
#lowercase
echo "In lowercase: ${myVar,,}"


#replace a word
newVar=${myVar/there/everyone}
echo "Changed variable is: "
echo "${newVar}"


#slice
echo "After slice: "
echo "${myVar:4:5}"

Signle words can be stored without semicolons("").

User Input

#!/bin/bash

# Taking user input

echo "Enter your name: "
read name
echo "Name is $name"

#ANOTHER WAY
read -p "What is your name bruh? " name2
echo "Your name is $name2"

Now run the file.

Arithmetic operatings

#!/bin/bash
x=10
y=2

mul=$x*$y
echo "$mul" #output: 10*2

let mul2=$x*$y
echo "$mul2" #20

# Direct
echo "Subtraction is: $(($x-$y))"

To do mathematical calculations:

Either you have to use let keyword, when you are assigning a variable
Or when you are directly printing the calculations you have to use '(())' (double parentheses).

Conditionals

if-else

#!/bin/bash

read -p "Enter your marks: " marks

if [[ $marks -ge 40 ]]; then
    echo "You are pass"
else
    echo "Fail!!!"
fi

if [[ $marks -ge 40 ]]; then: This line begins an if statement. It checks whether the value of marks is greater than or equal to 40. If this condition is true, the following commands will be executed.

echo "You are pass": This line is executed if the condition in the if statement is true. It prints "You are pass" to the screen.

else: This line is part of the if statement and is executed if the condition in the if statement is false.

echo "Fail!!!": This line is executed if the condition in the if statement is false. It prints "Fail!!!" to the screen.

fi: This line marks the end of the if statement, indicating that there are no more commands to be executed conditionally.

elif

elif [[ $marks -ge 60 ]]; then: If the first condition is not met, this block is checked. If the user's marks are greater than or equal to 60, it prints "Good job! You scored a B."

elif [[ $marks -ge 40 ]]; then: If neither of the previous conditions is met, this block is checked. If the user's marks are greater than or equal to 40, it prints "You passed with a C."

choice

#!/bin/bash
echo "Provide an option: a for date, b list of files, c check for current directory"

read choice

case $choice in
    #how to write multiple lines in one option:
    a)
        echo "Today is: "
        date
        echo "Ending."
        ;;
    b)ls;;
    c)pwd;;
    *)echo "Provide a valid value";;
esac

echo "Provide an option: a for date, b for list of files, c for check the current directory": This line prints a menu with options for the user to choose from.

read choice: This line reads the user's input and stores it in the variable choice.

The case statement allows you to evaluate the value of choice against different patterns:

a): If the value of choice is "a," the code within this block is executed. It prints the current date using the date command. In the above code in option a it is also shown that how you can add multi line instructions.

b): If the value of choice is "b," the ls command is executed, listing the files in the current directory.

c): If the value of choice is "c," the pwd command is executed, displaying the current directory path.

*): If none of the above patterns match (i.e., the user enters an invalid option), this block is executed, and it prints "Provide a valid value."

The ;; statement marks the end of each block within the case statement.

Logical Operators

#!/bin/bash

#AND

read -p "Enter your age: " age
read -p "Your nationality: " nat

if [[ $age -ge 18 ]] && [[ $nat -eq "Indian" ]];then
    echo "You can vote!!!"
else
    echo "You can not vote"

fi


# OR

read -p "Enter your age again: " age
read -p "Your nationality again: " nat

if [[ $age -ge 18 ]] || [[ $nat -eq "Indian" ]];then
        echo "You can vote!!!"
else
        echo "You can not vote"

fi

In logical Operators we use && and || according to our needs.

Ternary Operator

#!/bin/bash

read -p "Enter your age: " age
[[ $age -ge 18 ]] && echo "Adult" || echo "Minor"

In the above case if age is greater than or equal to 18 then the program will print "Adult" or it will print "Minor".

Loops

for loop

#!/bin/bash

# Loop from 1 to 5
for i in {1..5}; do
    let mul=2*$i
    echo "Iteration $mul"
done


for i in {1..10}; do
    echo "Multiplication table: $((3*i))"
done

# Iteration over strings
for name in Raju Sham Baburao;do
    echo "Name is $name"
done

The first loop iterates over numbers from 1 to 5 (inclusive) using the brace expansion {1..5}.
The second loop iterates over numbers from 1 to 10 (inclusive) using the brace expansion {1..10}.

for loop iteration on files

Create a file named names.txt:. Add the following things in the file.

Ryle
Max
Sourin
Oslo
Professor

Then, create a shell script:

#!/bin/bash

#Getting values from a file names.txt

FILE="/home/heysourin/Desktop/shell-scripts/names.txt"

for name in $(cat $FILE);do
       echo "Name is $name"
done

You have to add proper location of the file and store that inside a variable (FILE in this case).
cat fileName.txt reads a file and prints the output on the shell itself.

for loop on an array

#!/bin/bash

myArray=( 1 2 3 Hello Hi )

length=${#myArray[*]}

for (( i=0;i<$length;i++ ));do
        echo "Value of array is ${myArray[$i]}"

done

while loop

#!/bin/bash

count=0
num=10

while [[ $count -le $num ]];do
    echo "Value of count var is $count"
    let count++
done

until loops

It is a special type of loop seen in shell scripting

#!/bin/bash

a=10

until [[ $a -eq 1 ]]
do
    echo "Value of a is $a"
    let a--
done

The loop will run until a's value becomes equal to 1.

Infinite loop using while loop

#!/bin/bash

while true
do
    echo "Hi"
    sleep 2s #will run every 2 sec
done

This is how we write a infinite loop.
sleep 2s: It will trigger the loop to run every 2 seconds.

Infinite loop using for loop

#!/bin/bash

for (( ;;  ))
do
    echo "Hi buddy"
    sleep 2s

done

Reading a file using while loop

names.txt

Ryle
Max
Sourin
Oslo
Professor

Shell script:

#!/bin/bash

## Reading a content from a file
while read myVar
do
    echo "Value from file is $myVar"
done < names.txt

Functions

#!/bin/bash

function myFunc {
       echo "-------------"
       echo "Welcome"
       echo "-------------"

}

myFunc
myFunc
myFunc


## another way
welcomeNote(){
    echo "Hi there, please come in!!"
}
welcomeNote
welcomeNote
welcomeNote

Function with arguments

#!/bin/bash

#ps: space after function-name is mandatory

function welcomeNote {
    echo "--------------------"
    echo "Welcome $1"

    echo "--------------------"
    echo "Age is $2"
}

welcomeNote Sourin 94 #calling the function with argument1 and argument2
welcomeNote Max 32 #calling the function with argument1 and argument2

Arguments passing directly on the shell

#!/bin/bash

#to access the arguments

echo "First argument is $1"
echo "Second argument is $2"


echo "All the arguments are - $@" #prints all the args
echo "Number of arguments are - $#" #prints total number of args

You will save the file and run it like this: bash fileName.sh Hello 12, Hello and 12 is the argument1 and argument2 in this case, which we are passing directly on the shell while we try to run the file.

break & continue statement

break

#!/bin/bash

# example of break in a loop

read -p "Enter the number you want between 1 to 9: " no

for i in {1..9}
do
    #Break the loop if number found
    if [[ $no -eq $i ]]
    then
        echo "$no is found!!!"
        break
    fi
    echo "Number is $i"
done

When if statement will find the desired condition, it will execute brake statement and will stop the program.

continue

#!/bin/bash


#Program to print odd numbers
for i in {1..10}
do
    let r=$i%2
    if [[ $r -eq 0 ]]
    then
        continue
    fi
    echo "Odd no. is $i"
done

The above is a shell script to print odd number, when if statement will satisfy its condition the particular condition will be skipped and will print the rest of the things.

sleep/ exit/ `$?`

sleep : We have discussed this previously, it creates a delay between two executions.
exit: to stop the whole program at some certain point.
$1: It is used to check if the previous command executed successfully or not. If it returns 0, that means previous command ran successfully and exited with 0. If it returns 1, that means previous command was not executed successfully.

Connectivity Check

ping -c 1 www.google.com.

If it returns something like this --- www.google.com ping statistics --- 1 packets transmitted, 1 received, 0% packet loss, time 0ms rtt min/avg/max/mdev = 174.026/174.026/174.026/0.000 ms. Then the connection is successful.

Check if a file and directory exists

Will be using it inside a shell scipt, in a if else statement. I am showing the initial part only.

file

if [ -d fileName ]
if [ ! -d fileName ]

Bash Variables

RANDOM: Generates a random integer value from0 to 32767.

UID: User Id of the user, that you are currently logged in as. (eg: For root user it will return 0)

Login as root user

sudo su -: It will ask for your password, then will open root user mode. You can exit the mode by using exit command.

What is root user?

Redirection

#!/bin/bash

ping -c 1 www.google.com > redirect.log

When you run this script, you will not see any output on the terminal. A file named redirect.log will be created and the result will be saved in that file.
> redirect.log: A new file is created where all the data will be saved.
If you want to add any other data to the same file then you will have to use >> command, like:

#!/bin/bash

ping -c 1 www.google.com > redirect.log

date >> redirect.log

current date will be saved in the file again, below the previous data.

Log messages

#!/bin/bash

logger "This is a log from ${0}"

The result will not be printed on the shell. It can be seen on the logger messages.

How to access log messages? sudo less var/log/messages or sudo less var/log/syslog will show you the log messages. ## Debugging

#!/bin/bash

set -e
pwd
date
cd /root
hostname

Adding set -x or set -c after #!/bin/bash line in any script will help you debugging it.

Running a file in the background

For that first of all you have to approve few permissions of the file: chmod +x fileName.sh

then

nohup ./fileName.sh

It will run the script in the background, it will not stop even after terminating the shell.
It will create a nohup.out file, that you can read later using cat nohup.out.

Automation

You can set any task to run at a particular time by using at command. On the shell:

Step 1: run this at 21:00 02 September.

Step 2: you'll get some outputs like this:

warning: commands will be executed using /bin/sh
at Sat Sep  2 21:00:00 2023
at>

Step 3: Then enter your task, eg: bash home/Desktop/folederName/fileName.sh.

Step 4: Press Ctrl + D to save and exit.

Your script will run at its scheduled time.

atq: To see all the scheduled tasks, that has not been executed yet.
atrm: To delete a scheduled task that has not been executed yet.

DevOps Learning ~ Day 1

Sourin🥑 | Web 3.0 & Blockchain🚀 — Sun, 20 Aug 2023 13:56:15 +0000

Starting a new journey is always an exciting endeavour, and today marked the beginning of my exploration into the world of DevOps. Today I have learned the fundamentals, I was introduced to a plethora of concepts that lay the foundation for this intriguing field.

The Need for DevOps

At the core of my day 1 learning, I understood the fact that why DevOps has become an integral part of modern day software development. DevOps isn’t just a buzzword. It’s a method that bridges the gap between development and operations, ensures seamless collaboration and continuous integration. As I pondered the challenges faced during traditional software development, the reasons for adopting DevOps became clear — faster releases, improved collaboration, and enhanced quality assurance.

The Dance of Software Development Life Cycle (SDLC)

One of the first concepts I encountered was the Software Development Life Cycle (SDLC). It’s the backbone of any software project, comprising phases from idea conception to deployment. DevOps steps onto the stage at crucial points within the SDLC — particularly in building, testing, and deploying software. This real-time collaboration ensures that development and operations teams work in harmony, leading to smoother and more efficient processes.

If you look at the image carefully; Building, Testing and Deploying is the process that a DevOps engineer mostly works with.

Unveiling Virtual Machines and Cloud Computing

As I progressed in my learning, I found myself unveiling the mysteries of virtual machines (VMs) and cloud computing. VMs are like digital versions of physical computers, allowing a user to run multiple operating systems on a single physical machine. The concept of cloud computing, on the other hand, revolutionised the way we deploy and manage a system. It offers scalability, flexibility, and the power to spin up resources as needed.

Basics of Cloud Computing:

Flexibility and Scalability: Cloud computing provides the ability to adjust resources based on demand. Unlike physical servers that require lot of investments and can be challenging to scale and manage. Cloud services allow users to provision additional resources or reduce them as required.
Cost Efficiency: Cloud services operate on a pay-as-you-go model, meaning you only pay for the resources that you use. This eliminates the need for large capital investments in hardware, reducing financial risks. Additionally, you avoid costs associated with maintaining and upgrading physical servers.
Resource Management: Cloud providers are the one who manage the underlying infrastructure, including hardware maintenance, updates, and security patches. This allows businesses to focus on their core competencies without dedicating significant resources, time and labour to server management.
Global Accessibility: Cloud services offer global accessibility. Users can access their applications and data from anywhere in the world with an internet connection. This is a significant advantage over traditional setups that require physical presence in data centers.
Rapid Deployment: Setting up physical servers can take a lot of time due to procurement, setup, and configuration. Cloud resources can be provisioned in very less time within minutes, enabling rapid deployment of applications and services.
Global Reach: Cloud providers have data centers located in various locations around the world. This allows businesses to deliver content and services with low latency to users across different geographical locations.

The Role of a DevOps Engineer

To start with the basics:

i. Automation

ii. Monitoring and Alerting

iii. Security and Compliance

iv. Version Control

v. CI/CD

vi. Documentation

Understanding the role of a DevOps engineer was a pivotal moment in my day 1 journey. A DevOps engineer isn’t just a coder or an operations guru — they are the bridge between development and operations. They orchestrate processes, automate tasks, and champion a culture of collaboration. Their expertise lies in tools that streamline the entire development lifecycle, from code creation to deployment.

As I wrap up my reflections on day 1, I’m excited to have embarked on this DevOps journey. From the essentials of why DevOps matters to the foundational understanding of SDLC, virtual machines, cloud computing, and the pivotal role of a DevOps engineer, I can already see the immense potential this field holds.

Stay tuned as I dive deeper into the DevOps universe, exploring the tools, practices, and technologies that make this methodology a game-changer in modern software development.

Basic Commands of Linux

Explore essential Linux commands, file system navigation, permissions of the 1st day.

**whoami **Displays the current user’s username.

pwd Prints the current working directory (i.e., the path to the directory you’re in).

ls Lists files and directories in the current directory.

ls -a Lists all files and directories, including hidden ones (those starting with .).

ls -la Lists all files and directories in a detailed, long format, including hidden ones.

mkdir folderName Creates a new directory with the specified name.

cd folderName Changes the current directory to the specified folder.

cd .. Moves up one directory level.

cd Changes to the user’s home directory.

touch fileName.txt Creates a new empty file with the specified name.

echo “Hello world” Prints the text “Hello world” to the terminal.

mv fileName.txt folderName2 Moves the file fileName.txt to folderName2.

nano Opens the Nano text editor to create or edit files.

cat fileName.txt Displays the content of the file fileName.txt in the terminal.

history Displays a list of recently executed commands.

rm fileName.txt Deletes the file fileName.txt.

System Management:

sudo apt install nodejs Installs the Node.js package using the APT package manager with superuser privileges.

sudo apt update Updates the package list and information for available software packages.

Note: It is recommended to use apt commands on the terminal and apt-get in bash scripts. This is because apt is the newer version and is constantly evolving, which can sometimes break backward compatibility. Using apt-get commands ensures guaranteed backward compatibility and provides more functionality for script usage.

man Displays the manual page for the specified topic, providing detailed information about commands and concepts.

Until next time :) Connect me here :)

50+ Web3 and Blockchain Keywords Explained

Sourin🥑 | Web 3.0 & Blockchain🚀 — Mon, 10 Jul 2023 06:40:41 +0000

Web3.0: Web3.0, also known as Web3, refers to the next generation of the internet that incorporates decentralized technologies such as blockchain, cryptocurrencies, and peer-to-peer networks. Web3.0 aims to empower users with more control over their data, privacy, and online interactions. It envisions a more open, transparent, and user-centric internet.

Decentralization: Decentralization refers to the distribution of control and decision-making across a network, rather than being held by a central authority. In the context of Web3 and blockchain, decentralization is a key principle that aims to eliminate the need for intermediaries and allows participants to have more control over their data and transactions.

Smart Contract: A smart contract is a self-executing contract with the terms of the agreement directly written into code. Smart contracts are deployed on blockchain platforms and automatically execute predefined actions when certain conditions are met. They enable trustless and transparent interactions between parties.

Decentralized Finance (DeFi): Decentralized Finance (DeFi) refers to the use of blockchain technology and smart contracts to recreate traditional financial systems in a decentralized manner. DeFi aims to provide financial services such as lending, borrowing, and trading without the need for intermediaries like banks. It enables greater accessibility and transparency in financial transactions.

Non-Fungible Token (NFT): A Non-Fungible Token (NFT) is a unique digital asset that represents ownership or proof of authenticity of a specific item or piece of content. NFTs have gained popularity in the art and collectibles space. Each NFT has a unique identifier and cannot be exchanged on a one-to-one basis like cryptocurrencies.

Interoperability: Interoperability refers to the ability of different blockchain networks or systems to communicate and interact with each other seamlessly. It is important for enabling data and asset transfer between different blockchains and ensuring compatibility between various chains.

Consensus Mechanism: A consensus mechanism is a protocol or algorithm used to achieve agreement among participants in a distributed network. Consensus mechanisms ensure that all nodes in a blockchain network agree on the validity of transactions and the order in which they are added to the blockchain. Examples include Proof of Work (PoW) and Proof of Stake (PoS).

Proof of Work (PoW): Consensus mechanism where miners solve complex puzzles to validate transactions, ensuring security and immutability by making tampering computationally expensive.

Proof of Stake (PoS): Consensus mechanism where validators create blocks based on staked cryptocurrency, promoting energy efficiency, scalability, and faster block validation without intensive computational puzzles.

Distributed Ledger Technology (DLT): Distributed Ledger Technology (DLT) is a broader term that encompasses blockchain technology. It refers to a decentralized and distributed database that records and stores transactions across multiple nodes or computers. Blockchain is a specific type of DLT.

Cryptocurrency: Cryptocurrency is a digital or virtual form of currency that uses cryptography for security. It operates on decentralized networks, typically based on blockchain technology. Examples of cryptocurrencies include Bitcoin (BTC) and Ethereum (ETH).

Gas: Gas refers to the unit of measurement for the computational effort required to execute transactions or smart contracts on the Ethereum blockchain. Gas is paid in Ether (ETH) and helps prevent spam and abuse by requiring users to pay for the computational resources they consume.

Oracles: Oracles are services or mechanisms that provide external data to smart contracts on the blockchain. They act as bridges between the blockchain and the real world, enabling smart contracts to interact with off-chain data sources, such as APIs, to make informed decisions and trigger actions based on real-time information.

Cross-Chain: Cross-chain refers to the ability to transfer assets or data between different blockchain networks. It involves interoperability and allows users to move assets seamlessly across different blockchains, facilitating increased liquidity and expanding the possibilities for decentralized applications.

Decentralized Autonomous Organization (DAO): A Decentralized Autonomous Organization (DAO) is an organization that operates through smart contracts on a blockchain. It is governed by a set of predefined rules and decisions are made through voting by token holders. DAOs aim to eliminate the need for traditional hierarchical structures and allow for decentralized decision-making.

Layer 2 Scaling: Layer 2 scaling solutions are techniques or protocols built on top of existing blockchains to improve scalability and increase transaction throughput. They aim to handle a larger number of transactions off-chain or in a more efficient manner, reducing congestion and lowering transaction costs. Examples of layer 2 scaling solutions include state channels and sidechains.

Permissionless: Permissionless refers to the openness and accessibility of a blockchain network or protocol. In a permissionless network, anyone can participate, validate transactions, and contribute to the network without requiring explicit permission. This characteristic is a fundamental aspect of many blockchain networks, enabling anyone to join and interact with the network without needing approval from a central authority.

Hard Fork: A hard fork is a type of upgrade or change to a blockchain protocol that is not backward compatible with older versions. It requires all participants in the network to upgrade to the new version in order to continue participating. Hard forks can result in a split in the blockchain, creating two separate chains with different rules and potentially leading to the creation of a new cryptocurrency.

Halving: Halving is an event that occurs in some cryptocurrencies, such as Bitcoin, where the block reward for miners is reduced by half after a certain number of blocks are mined. This event is programmed into the cryptocurrency's protocol and is designed to control the issuance of new coins and create scarcity over time.

Hashing Algorithm: Hashing is a process used in computing to generate a unique and fixed-size string of characters (hash) from input data of any size. In the context of blockchain, hashing is used to create a digital fingerprint of data, such as transactions or blocks, ensuring their integrity and allowing for easy verification. Hashes are used to confirm the completeness and validity of blockchain transactions.

Censorship Resistance: Censorship resistance refers to the ability of a system or platform to resist censorship or control by centralized authorities. In Web3, blockchain-based platforms provide censorship resistance by decentralizing control and allowing users to have ownership and control over their data and transactions. This enables freedom of expression and protects against arbitrary censorship or manipulation.

Decentralized Exchange (DEX): A decentralized exchange is a type of cryptocurrency exchange that operates on a blockchain network without the need for intermediaries or a central authority. DEXs allow users to trade cryptocurrencies directly with each other, using smart contracts for order matching and execution. They provide increased privacy, security, and control over assets compared to centralized exchanges.

Immutable Ledger: An immutable ledger refers to a blockchain's characteristic of being tamper-resistant and unchangeable once data is added to it. Once a transaction or data is recorded on the blockchain, it becomes part of a permanent and transparent history that cannot be altered or deleted. This property ensures the integrity and trustworthiness of the data stored on the blockchain.

Token Standards: Token standards are specific protocols or sets of rules that define the functionality and behavior of tokens on a blockchain. Examples of token standards include ERC-20 for fungible tokens, ERC-721 for non-fungible tokens (NFTs), and ERC-1155 for multi-token standards. Token standards ensure interoperability and compatibility between different tokens and enable developers to build applications that interact with tokens in a standardized way.

Decentralized File Storage: Decentralized file storage refers to the storage of data on a distributed network of nodes, rather than relying on a centralized server or provider. Blockchain-based decentralized file storage systems, such as IPFS (InterPlanetary File System) or Filecoin, allow users to store and retrieve data in a secure, distributed, and censorship-resistant manner.

Tokenomics: Tokenomics refers to the economic design and structure of a cryptocurrency or token ecosystem. It encompasses factors such as token supply, distribution, utility, governance mechanisms, and incentives. Tokenomics aims to create a sustainable and balanced ecosystem that aligns the interests of token holders, users, and other stakeholders in the network.

Zero-knowledge proofs (ZKPs): ZKPs are cryptographic protocols that allow one party (the prover) to prove the knowledge of a certain piece of information to another party (the verifier) without revealing the actual information itself. The goal of zero-knowledge proofs is to convince the verifier of the truthfulness of a statement without disclosing any additional information beyond the validity of the statement.

Ethereum: Ethereum is an open-source, blockchain-based platform that enables developers to build and deploy decentralized applications (dApps). It was proposed by Vitalik Buterin in late 2013 and development was crowdfunded in 2014. Ethereum's blockchain is fundamentally different from Bitcoin's blockchain. While Bitcoin's blockchain is used to track ownership of digital currency (bitcoins), the Ethereum blockchain focuses on running programming code of any decentralized application

Bitcoin: Bitcoin, often described as a cryptocurrency, a virtual currency or a digital currency, is a type of money that is completely virtual. It's like an online version of cash. You can use it to buy products and services, but not many shops accept Bitcoin yet and some countries have banned it altogether. Bitcoin was the first cryptocurrency and remains the most important in the market. It was invented in 2008 by an unknown person or group of people using the name Satoshi Nakamoto.

ICO: ICO stands for Initial Coin Offering and it's often used as a fundraiser for new projects. This is where a company looking to raise money to create a new coin, app, or service launches an ICO as a way to raise funds. People who buy into the ICO receive a certain number of tokens in return. ICOs are often compared to IPOs (Initial Public Offerings), but there are some significant differences

Public Key: In the world of cryptocurrencies, a public key represents a point on a particular Elliptic Curve (EC) defined in secp256k1. Public keys contain an identification byte, a 32-byte X coordinate, and a 32-byte Y coordinate. They are used in Bitcoin and other cryptocurrencies for generating addresses where funds can be seen

Private Key: In cryptocurrencies, a private key allows a user to gain full access to their wallet. The person who holds the private key fully controls the coins in that wallet. For this reason, it should be kept secret. Formally, a private key for Bitcoin (and many other cryptocurrencies) is a series of 32 bytes

Stablecoin: Stablecoins are a type of cryptocurrency designed to minimize volatility, a common issue with cryptocurrencies like Bitcoin. They achieve this stability by pegging their market value to an external reference, usually a fiat currency like the US dollar, or a commodity like gold. Some stablecoins maintain reserve assets as collateral, while others use algorithmic formulas to control supply. The primary purpose of stablecoins is to provide a more suitable option for common transactions.

Altcoin: The term altcoin refers to all cryptocurrencies other than Bitcoin and, for some, Ethereum. These alternative cryptocurrencies come in various types, each designed for different purposes. While the future value of altcoins is unpredictable, as long as the blockchain they were designed for continues to be used and developed, the altcoins will continue to exist. It's important to note that while many altcoins offer potential investment opportunities, some are scams or have lost developer and community interest

Mainnet: It refers to the main blockchain network of a cryptocurrency, where real transactions and operations take place. It is the live and production-ready network where actual value is exchanged. Mainnet is typically used for real-world applications, and transactions on the mainnet involve real cryptocurrencies.

Testnet: on the other hand, is a separate network specifically designed for testing and development purposes. It mimics the functionalities of the mainnet but uses test tokens or simulated cryptocurrencies that have no real-world value. Testnets allow developers and users to experiment, validate, and debug their applications without risking real funds. It provides a safe environment for testing new features, smart contracts, and conducting simulations before deploying on the mainnet. Testnets are crucial for ensuring the reliability and security of applications before they are deployed to the production-ready mainnet.

Remix IDE: is an online development environment for writing, testing, and deploying smart contracts on the Ethereum blockchain. It provides a user-friendly interface with a built-in code editor, compiler, debugger, and deployment tools. Remix IDE allows developers to write Solidity smart contracts, interact with contracts using a web3 provider, and test their code using various tools and plugins. It is a popular choice for Ethereum developers due to its simplicity and comprehensive features.

Infura/Alchemy: It is a popular service that provides infrastructure and API endpoints for connecting to the Ethereum blockchain. It acts as a web3 provider, allowing developers to interact with the Ethereum network without running a full Ethereum node. Infura simplifies the development process by providing reliable and scalable access to the Ethereum blockchain, eliminating the need for developers to set up and maintain their own infrastructure. It offers various API endpoints, including JSON-RPC and WebSocket, which developers can use to send transactions, retrieve data, and interact with smart contracts. Infura is widely used by developers to integrate Ethereum functionality into their applications and services.

Mining: Mining is the process of validating and adding new transactions to a blockchain. It involves solving complex mathematical puzzles to find a new block, which contains a set of transactions. Miners compete with each other to solve these puzzles by using computational power, and the first miner to find the solution gets rewarded with newly minted cryptocurrency tokens. Mining ensures the security, integrity, and decentralization of a blockchain network by preventing double-spending and maintaining consensus among participants.

Tokenization: Tokenization is the process of representing real-world assets or rights as digital tokens on a blockchain. It allows for fractional ownership, increased liquidity, and easier transfer of assets. Tokenization has applications in areas such as real estate, art, and finance.

Immutable: Immutable means that something is unchangeable or cannot be altered or tampered with. In the context of blockchain, immutability refers to the property of data stored on the blockchain that cannot be modified once it is added to the chain. This ensures the integrity and trustworthiness of the data.

Merkle Tree: A hierarchical data structure that enables efficient verification and integrity checks of large datasets. It uses cryptographic hashing to create a tree structure where each node represents the hash of its child nodes, providing an efficient way to verify the integrity of specific data without needing to examine the entire dataset.

Byzantine Fault Tolerance: The ability of a distributed system to reach a consensus even in the presence of malicious or faulty nodes. It ensures system resilience by employing redundancy, replication, and consensus algorithms to tolerate failures and prevent malicious actors from compromising the integrity and reliability of the system.

ICO (Initial Coin Offering): A fundraising method used by cryptocurrency projects to raise capital. It involves issuing and selling tokens to investors in exchange for cryptocurrencies or fiat currencies, providing early access to the project's tokens and potential returns on investment.

Whitepaper: A detailed document that outlines the concept, technology, goals, and implementation plan of a cryptocurrency project. It provides an in-depth analysis of the project's vision, technical specifications, tokenomics, and potential impact, serving as a comprehensive guide for investors and stakeholders.

Yellowpaper: Similar to a whitepaper, a yellowpaper is a technical document that provides a deeper technical understanding of a cryptocurrency project. It typically delves into the underlying protocols, algorithms, and technical intricacies of the project, providing detailed explanations and specifications for developers and researchers.

Fork: A divergence in the blockchain where a single chain splits into two separate chains, resulting in two different versions of the blockchain.

Soft Fork: A backward-compatible upgrade to the blockchain protocol where the new rules are more restrictive than the old rules, allowing the new blocks to be accepted by both old and new nodes.

Hard Fork: A non-backward-compatible upgrade to the blockchain protocol where the new rules are more permissive than the old rules, resulting in a permanent divergence in the blockchain and two separate chains that are incompatible with each other.

How to create a Web3 Wallet Like MetaMask? Web3 and Blockchain Project.

Sourin🥑 | Web 3.0 & Blockchain🚀 — Tue, 20 Jun 2023 17:28:33 +0000

Here we will create a web3 wallet like MetaMask using tech stacks like Ethers.js(v5), React, TypeScript and Tailwind CSS.

For reference I recommend you to watch this YouTube video and this GitHub Repo(Source Code). In the video I have also explained how you can create a Browser extension.

Our Wallet has 3 parts:

Create New account & Recover existing account
Fetching balance and sending ETH
Fetching transaction data from block explorer

Prerequisite: Knowledge of Web3, React.js and Backend Dev

1. Create New account & Recover existing account:

For account creation and recover we will create React component AccountCreate.tsx:

import React, { useState, useEffect } from "react";
import { generateAccount } from "../wallet-utils/AccountUtils";

import AccountDetails from "./AccountDetails";
import TransactionDetails from "./TransactionDetails";

interface Account {
  privateKey: string;
  address: string;
  balance: string;
}

const AccountCreate: React.FC = () => {
  const [showInput, setShowInput] = useState(false);
  const [seedPhrase, setSeedPhrase] = useState("");
  const [account, setAccount] = useState<Account | null>(null);

  const createAccount = () => {
    const account = generateAccount();// account object contains--> address, privateKey, seedPhrase, balance
    console.log("Account created!", account);
    setSeedPhrase(account.seedPhrase);
    setAccount(account.account);
  };

  const showInputFunction = () => {
    setShowInput(true);
  };

  const handleSeedPhraseChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    setSeedPhrase(e.target.value);
  };

  const handleSeedPhraseSubmit = (e: React.FormEvent) => {
    e.preventDefault();
    const account = generateAccount(seedPhrase);
    console.log("Recovery", account);
    setSeedPhrase(account.seedPhrase);
    setAccount(account.account);
  };

  return (
    <div className="max-w-md mx-auto bg-white rounded-md shadow-md p-6">
      <h2 className="text-2xl font-bold mb-4">Pixel Web3 Wallet on Polygon Mumbai</h2>
      <button
        onClick={createAccount}
        className="text-white bg-gradient-to-r from-purple-500 via-purple-600 to-purple-700 hover:bg-gradient-to-br focus:ring-4 focus:outline-none focus:ring-purple-300 dark:focus:ring-purple-800 shadow-lg shadow-purple-500/50 dark:shadow-lg dark:shadow-purple-800/80 font-medium rounded-lg text-sm px-5 py-2.5 text-center mr-2 mb-2"
      >
        Create Account
      </button>
      <button
        onClick={showInputFunction}
        className="text-gray-900 bg-gradient-to-r from-lime-200 via-lime-400 to-lime-500 hover:bg-gradient-to-br focus:ring-4 focus:outline-none focus:ring-lime-300 dark:focus:ring-lime-800 shadow-lg shadow-lime-500/50 dark:shadow-lg dark:shadow-lime-800/80 font-medium rounded-lg text-sm px-5 py-2.5 text-center mr-2 mb-2"
      >
        Recover Account
      </button>
      {showInput && (
        <form onSubmit={handleSeedPhraseSubmit} className="flex m-2">
          <input
            type="text"
            value={seedPhrase}
            onChange={handleSeedPhraseChange}
            className="bg-transparent border border-gray-300 rounded-md w-full py-2 px-4 placeholder-gray-400 text-gray-700 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 mr-2"
            placeholder="Enter your text"
          />
          <button
            type="submit"
            className="text-white bg-gradient-to-r from-cyan-400 via-cyan-500 to-cyan-600 hover:bg-gradient-to-br focus:ring-4 focus:outline-none focus:ring-cyan-300 dark:focus:ring-cyan-800 shadow-lg shadow-cyan-500/50 dark:shadow-lg dark:shadow-cyan-800/80 font-medium rounded-lg text-sm px-5 py-2.5 text-center mr-2 m-2"
          >
            Submit
          </button>
        </form>
      )}

      <div>
        <p className=" text-gray-900 font-medium">A/C Address: </p>
        <span className="text-gray-600 mt-2">{account?.address}</span>
      </div>

      <div>
        <p className="text-gray-900  font-medium">Your 12 Phrase Mnemonic: </p>
        <span className="text-gray-600 text-normal">{seedPhrase}</span>
      </div>

      <hr />
      {account && <AccountDetails account={account} />}
      {account && <TransactionDetails address={account.address} />}
    </div>
  );
};

export default AccountCreate;

The above component has an import named generateAccount, which is also the most important function. For that we will refer ‘AccountUtils.ts’ file. We will install npm install ethers@5 . The code is:

import { Wallet } from "ethers";

interface Account {
  privateKey: string;
  address: string;
  balance: string;
}

export function generateAccount(
  seedPhrase: string = "",
  index: number = 0
): { account: Account; seedPhrase: string } {
  let wallet: Wallet;

  if (seedPhrase === "") {
    seedPhrase = Wallet.createRandom().mnemonic.phrase;
  }

  // If the seed phrase does not contain spaces, it is likely a mnemonic
  wallet = seedPhrase.includes(" ")
    ? Wallet.fromMnemonic(seedPhrase, `m/44'/60'/0'/0/${index}`)
    : new Wallet(seedPhrase);

  // console.log("hehe",wallet);

  const { address } = wallet; // we are capturing address variable from 'wallet' object

  const account = { address, privateKey: wallet.privateKey, balance: "0" };

  // If the seedphrase does not include spaces then it's actually a private key, so return a blank string.
  return { account, seedPhrase: seedPhrase.includes(" ") ? seedPhrase : "" };
}

This sums up our first feature that is create and recover accounts!! Let’s move to second one.

2. Fetching balance and sending ETH

For fetching balance and sending ETH we will create a React component and also create an interface of chains on Ethereum network.

At the beginning we will create AccountDetails.tsx component:

import React, { useState, useEffect } from "react";
import { Account } from "../interfaces/Account";
import { ethers } from "ethers";
import { mumbai } from "../interfaces/Chain";
import { sendToken } from "../wallet-utils/TransactionUtils";

interface AccountDetailProps {
  account: Account;
}

const AccountDetails: React.FC<AccountDetailProps> = ({ account }) => {
  const [destinationAddress, setDestinationAddress] = useState("");
  const [amount, setAmount] = useState(0);
  const [balance, setBalance] = useState(account.balance);
  const [networkResponse, setNetworkResponse] = useState<{
    status: null | "pending" | "complete" | "error";
    message: string | React.ReactElement;
  }>({
    status: null,
    message: "",
  });

  const fetchData = async () => {
    const provider = new ethers.providers.JsonRpcProvider(mumbai.rpcUrl);
    let accountBalance = await provider.getBalance(account.address);
    setBalance(
      String(formatEthFunc(ethers.utils.formatEther(accountBalance)))
    );
  };

  //Required to Format decimals of ETH balance
  function formatEthFunc(value: string, decimalPlaces: number = 2) {
    return +parseFloat(value).toFixed(decimalPlaces);
  }

  useEffect(() => {
    fetchData();
  }, [account.address]);

  const handleDestinationAddressChange = (
    e: React.ChangeEvent<HTMLInputElement>
  ) => {
    setDestinationAddress(e.target.value);
  };

  const handleAmountChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    setAmount(Number.parseFloat(e.target.value));
  };

  const transfer = async () => {
    setNetworkResponse({
      status: "pending",
      message: "",
    });

    try {
      const { receipt } = await sendToken(
        amount,
        account.address,
        destinationAddress,
        account.privateKey
      );

      if (receipt.status === 1) {
        setNetworkResponse({
          status: "complete",
          message: (
            <p>
              Transfer complete!{" "}
              <a
                href={`${mumbai.blockExplorerUrl}/tx/${receipt.transactionHash}`}
                target="_blank"
                rel="noreferrer"
              >
                View transaction
              </a>
            </p>
          ),
        });
        return receipt;
      } else {
        console.log(`Failed to send ${receipt}`);
        // Set the network response status to "error" and the message to the receipt
        setNetworkResponse({
          status: "error",
          message: JSON.stringify(receipt),
        });
        return { receipt };
      }
    } catch (error: any) {
      console.error(error);
      setNetworkResponse({
        status: "error",
        message: error.reason || JSON.stringify(error),
      });
    }
  };

  return (
    <div className="">
      <div>
        <h4 className="text-gray-900 font-medium">Address: </h4>
        <a
          target="blank"
          href={`https://mumbai.polygonscan.com/address/${account.address}`}
          className="text-blue-500 hover:text-blue-600  cursor-pointer"
        >
          {account.address}
        </a>
        <br />
        <span className="text-gray-900 font-medium">Balance: </span>
        {balance} ETH
      </div>

      <div className="my-2">
        <label htmlFor="" className="text-gray-900 font-medium">
          Destination Address:
        </label>
        <input
          type="text"
          value={destinationAddress}
          onChange={handleDestinationAddressChange}
          className="border"
        />
      </div>

      <div>
        <label htmlFor="" className="text-gray-900 font-medium">
          Amount:
        </label>
        <input
          type="number"
          value={amount}
          onChange={handleAmountChange}
          className="border"
        />
      </div>

      <button
        className="text-white bg-gradient-to-r from-yellow-400 via-yellow-500 to-yellow-600 hover:bg-gradient-to-br focus:ring-4 focus:outline-none focus:ring-yellow-300 dark:focus:ring-yellow-800 shadow-lg shadow-yellow-500/50 dark:shadow-lg dark:shadow-yellow-800/80 font-medium rounded-lg text-sm px-5 py-2.5 text-center mr-2 m-2"
        type="button"
        onClick={transfer}
        disabled={!amount || networkResponse.status === "pending"}
      >
        Send {amount} ETH
      </button>

      {networkResponse.status && (
        <>
          {networkResponse.status === "pending" && (
            <p>Transfer is pending...</p>
          )}
          {networkResponse.status === "complete" && (
            <p>{networkResponse.message}</p>
          )}
          {networkResponse.status === "error" && (
            <p>
              Error occurred while transferring tokens:{" "}
              {networkResponse.message}
            </p>
          )}
        </>
      )}
    </div>
  );
};

export default AccountDetails;

If you notice, in the above file we have few interface imports.

a. Import of account data types, create a file Account.ts:

export interface Account {
    privateKey: string,
    address: string,
    balance: string,
}

b. Import of different networks on Ethereum, create a file Chain.ts:
Remember in this file you’ll need RPC-URL of the networks, you can get them from Alchemy or Infura or from somewhere else.

export type Chain = {
    chainId: string;
    name: string;
    blockExplorerUrl: string;
    rpcUrl: string;
  };

export const mumbai: Chain = {
    chainId: '80001',
    name: 'Polygon Testnet Mumbai',
    blockExplorerUrl: 'https://mumbai.polygonscan.com ',
    rpcUrl: '<YOUR-RPC-URL>',
};

export const mainnet: Chain = {
    chainId: '1',
    name: 'Ethereum',
    blockExplorerUrl: 'https://etherscan.io',
    rpcUrl: '<YOUR-RPC-URL>',
};

export const CHAINS_CONFIG = {
    [mumbai.chainId]: mumbai,
    [mainnet.chainId]: mainnet,
};

c. Third imort on AccountDetails.tsx file is TransactionUtils.ts, which contains the most import function that will be used to transfer ETH.

import { ethers, Wallet } from "ethers";
import { CHAINS_CONFIG, mumbai } from "../interfaces/Chain";

export async function sendToken(
  amount: number,
  from: string,
  to: string,
  privateKey: string
) {
  const chain = CHAINS_CONFIG[mumbai.chainId];
  const provider = new ethers.providers.JsonRpcProvider(chain.rpcUrl);//creating a
  const wallet: Wallet = new ethers.Wallet(privateKey, provider);

  const tx = { to, value: ethers.utils.parseEther(amount.toString()) };

  const transaction = await wallet.sendTransaction(tx);

  const receipt = await transaction.wait();

  return { transaction, receipt };
}

End of the second, now comes the Third part.

3. Fetching transaction data from block explorer

For this we’ll need API-Key-Token from the block explorer. You can refer the video mentioned in the beginning.

Create a file TransactionDetails.tsx. Here you’ll need to have basic understandings of backend development, as we are fetching data using axios.

We are using base uri and endpoints of Polygonscan as we are fetching data from mumbai test net of polygon.

import React, { useEffect, useState } from "react";
import axios from "axios";

interface Transaction {
  hash: string;
  from: string;
  to: string;
  isError: string;
  timeStamp: string;
}

interface TransactionTableProps {
  address: string;
}

const MUMBAI_API_KEY = "<YOUR-API-KEY>";
const MUMBAI_API_BASE_URL = "https://api-testnet.polygonscan.com/api";

const TransactionDetails: React.FC<TransactionTableProps> = ({ address }) => {
  const [transactions, setTransactions] = useState<Transaction[]>([]);

  useEffect(() => {
    const fetchTransactions = async () => {
      const endpoint = `?module=account&action=txlist&address=${address}&page=1&offset=10&sort=desc&apikey=${MUMBAI_API_KEY}`;
      const url = `${MUMBAI_API_BASE_URL}${endpoint}`;

      try {
        const response = await axios.get(url);
        const transactionData: Transaction[] = response.data.result;
        setTransactions(transactionData);
      } catch (error) {
        console.error("Error fetching transactions:", error);
      }
    };

    fetchTransactions();
  }, [address]);

  return (
    <table className="min-w-full divide-y divide-gray-200">
    <thead className="bg-gray-100">
      <tr>
        <th className="py-2 px-4">No.</th>
        <th className="py-2 px-4">Hash</th>
        <th className="py-2 px-4">From</th>
        <th className="py-2 px-4">To</th>
        <th className="py-2 px-4">Status</th>
        <th className="py-2 px-4">Timestamp</th>
      </tr>
    </thead>
    <tbody>
      {transactions.map((transaction, index) => (
        <tr key={index} className={index % 2 === 0 ? 'bg-gray-50' : ''}>
          <td className="py-2 px-4">{index + 1}</td>
          <td className="py-2 px-4">
            {`${transaction.hash.slice(0, 5)}...${transaction.hash.slice(-3)}`}
          </td>
          <td className="py-2 px-4">
            {`${transaction.from.slice(0, 5)}...${transaction.from.slice(-3)}`}
          </td>
          <td className="py-2 px-4">
            {`${transaction.to.slice(0, 5)}...${transaction.to.slice(-3)}`}
          </td>
          <td className="py-2 px-4">
            {transaction.isError === '0' ? '✅' : '❌'}
          </td>
          <td className="py-2 px-4">{transaction.timeStamp}</td>
        </tr>
      ))}
    </tbody>
  </table>
  );
};

export default TransactionDetails;

This sums up the coding part.

This is how wallet browser extension looks like, steps are explained in the YT video.

If you stuck anywhere, hit me up

Generate better response from AI Language Models (ChatGPT, Google BARD) as a Web3 or Blockchain Developer. Step by step guide.

Sourin🥑 | Web 3.0 & Blockchain🚀 — Sat, 17 Jun 2023 16:31:11 +0000

The 6 Steps we have to keep in mind.

1. Context
2. A Specific goal 
3. A specific format 
4. Breaking down into smaller parts 
5. Assign smaller tasks 
6. Providing

Explaining them in a step-by-step way:
Context: Giving the AI model clear and pertinent context aids in its understanding of the particular issue or subject you want assistance with. The model can better personalise its answer to your needs the more background information you offer.

A Specific Goal: Clearly state your goal for the talk or what you hope to accomplish. Having a clear objective aids the AI model in producing solutions that are pertinent and laser-focused.

A Specific Format: Indicate the structure or format you like for the response. Mentioning the preferred style, for instance, if you want a step-by-step tutorial, a concise summary, or a comparison of several possibilities, aids the model in producing a more appropriate response.

Breaking Down into Smaller Parts: Consider dividing a big activity or topic into smaller, more manageable components. This enables the model to address each component independently and offer more thorough and precise replies.

Assigning Smaller Tasks: Divide the task into tiny sub-tasks rather than giving the model a massive request. The model can handle each sub-task well and deliver more precise and focused replies with the aid of this strategy.

Providing Examples: Giving particular examples that are connected to your question might help the model grasp it better. The model may provide replies that match the patterns and features given by using examples as reference points.

Follow for more. Feel free to connect :)

How to Connect Web3 Wallet into your Website? (Web3 and Blockchain project).

Sourin🥑 | Web 3.0 & Blockchain🚀 — Fri, 02 Jun 2023 19:42:39 +0000

Connecting a MetaMask wallet to your Web3 website is important for various reasons. It allows you to connect you to your DApps, manage your Crypto assets, signing transactions and message verification and enhance security.

Prerequisite: EVM, Blockchain, JavaScript, React.js

Check if any EVM based wallet is installed in your browser

 if (typeof window.ethereum !== "undefined") {
      console.log("Wallet installed");
    }

Check installed wallet is Metamask or not

In that case we will use ethereum.isMetaMask to check:

if (typeof window.ethereum && ethereum.isMetaMask !== "undefined") {
      console.log("MetaMask Wallet is present");
    }

If you don't have MetaMask installed

 if (typeof window.ethereum === "undefined") {
      console.log("MetaMask Wallet not installed");
      window.location.href = "https://metamask.io/download.html";
    }

Now we have installed MetaMask, its time to connect the wallet with our website.

    try {
      const accounts = await ethereum.request({
        method: "eth_requestAccounts",
      });
      console.log(accounts);
    } catch (error) {
      console.error(error);
    }

These are all the methods we need to follow to connect our wallet with our frontend.

Decentralized Voting App (dApp) Tutorial. Web3 and Blockchain Project.

Sourin🥑 | Web 3.0 & Blockchain🚀 — Sun, 21 May 2023 06:31:42 +0000

Decentralized applications (DApps) are transforming various industries, bringing security, transparency, and trust to the world. One field where the potential of decentralized technology truly shines is in voting systems. By leveraging blockchain technology, decentralized voting application can be created that ensures the integrity of the voting process, removes the need for intermediaries, and empowers every individual with their voting rights.

In this comprehensive tutorial, we will create our own decentralized voting application from scratch. This guide will provide you with the knowledge and tools you need to get started.

Prerequisite-Knowledge: JavaScript, React.js, Solidity, Ethereum

But, do not worry if you don’t have the above mentioned knowledges. You can just follow along.

Step 1: We will create our Solidity smart contract

// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;

contract Election {
    struct Candidate {
        uint256 id;
        string name;
        uint256 voteCount;
    }

    address public owner;

    mapping(uint256 => Candidate) public candidates;
    mapping(address => bool) public voters;

    uint256 public candidataCount;

    constructor() {
        owner = msg.sender;
        addCandidate("Ryle");
        addCandidate("Max");
    }

    function addCandidate(string memory _name) public{
        require(msg.sender == owner, "Only owner can add candidates");
        candidataCount++;
        candidates[candidataCount] = Candidate(candidataCount, _name, 0);
    }

    function vote(uint256 _candidateId) public {
        require(!voters[msg.sender], "You have already voted");
        require(
            _candidateId <= candidataCount && _candidateId >= 1,
            "Invalid candidate Id"
        );
        voters[msg.sender] = true;
        candidates[_candidateId].voteCount++;
    }
}

Step 2: We will deploy our smart contract on test network. We will get ABI and Contract Address when we deploy our smart contracts.

Step 3: Now we will create our Next.js Application in our local machine by npx create-next-app my-app.

Step 4: **In the **index.js write this file

import Head from "next/head";
import Image from "next/image";
import styles from "../styles/Home.module.css";
import React, { useState, useEffect } from "react";
import { ethers } from "ethers";
import { contractABI, contractAddress } from "./Engine";
import Navbar from "./Navbar";

export default function Home() {
  const [candidatesUseState, setCandidatesUseState] = useState([]);
  const [voters, setVoters] = useState([]);
  const [account, setCurrentAccount] = useState();
  const [walletAddress, setWalletAddress] = useState("");
  const [votedOrNot, setVotedOrNot] = useState();
  const [candidateId, setCandidateId] = useState();

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

      if (!ethereum) {
        console.log("Please install metamask!!!");
      } else {
        // console.log("We have the ethereum object", ethereum);
      }

      const accounts = await ethereum.request({ method: "eth_accounts" });
      if (accounts.length) {
        const account = accounts[0];
        // console.log("Authorized account has found", account);
        setCurrentAccount(account);
        console.log("Connected");
      } else {
        setCurrentAccount("");
        console.log("No authorized account has found!");
      }
    } catch (error) {
      console.error(error);
    }
  };

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

      if (!ethereum) {
        alert("Metamask has found!");
        return;
      }

      const accounts = await ethereum.request({
        method: "eth_requestAccounts",
      });

      // console.log("Connected", accounts[0]);
      // setCurrentAccount(accounts[0]);
    } catch (err) {
      console.error(err.message);
    }
  };

  const getCandidates = async (candidateId) => {
    const provider = new ethers.providers.Web3Provider(window.ethereum);

    const connection = new ethers.Contract(
      contractAddress,
      contractABI,
      provider
    );

    const candidatesCount = Number(await connection.candidataCount());
    console.log(candidatesCount);

    for (var i = 1; i <= candidatesCount; i++) {
      const candidate = await connection.candidates(i);

      const id = candidate[0];
      const name = candidate[1];
      const voteCount = candidate[2];

      const item = {
        id: Number(id),
        name: name.toString(),
        voteCount: voteCount.toNumber(),
      };
      setCandidatesUseState((prev) => [...prev, item]);
    }
    // console.log(candidatesUseState);
  };

  const checkVotingStatus = async (voter) => {
    try {
      const provider = new ethers.providers.Web3Provider(window.ethereum);

      const connection = new ethers.Contract(
        contractAddress,
        contractABI,
        provider
      );

      const hasVoted = await connection.voters(voter);
      console.log(voter, "hasVoted: ", hasVoted);
      setVotedOrNot(hasVoted);
    } catch (error) {
      console.error(error);
    }
  };

  const changeHandler = (e) => {
    setWalletAddress(e.target.value);
  };

  const handleButtonClick = async () => {
    await checkVotingStatus(walletAddress);
  };

  const vote = async (candidateId) => {
    try {
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const signer = await provider.getSigner();

      const connection = new ethers.Contract(
        contractAddress,
        contractABI,
        signer
      );

      const vote = await connection.vote(candidateId);
    } catch (error) {
      console.error(error);
    }
  };

  const handleChange2 = (e) => {
    setCandidateId(e.target.value);
  };

  const buttonClick2 = () => {
    vote(candidateId);
  };

  useEffect(() => {
    checkIfWalletIsConnected();
    connectWallet();
    getCandidates();
  }, []);

  return (
    <div className="">
      <Head>
        <title>Voting Dapp ~ heysourin</title>
        <meta name="description" content="Generated by create next app" />
        <link rel="icon" href="/icon.png" />
      </Head>

      <main className="">
        <Navbar account={account} connectWallet={connectWallet} />

        <h1 className="font-bold text-3xl m-5">Candidates:</h1>
        <div className="flex flex-row">
          <table className="w-full border-collapse mx-10">
            <thead>
              <tr>
                <th className="py-2 px-4 border">Candidate Id</th>
                <th className="py-2 px-4 border">Candidate Name</th>
                <th className="py-2 px-4 border">Vote Count</th>
              </tr>
            </thead>
            <tbody>
              {candidatesUseState.map((candidate, i) => (
                <tr key={i}>
                  <td className="py-2 px-4 border">{candidate.id}</td>
                  <td className="py-2 px-4 border">{candidate.name}</td>
                  <td className="py-2 px-4 border">{candidate.voteCount}</td>
                </tr>
              ))}
            </tbody>
          </table>
        </div>

        {/* @note CHECK IF VOTED*/}
        <div>
          <h2 className="font-bold text-3xl mt-10 ml-5">Check Voted or Not:</h2>
          <div className="flex flex-row mx-10">
            <input
              type="text"
              className="border border-gray-300 px-4 m-4"
              placeholder="Enter wallet address"
              value={walletAddress || ""}
              onChange={changeHandler}
            />
            <button
              onClick={handleButtonClick}
              className="bg-gradient-to-r from-orange-600 to-yellow-500 text-white font-bold py-2 px-4 rounded m-4"
            >
              Check if voted
            </button>
            <div className="mt-6">
              {votedOrNot ? (
                <p>You have already voted, can not vote anymore!</p>
              ) : (
                <p>You have not voted yet!</p>
              )}
            </div>
          </div>
        </div>

        <div>
          <h2 className="font-bold text-3xl mt-8 ml-5">Vote: </h2>
          <div className="flex flex-row mx-10">
            <input
              type="text"
              className=" w-24 mx-3 my-4 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500"
              pattern="\d{0,2}"
              maxLength="2"
              placeholder="Candidate Id"
              value={candidateId || ""}
              onChange={handleChange2}
              required
            />
            <button
              onClick={buttonClick2}
              className="bg-gradient-to-r from-purple-700 to-blue-500 text-white font-bold py-2 px-4 rounded m-4"
            >
              Vote
            </button>
            <div className="mt-6"></div>
          </div>
        </div>
      </main>

      <footer className="flex items-center justify-between bg-gradient-to-r from-gray-900 to-gray-700 p-6 text-white">
        <a
          href="https://github.com/heysourin"
          target="_blank"
          className="text-left"
        >
          My Github
        </a>
        <a
          href="https://linkedin.com/in/heysourin"
          target="_blank"
          className="text-left"
        >
          My LinkenIn
        </a>
        <span className="text-right">
          <a
            href="https://github.com/heysourin/Voting-dApp-on-Avalanche-Network"
            className="text-white"
          >
            Source Code
          </a>
        </span>
      </footer>
    </div>
  );
}

The above file has Navbar component import. Create a file Navbar.jsx in the pages folder. Code:

import { React } from 'react'

const Navbar = ({ account, connectWallet }) => {
  return (
    <nav className="flex items-center justify-between flex-wrap bg-gradient-to-r from-gray-900 to-gray-700 p-6">
      <div className="flex items-center flex-shrink-0 text-white mr-6">
        <span className="font-bold text-3xl tracking-tight">
          Web3 Voting DAPP
        </span>
      </div>
      <div className="flex">
        {account ? (
          <button
            type="button"
            className='className="bg-gradient-to-r from-blue-500 to-blue-700 text-white py-2 px-4 rounded-m font-bold'
          >
            {account.slice(0, 6) + '...' + account.slice(38, 42)}
          </button>
        ) : (
          <button
            type="button"
            className='className="bg-blue-500 bg-blue-700 text-white font-bold py-2 px-4 rounded"'
            onClick={connectWallet}
          >
            Connect Wallet
          </button>
        )}
      </div>
    </nav>
  )
}

export default Navbar

Now you are good to go :)

GitHub repo to refer.

If you need any help, feel free to connect.