DEV Community: Abdul Maajid

Top Tools for Solidity Smart Contract Developers

Abdul Maajid — Wed, 22 Feb 2023 14:17:25 +0000

Introduction:

In the fast-evolving world of blockchain, smart contracts are becoming increasingly popular. They provide a secure, efficient, and transparent way to conduct transactions, making them ideal for a wide range of applications, from supply chain management to voting systems.

As a smart contract developer, you know that creating, testing, and deploying smart contracts can be a complex process. Luckily, there are a number of tools available that can help you streamline your workflow and ensure your smart contracts are error-free and efficient.

In this article, we will discuss the top tools for smart contract developers that can help you simplify the development process, save time, and improve your coding skills.

Section 1: Solidity Development Tools

Solidity is the most widely used programming language for smart contract development. Here are some essential tools that every Solidity developer should be familiar with:

Remix: Remix is an integrated development environment (IDE) that provides a range of features for Solidity developers. It includes a compiler, debugger, and testing environment, as well as a built-in code editor.
Truffle: Truffle is a development framework that simplifies the process of building, testing, and deploying smart contracts. It provides a suite of tools, including a development console, testing framework, and asset pipeline, to make smart contract development more efficient.
Hardhat: Hardhat is another development environment that provides a range of features for Solidity developers. It includes a local blockchain for testing, a testing framework, and a plugin system that allows developers to extend its functionality.

Section 2: Testing and Debugging Tools

Testing and debugging smart contracts is a crucial part of the development process. Here are some tools that can help you ensure your smart contracts are error-free:

Ganache: Ganache is a local blockchain that allows you to test your smart contracts in a simulated environment. It provides a range of features, including a built-in web3 provider and a user-friendly interface for monitoring transactions.
Solhint: Solhint is a linter for Solidity code that checks for common errors and style issues. It can be integrated into your development environment to provide real-time feedback on your code.
MythX: MythX is a security analysis tool for smart contracts. It provides automated security scans and vulnerability reports, allowing you to identify and address potential security issues before deploying your smart contract.

Deployment and Management Tools

Deploying and managing smart contracts can be a complex process. Here are some tools that can help you simplify this process:

Infura: Infura is a scalable infrastructure provider that allows you to connect to the Ethereum network without running a local node. It provides a range of features, including access to the Ethereum API and a range of developer tools.
Etherscan: Etherscan is a blockchain explorer that provides a range of features for Ethereum developers. It allows you to view transaction details, monitor contract activity, and explore the Ethereum blockchain.
OpenZeppelin: OpenZeppelin is a library of reusable smart contract components that can help you save time and ensure your smart contracts are secure. It includes a range of pre-built contracts, such as ERC20 and ERC721 tokens, as well as tools for testing and deployment.
BoringSolidity: BoringSolidity is a set of libraries for Solidity smart contract development that aims to simplify and standardize common tasks, reduce the risk of vulnerabilities, and improve overall code quality. It was developed by ConsenSys Diligence, a leading security audit firm in the blockchain industry.

Conclusion:

In conclusion, building smart contracts can be a challenging but rewarding task. Fortunately, there are many tools available to make the process easier and more efficient. From development frameworks and IDEs to testing and analysis tools, the options are vast and diverse. As a smart contract developer, it's important to stay up-to-date with the latest trends and tools in the industry to ensure that you're building the best possible products. By using the tools discussed in this article, you can streamline your development process and create more secure and robust smart contracts.
So go ahead, dive in, and start building the next generation of decentralized applications.

I hope you found this article useful, if you need any help please let me know in the comment section. Would you like to buy me a coffee, You can do it Here

Let's connect on Twitter and LinkedIn.

Some Most Used NFT Standards

Abdul Maajid — Sun, 23 Oct 2022 18:20:38 +0000

ERC721 is the basic standard used to build token known as NFT(non-fungible token). A Non-Fungible Token (NFT) is used to identify something or someone in a unique way. This type of Token is perfect to be used on platforms that offer collectible items, access keys, lottery tickets, numbered seats for concerts and sports matches, etc.

There are multiple standards used to build a nft tokens, the most popular are:

ERC-721
ERC-721A
ERC-1155

ERC721

ERC721 token standard actually started off the NFT phenomenon. The standard was a first of its own kind and helped in creating unique tokens.

ERC721 with ERC721Enumerable extension enhances the functionality of the original ERC721 by adding enumerability of all token ids in the contracts, and a way to check all token ids owned by an account.

Pros:

Makes easy to find tokens by their associated tokenID by adding some utility functions like totalSupply, tokenByIndex, and tokenOfOwnerByIndex.

Cons:

Store redundant/unneeded information on-chain. which drives up the costs of not only minting tokens but also transferring them
Managing increasingly large loops.
Mint price cost increase after the first mint

ERC-721A

ERC721A is an improved implementation of the ERC721 standard that supports minting multiple tokens for close to the cost of one. You can save up to 80% on mints if you use this NFT minting contract

Pros:

Gas savings for minting multiple NFTs in a single transaction.
Removing duplicate storage from OpenZeppelin’s ERC721Enumerable.
Updating the owner’s balance once per batch mint request, instead of per minted NFT.
Updating the owner data once per batch mint request, instead of per minted NFT.

Cons:

Transfer transactions cost more gas, which means it may cost more to gift or sell an ERC721A NFT after minting.

ERC-1155

ERC-1155 a standard interface for contracts that manage multiple token types, ERC1155 NFT is the same as an ERC721 NFT when the allowed mint quantity is equal to ‘1’. The most notable aspect is the difference between ERC 1155 and ERC 721 focuses largely on support for batch transfers.

Pros:

Facilitate batch transfers, reducing network congestion and lowering gas costs by up to 90%.
Has a transfer security function that enables hassle-free transactions and allows tokens to be reclaimed by the issuer if sent to the wrong address.
Requires a single smart contract for infinite tokens

Cons:

The sole disadvantage of ERC-1155 is that it keeps less reliable data to save time and money on transactions.

Which one do you use or prefer to use to build an NFT Token and why🤔?

I hope you found this article useful, if you need any help please let me know in the comment section. Would you like to buy me a coffee, You can do it Here

Let's connect on Twitter and LinkedIn.

ERC20 vs ERC721 vs ERC 1155

Abdul Maajid — Sun, 01 May 2022 11:40:12 +0000

Ethereum is a technology that's home to digital money, global payments, and applications. Ethereum is an open-source, decentralized blockchain with EVM compatibility and smart contract functionality that enables anyone to build and run decentralized applications on its ecosystem.
Ethereum further empowers the global trade and finance industries with its rich ecosystem and ability to support various tokens such as Fungible tokens, semi-fungible tokens, and
non-fungible tokens (NFTs).

On Ethereum Blockchain, tokens can represent virtual currencies (that hold real-world value), digital items, lottery tickets, fiat currencies like USD, and even a company’s share integrated on the Ethereum blockchain and used for various purposes. So there must some standard that should back such powerful features of tokens on blockchain. That's why Application-level standards and conventions, including contract standards such as token standards (ERC-20) and many more developed Link.

Witnessing the need for change, the Ethereum community introduces new token standards to help enterprises streamline their business operations in the Ethereum ecosystem. For this guide, we are keeping our discussion up to the three major token standards-ERC20 vs ERC721vs ERC1155.

What does ERC token standards?

ERC stands for Ethereum request for comment. An ERC20 token is a standard used for creating and issuing smart contracts on the Ethereum blockchain. Smart contracts can then be used to create smart property or tokenized assets that people can invest in.

ERC-21, ERC-721, and ERC-1155 are the three prevalent ERC token standards that most industries utilize to create their tokens. ERC standards, in a way, define smart contract standards for writing the smart contract that regulates the token activities on Ethereum.

Note that enterprises can also create tokens on Ethereum that do not abide by any token standard. Still, these tokens lack compatibility with important components of Ethereum, such as DeFi exchange and decentralized wallets.

ERC20 vs ERC721 vs ERC 1155:

ERC token standard start from ERC-20 to ERC-4987, the evolution of the ERC tokens has been a great effort to keep Ethereum’s momentum high and make it a more mainstream. Let’s focus on the three major token standards-ERC20 vs ERC721 vs ERC 1155.

ERC-20: Fungible tokens

ERC-20 tokens is the first token standard that introduced to enable the creation of fungible tokens. Every ERC20 token is interchangeable with each other. Fungible tokens, for example, represent assets whose value can be replaced with something of equal value like Fiat currencies.

Virtually, the ERC-20 token can represent the following digital assets:

Tickets for an online contest or scheme.
Real-world financial assets such as a company’s stock, share dividend, etc.
Reputation points from online games.
Other redeemable points.

ERC-20 tokens are Ethereum’s solution for streamlining the procedure of token integration and their regulation. This token standard further helps developers create a smart contract for tokenizing any Fungible asset. Eventually, the smart contract regulates a decentralized application built on Ethereum.

ERC-721: Non-fungible tokens(NFT)

The use of non-fungible tokens or NFTs is increasingly popular. From tokenizing digital content to a real-world asset, NFTs have been unlocking many benefits for people specially for artists.

On Ethereum, a token representing a one kind of digital asset must comply with the ERC-721 token standard. Some known NFT- Cryptokitties, Bored APE, was built on the Ethereum blockchain.

For understanding the role of ERC-721, check the following statement:

ERC-20 is important to discover new cryptocurrencies. Likewise, ERC-721 is essential to create new and interesting NFTs that represent immutable ownership proof. Let’s understand what can ERC-721 represents:

A unique digital content piece.
Real estate property.
Social media content Tweets, Videos and pictures.
Gaming assets and collectibles.
Gaming characters.

The use of NFTs is vast, and every new technology utilizes NFTs or NFT technology to find amazing possibilities in the virtual business world.

ERC-721 token standard addresses all these challenges, and users provide someone with the ownership of unique digital assets, trackable through Ethereum’s public ledger.

ERC-1155: Multi Token Standard

A standard interface for contracts that manage multiple token types. A single deployed contract may include any combination of fungible tokens, non-fungible tokens or other configurations (e.g. semi-fungible tokens).
It can be better explained as a common token Smart contract interface for various Ethereum tokens: fungible, semi-fungible, and non-fungible tokens.

An enterprise willing to create and issue multiple tokens can leverage ERC-1155. It eliminates the hassle of writing separate smart contracts for each token standard (i.e. ERC-20, ERC-721, or more) and helps them seamlessly manage all their tokens.

ERC-1155 token can represent the following:

Tokens.
NFTs.
Redeemable shopping vouchers etc.

Conclusion

ERC-20, ERC-721, and ERC-1155 are currently the prevalent token standards. Likewise, the new and improved token standards will help enterprises launch more successful projects.

I hope you found this article useful, if you need any help please let me know in the comment section. Would you like to buy me a coffee, You can do it Here

Let's connect on Twitter and LinkedIn.

Best Free Resources to Learn Web3/Blockchain Development

Abdul Maajid — Mon, 14 Mar 2022 07:50:46 +0000

Introduction

Web3 is very popular right now. Web3 developers are earning more than web2 developers. Probably, it’s a good time to start learning Blockchain/web3. In this post, We will explore some great free resources to learn.

Basic

Buildspace

Buildspace offers very good tutorials to understand web3 stuff. If you're curious about web3 but not sure where to start -- this is the platform for you. Learn + start building cool stuff right now, earn NFTs, access secret work opportunities in crypto.
Their discord server is also very helpful for people who want to learn web3. A great thing is that after you finish a tutorial, Buildspace will give you an NFT.

ODYSSEY

ODYSSEY is a great site to understand the concepts of Web3 on other topics that are related to web3. For example, blockchain, NFTs, web3 concept, DeFi, DAO etc.

useWeb3

useWeb3 is a very useful learning platform to access huge amount of helpful resources to learn Web3 and Blockchain. Here you can get all type of content like Books, Tutorials, Code Challenges etc.

thirdweb

Thirdweb provide Tools that accelerate your workflow. They provide built in Intuitive SDKs and widgets for developers. Here you can create smart contracts without writing any code. thirdweb is a good platform for non-tech people.
thirdweb allows us to build a dApps like NFT marketplace NFT collection etc very quickly.

Moralis

https://moralis.io/ is the ultimate Web3 Development Platform. You can build with one snippet of code. Save time + cost of building your own back-end infrastructure and use our fully managed, infinitely scalable enterprise-grade infrastructure — with one snippet of code. It's a best resource to learn Web3 development.

Questbook

Questbook is very good platform to learn blockchain and web3 development. They have multiple Tracks to learn like Build on Ethereaum, Build on Solana etc. Even you can earn Nfts by completing Quests.

Crypto Zombies

Crypto Zombies is a really helpful to understand solidity basics and dapp’s simple architecture for beginners. CryptoZombies is an interactive school that teaches you all things technical about blockchains. Learn to make smart contracts in Solidity by making your own crypto-collectibles game.

Pointer

Pointer offers really nice tutorials for developers. Here you can Build a full-stack Blockchain app.

LearnWeb3

LearnWeb3 offers great tutorials. Their tutorials are divided into 4 levels: Freshman, Sophomore, Junior, and Senior.
Also, they offer tests to check your understanding.

Figment

Figment is offering a lot of tutorials on blockchain and web3 development. They offer you tutorials for multiple Blockchains like Etheream, Solana, Terra etc.

Youtube

Here are some best youtube channels to learn.

Nader Dabit YouTube Channel

https://www.youtube.com/c/naderdabit
Some of you may know, Nader used to work as a DevRel at Amazon, but now he is in the web3 world. He has released many useful videos since last year.

Patrick Collins YouTube Channel

https://www.youtube.com/c/PatrickCollins
Patrick is a DevRel at Chainlink and his videos cover a lot of things that are related to blockchain.

ETHGlobal YouTube Channel

https://www.youtube.com/c/ETHGlobal
ETHGlobal helps run hackathons all over the world. Our goal is to be the best on-ramp to the global Ethereum community. They are leveraging years of experience to foster a world-class ecosystem of Ethereum developers and entrepreneurs.

Chainlink YouTube Channel

https://www.youtube.com/channel/UCnjkrlqaWEBSnKZQ71gdyFA
Chainlink also provide you lot of videos to learn about blockchain and web3.

HashLips

https://www.youtube.com/c/HashLipsNFT
If you are interested in NFTs, want to learn about NFTs then this Channel is the best place to learn.

Dapp University

https://www.youtube.com/c/DappUniversity
Dapp Univeristy is very good youtube channel if you want to learn web3 and development on EVM based blockchains.

Solana Labs

https://www.youtube.com/c/Solanalabs
This is solana's official channel if you want to learn about solana blockchain.

Blog

Here are some best articles to learn about Blockchain and web3
FullStack Web3 — Everything You Need to Know by Patrick Collins
https://medium.com/better-programming/everything-you-need-to-know-about-fullstack-web3-94c0f1b18019
How to Become a Blockchain Engineer by Patrick Collins
https://medium.com/better-programming/how-to-become-a-blockchain-engineer-fa4386a0504f
The Complete Guide to Full Stack Ethereum Development by Nader Dabit
https://dev.to/dabit3/the-complete-guide-to-full-stack-ethereum-development-3j13
The Complete Guide to Full Stack Solana Development with React, Anchor, Rust, and Phantom by Nader Dabit
https://dev.to/edge-and-node/the-complete-guide-to-full-stack-solana-development-with-react-anchor-rust-and-phantom-3291

I hope you found this article useful, if you need any help please let me know in the comment section. Would you like to buy me a coffee, You can do it Here

Let's connect on Twitter and LinkedIn.

👋 Thanks for reading, See you next time

How to Create an NFT(ERC-721) using OpenZeppelin

Abdul Maajid — Sat, 29 Jan 2022 10:13:18 +0000

Introduction

Now a days blockchain is very trending lot of people are earning by selling and creating NFTs. If you want to build your own NFT collection. So in this article, I will create a non-fungible-token (NFT) and deploy to a public testnet.

What is NFT?

NFT stands for Non Fungible token is used to identify something or someone in a unique way. NFTs are tokens that we can use to represent ownership of any unique item. By NFTS we can tokenize things like art, collectibles, even any real state property. They can have only one owner at a time and they're secured by the Ethereum blockchain. Only owner can transfer ownership of NFT.

NFT Standard(ERC-721)

The ERC-721 is the most common NFT standard. If your Smart Contract implements certain standardized API methods, it can be called an ERC-721 Non-Fungible Token Contract.

These methods are specified in the EIP-721. Open-source projects like OpenZeppelin have simplified the development process by implementing the most common ERC standards as a reusable library.
Here is the final Contract code for NFT which we will deploy to testnet(Ropsten).

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract ZPunks is ERC721, ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;

    Counters.Counter private _tokenIdCounter;

    constructor() ERC721("ZPunks", "ZPK") {}

    function _baseURI() internal pure override returns (string memory) {
        return "https://ipfs.infura.io:5001/api/v0/cat?arg=";
    }

    function safeMint(address to, string memory uri) public onlyOwner {
        uint256 tokenId = _tokenIdCounter.current();
        _tokenIdCounter.increment();
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, uri);
    }

    // The following functions are overrides required by Solidity.

    function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
        super._burn(tokenId);
    }

    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }
}

Lets break it to understand every function purpose.

pragma solidity ^0.8.2;

First of all we are setting our solidity version for this contract. In this contract I am setting ^0.8.2 which means to install version 0.8.2 or the latest minor or patch version such as 0.8.7.
And after that we are importing all required files from openzeppelin library. And then inheriting in our main contract.

using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;

Here we are using openzeppelin's counter library for saving NFT ids in contract.

constructor() ERC721("ZPunks", "ZPK") {}
function _baseURI() internal pure override returns (string memory) {
    return "https://ipfs.infura.io:5001/api/v0/cat?arg=";
}

After that we are setting NFT name and symbol in constructor. After setting NFT name we set base uri of NFT's data. I set IPFS uri you can set your own api uri too.

function safeMint(address to, string memory uri) public onlyOwner {
    uint256 tokenId = _tokenIdCounter.current();
    _tokenIdCounter.increment();
    _safeMint(to, tokenId);
    _setTokenURI(tokenId, uri);
}

Then we have function for mint our nft. In this function we have two parameters first is the address of the nft owner and second is Hash of data you stored. In this function onlyOwner modifier is used which means this function can only be called by Owner of this contract.

function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
    return super.tokenURI(tokenId);
}

Then in the last we have tokenUri function which we will use to retrieve our NFT's stored uri Metadata.

Deploy Contract

Now Lets deploy our NFT contract. I will deploy contract on Polygon Mumbai testnet. You can choose any testnet to deploy. If you want to deploy on Polygon Mumbai tesnet you can add network on metamask using following congiuration.

Network Name: Polygon Testnet

Chain ID: 80001

RPC URL: https://rpc-mumbai.maticvigil.com/

Currency Symbol: MATIC

Block Explorer URL: https://mumbai.polygonscan.com/

We will deploy our contract using remix IDE. Now let open remix IDE. And create new file and name MyNFT.sol.

After creating new file now copy the above contract code and paste in new created file and save.

Now lets move to compile section and compile our contract. Here we can see the compiler at top here we can select solidity version. I am using v0.8.7 you can use which you want to use and then press compile button.

Now lets move to deployment section to deploy our contract on Polygon Mumbai testnet. Here we can see on top ENVIRONMENT change this to Injected Web3 and change contract to contract name you have in file.

And then click on deploy button and approve transaction after a while you contract will be deployed on blockchain and you can interact with contract and mint your NFT.

Here we can see all the functions from our contract file. We can mint our first nft using function named safeMint it needs two params one is address and IPFS Hash of nft which you can get after uploading image to IPFS.
Congratulations! on creating your NFT contract.

I hope you found this article useful, if you need any help please let me know in the comment section. Would you like to buy me a coffee, You can do it Here

Let's connect on Twitter and LinkedIn.

👋 Thanks for reading, See you next time

Top Programming Languages To Create Smart Contracts

Abdul Maajid — Thu, 04 Nov 2021 11:00:17 +0000

There are many programming languages that allow you to write smart contracts. In this article, we’ll explore some top programming languages used to build smart contracts.

First Let's understand what is a smart contract.

Smart Contract

A smart contract is a computer program that is used to exchange assets including money, property, or shares without the need of any intermediate to function. The code and the agreements are contained therein exist over a distributed, decentralized blockchain network e.g. Ethereum, Solana, Bitcoin, etc.

For example, if you want to purchase a piece of land using a smart contract, your land ownership documents will be sent to you immediately after your payment is completed. You don’t need to trust a third-party site to transfer the ownership after making payments.

Use Cases

Government Voting
Supply Chain Management
Insurance Claim
Record Storing
Trading Activities

So, here is a list of top smart contract languages, Let’s get into it.

1. Solidity

Solidity is an object-oriented, high-level language for implementing smart contracts. Solidity was first developed by Gavin Wood, Christian Reitwiessner, Yoichi Hirai, and several of Ethereum’s core contributors to enable the development of smart contracts that functioned on Ethereum.

Influenced by C++, Python, and JavaScript, and is designed to target the Ethereum Virtual Machine (EVM), Solidity is the first blockchain programming language that one must learn. Especially when you want to develop dApps or are looking to get into the ICO development game.
Major platforms that support the Solidity language.

Ethereum
Polkadot
Binance Smart Chain
Tron
Uniswap

2. RUST

Rust is an ideal smart contract language: It is type-safe, memory safe, and free of undefined behaviors. It generates small binaries because it doesn’t include extra bloat, like a garbage collector, and advanced optimizations and tree shaking remove dead code. Through compiler flags, Rust can automatically protect against integer overflow. In the space-constrained blockchain world size is important. The Rust compiler is a great help for that, since it reorders struct fields in order to make each type as small as possible. Thus Rust data structures are very compact, in many cases even more compact than in C.

Though a newbie in the Blockchain ecosystem, Rust is also being widely considered for building innovative, immutable, and secure solutions.

Rust language enables open-source developers to create quick and effective Blockchain frameworks. It also serves them with a highly-capable mechanism of managing mutable states, amazing code optimization, better memory options, and concurrency-based opportunities.
Major platforms that support the RUST language.

Solana
Polkadot
OpenEthereum
Zero-chain
Bitcoin Cash

3. VYPER

Vyper is a contract-oriented, pythonic programming language that targets the Ethereum Virtual Machine (EVM).

It was designed to improve upon Solidity, another smart contract language for Ethereum, by limiting unsafe practices and enhancing readability; Vyper seeks to optimize the security and auditability of smart contracts.

Vyper provides the following features:

Bounds and overflow checking: On array accesses and arithmetic.
Support for signed integers and decimal fixed-point numbers
Decidability: It is possible to compute a precise upper bound for the gas consumption of any Vyper function call.
Strong typing
Small and understandable compiler code
Limited support for pure functions: Anything marked constant is not allowed to change the state. Vyper does not strive to be a 100% replacement for everything that can be done in Solidity; it will deliberately forbid things or make things harder if it deems fit to do so for the goal of increasing security.

4. JavaScript

JavaScript is a general-purpose programming language, and it’s found a place in the blockchain space. Because JavaScript is an entry-level language, most blockchains tend to create a JavaScript wrapper or library to allow developers to easily jump into the ecosystem.
The popularity of one of the renowned smart contract languages, Solidity, largely rests on its similarities to JavaScript.
The notable value advantages of JavaScript as one of the smart contract programming languages include the following,

JavaScript ensures easier and faster entry to the market due to the ease of using solutions based on JavaScript.
The design of JavaScript allows the benefit of improved scalability which can enhance the functionality of smart contracts effectively.
Most important of all, JavaScript assures limited hassles in the integration of required resources.
As a result, JavaScript can be one of the top contenders among the smart contract languages outlined in this list.

5. Python

Blockchain Programming in Python has not only ruled the world of app development, IoT app development, and network servers’ development, but is also proving to be an asset in the Blockchain-as-a-service arena.

Features

Blockchain programming in Python language is easy to learn
Access to dynamic architecture
Perfect for both base and scripting approaches,
Open-source support
Blockchain coding in python is efficient for prototyping

Python is the 2nd most popular programming language. Some of the popular blockchains developed using Python are Ethereum, Hyperledger Fabric, Steem, and NEO.

6. Yul

Yul is another entry among popular smart contract programming languages. As a matter of fact, it is an intermediate language that you can compile to bytecode for addressing the needs of different backends.
The Solidity compiler has an experimental implementation that uses Yul as an intermediate language. Yul is used in stand-alone mode and for inline assembly inside Solidity.

Yul bears planned support for EVM and ewasm (Ethereum flavored WebAssembly). It is designed to be a usable common denominator of both platforms.

Yul is a great target for high-level optimization stages that can benefit both EVM and ewasm platforms equally.
Most Ethereum-based projects most likely already use Yul.

7. Golang

Golang is an open sourced programming language loosely based on the syntax of the C programming language. Golang is an easy language for developers to learn and current estimates place Golang developers at more than 800,000 worldwide.

This programming language was created by Google. It is one language that can allow different processes to run at the same time, meaning that it allows for concurrent programming.

Most of HyperLedger’s chaincode built using HyperLedger Fabrics for smart contracts are being written in Golang. FLETA also supports Golang as a smart contract programming language.

8. Clarity

Clarity is a new language that brings smart contracts to Bitcoin. It is a decidable language, meaning you can know, with certainty, from the code itself what the program will do.

Clarity is interpreted (not compiled) & the source code is published on the blockchain. Clarity gives developers a safe way to build complex smart contracts. The Clarity open-source project is supported by the Stacks ecosystem, Hiro PBC, & Algorand.

Features

Predictable: The Clarity language uses precise and unambiguous syntax that allows developers to predict exactly how their contracts will be executed.
Secure: The Clarity language allows users to supply their conditions for transactions that ensure that a contract may never unexpectedly transfer a token owned by a user.
No compiler: Contracts written in Clarity are broadcasted on the blockchain exactly as they are written by developers. ## Conclusion So, these were some of the programming languages that can be considered for entering the Blockchain world and making the best of the flourishing opportunity. Which programming language from the above list you should use is dependent on the blockchain you want to work on. For Ethereum blockchain, for example, Solidity is the top choice for most developers.

I hope you found this article useful, if you need any help please let me know in the comment section. Would you like to buy me a coffee, You can do it here

Let's connect on Twitter and LinkedIn.

👋 Thanks for reading, See you next time

How to Create an ERC20 Token in Solidity

Abdul Maajid — Fri, 29 Oct 2021 10:00:23 +0000

Let’s start with the basics Understanding:

What is a Token?

Tokens can represent virtually anything in Ethereum:

reputation points in an online platform
skills of a character in a game
lottery tickets
financial assets like a share in a company
a fiat currency like USD
an ounce of gold
and many more...

What is an ERC-20 Token?

ERC stands for Ethereum Request for Comment, and 20 is the proposal identifier number. ERC-20 was designed to improve the ETH network.
An ERC20 token is a blockchain-based asset with similar functionality to bitcoin, ether, and bitcoin cash: it can hold value and be sent and received.
The ERC-20 introduces a standard for Fungible Tokens. In short they have a property that makes each Token be exactly the same type and value of another Token.

What makes ERC20 tokens so attractive and successful?

ERC20 tokens are simple and easy to deploy, as you will see in this tutorial.
It was the first popular specification to offer Ethereum token standardization. It was not by any means the first, but thanks to its popularity, it quickly became the industry standard.

Just like other Ethereum tokens, ERC20 tokens are implemented as smart contracts and executed on the Ethereum Virtual Machine (EVM) in a decentralized manner.

Creating your own ERC20 Token:

We will use Solidity to Create ERC-20 Token.
Solidity is an contract-oriented and statically-typed programming language that was designed to allow developers to create smart contracts.
ERC20 token need to implement the following methods and events:

Methods

Events

In order to create an ERC20 token, you need the following:

The Token’s Name
The Token’s Symbol
The Token’s Decimal Places
The Number of Tokens in Circulation

Now Head over to the Ethereum Remix IDE and make a new Solidity file, for example - token.sol

Paste the following code into your new Solidity script:

pragma solidity ^0.8.0;

interface IERC20 {

    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);


    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}


contract SampleToken is IERC20 {
    using SafeMath for uint256;

    string public constant name = "SampleToken";
    string public constant symbol = "SMT";
    uint8 public constant decimals = 18;

    mapping(address => uint256) balances;
    mapping(address => mapping (address => uint256)) allowed;

    uint256 totalSupply_;

    constructor(uint256 total) public {
        totalSupply_ = total;
        balances[msg.sender] = totalSupply_;
    }

    function totalSupply() public override view returns (uint256) {
        return totalSupply_;
    }

    function balanceOf(address tokenOwner) public override view returns (uint256) {
        return balances[tokenOwner];
    }

    function transfer(address receiver, uint256 numTokens) public override returns (bool) {
        require(numTokens <= balances[msg.sender]);
        balances[msg.sender] = balances[msg.sender].sub(numTokens);
        balances[receiver] = balances[receiver].add(numTokens);
        emit Transfer(msg.sender, receiver, numTokens);
        return true;
    }

    function approve(address delegate, uint256 numTokens) public override returns (bool) {
        allowed[msg.sender][delegate] = numTokens;
        emit Approval(msg.sender, delegate, numTokens);
        return true;
    }

    function allowance(address owner, address delegate) public override view returns (uint) {
        return allowed[owner][delegate];
    }

    function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
        require(numTokens <= balances[owner]);
        require(numTokens <= allowed[owner][msg.sender]);

        balances[owner] = balances[owner].sub(numTokens);
        allowed[owner][msg.sender] = allowed[owner][msg.sender].sub(numTokens);
        balances[buyer] = balances[buyer].add(numTokens);
        emit Transfer(owner, buyer, numTokens);
        return true;
    }
}

library SafeMath {
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
      assert(b <= a);
      return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
      uint256 c = a + b;
      assert(c >= a);
      return c;
    }
}

We need to define two mapping objects. This is the Solidity notion for an associative or key/value array:

 mapping(address => uint256) balances;
 mapping(address => mapping (address => uint256)) allowed;

The expression mapping(address => uint256) defines an associative array whose keys are of type address. a number used to denote account addresses, and whose values are of type uint256. Balances mapping, will hold the token balance of each owner account.

The second mapping object, allowed, will include all of the accounts approved to withdraw from a given account together with the withdrawal sum allowed for each.

After that we set the total amount of tokens at constructor (which is a special function automatically called by Ethereum right after the contract is deployed) and assign all of them to the “contract owner” i.e. the account that deployed the smart contract:

uint256 totalSupply_;
constructor(uint256 total) public {
  totalSupply_ = total;
  balances[msg.sender] = totalSupply_;
}

Get Total Token Supply

This function will return the number of all tokens allocated by this contract regardless of owner.

function totalSupply() public view returns (uint256) {
  return totalSupply_;
}

Get Token Balance of Owner

balanceOf will return the current token balance of an account, identified by its owner’s address.

function balanceOf(address tokenOwner) public view returns (uint256) {
   return balances[tokenOwner];
}

Transfer Tokens to Another Account

The transfer function is used to move numTokens amount of tokens from the owner’s balance to that of another user, or receiver. The transferring owner is msg.sender i.e. the one executing the function.

function transfer(address receiver, uint256 numTokens) public returns (bool) {
    require(numTokens <= balances[msg.sender]);
    balances[msg.sender] = balances[msg.sender].sub(numTokens);
    balances[receiver] = balances[receiver].add(numTokens);
    emit Transfer(msg.sender, receiver, numTokens);
    return true;
}

Approve user to Withdraw Tokens

This function is most often used in a token marketplace scenario. What approve does is to allow an owner i.e. msg.sender to approve a delegate account to withdraw tokens from his account and to transfer them to other accounts.

function approve(address delegate, uint256 numTokens) public returns (bool) {
   allowed[msg.sender][delegate] = numTokens;
   emit Approval(msg.sender, delegate, numTokens);
   return true;
}

At the end of its execution, this function fires an Approval event.

Get Number of Tokens Approved for Withdrawal

This function returns the current approved number of tokens by an owner to a specific delegate, as set in the approve function.

function allowance(address owner, address delegate) public view returns (uint) {
   return allowed[owner][delegate];
}

Transfer Tokens by Delegate

The transferFrom function is the peer of the approve function. It allows a delegate approved for withdrawal to transfer owner funds to a third-party account.

function transferFrom(address owner, address buyer,
                     uint numTokens) public returns (bool) {
  require(numTokens <= balances[owner]);
  require(numTokens <= allowed[owner][msg.sender]);

  balances[owner] = balances[owner] — numTokens;
  allowed[owner][msg.sender] =
        allowed[from][msg.sender] — numTokens;
  balances[buyer] = balances[buyer] + numTokens;
  Transfer(owner, buyer, numTokens);
  return true;
}

SafeMath

We also used SafeMath Library for uint256 data type. SafeMath is a Solidity library aimed at dealing with one way hackers have been known to break contracts: integer overflow attack. In such an attack, the hacker forces the contract to use incorrect numeric values by passing parameters that will take the relevant integers past their maximal values.

Contract Deployment

Now Let's deploy our ERC20 Token to Ethereum Network. To Deploy Contract to Ethereum Network you will need to install the MetaMask plugin on your browser and a Ropsten (Ethereum test network) account with at least some Ropsten Ether in it.

Then, we will hop over to the second tab to the bottom called Compiler and click Compile.

After compiled successfully Then, we will hop over to the third tab to the bottom called DEPLOY & RUN TRANSACTIONS. Then change the environment to Injected Web3. Make sure to select the appropriate contract from options.

And then enter total supply in highlighted box which you want for this token and click on deploy. A MetaMask popup will appear asking us to confirm the transaction. After approve your contract will be deployed which you can see in bottom section Deployed Contracts.

That’s it! your token contract is now deployed on Ethereum’s Ropsten testnet!

Congratulations on successfully creating your very own token/coin on the Ethereum network! Read more about the ERC-20 standard here.