Ethereum Development Tools – How to Build Ethereum Projects in 2023

The Web3 tech stack has a lot to offer, and there are several Ethereum development tools developers can take advantage of when building Ethereum projects in 2023. Here are some of the most prominent Ethereum tools:

• MetaMask – The leading Web3 wallet enabling developers to cover on-chain transactions, execute Web3 authentication, store crypto assets, and more.
• Solidity – Solidity is a leading programming language for creating smart contracts.
• OpenZeppelin – Get verified smart contract templates.   
• Node Providers – Choose a reliable node provider and avoid running your own nodes.
• Web3 Data API – Fetch any on-chain data with short snippets of code. 
• Moralis Streams – Listen to smart contracts and wallet addresses and create webhooks for on-chain events.
• Remix IDE – Create, compile, deploy, and verify Ethereum smart contracts with your browser.
• Hardhat – An Ethereum and JavaScript-based development environment.
• Brownie – An Ethereum and Python-based development environment.
• Ethereum Testnets – Test your smart contracts and dapps (decentralized applications) on one of Ethereum testnets (e.g., the Sepolia testnet).
• Crypto Faucet – Get testnet ETH (e.g., Goerli ETH) to execute transactions on Ethereum testnets.
• Etherscan – Ethereum mainnet and testnets explorer.
• Ethereum Boilerplate – Clone the Ethereum boilerplate, finalize some prerequisites and run your first dapp. More on how to use this Ethereum tool further down in this article!

If you wish to create your own smart contracts and build killer dapps around them, you’ll need more or less all of the above-listed Ethereum development tools. However, if you wish to build dapps around existing smart contracts, MetaMask and a free Moralis account alone can get you to the finish line. With the Moralis Web3 API, you can implement blockchain-related backend features by copy-pasting short snippets of code, like the following two popular examples:

• Get NFTs by wallet:

const response = await Moralis.EvmApi.nft.getWalletNFTs({
    address,
    chain,
});

• Get native balance by wallet:

const response = await Moralis.EvmApi.balance.getNativeBalance({
    address,
    chain,
});

Overview

We will start this article by showing you how to build Ethereum projects. Of course, this is possible only when using some of the best Ethereum dev tools. That said, the ultimate shortcut lies in using the ultimate Ethereum boilerplate in combination with the power of Moralis, which is the best way to start your Ethereum dev journey. 

As you progress, you’ll probably want to explore smart contract development. As such, you need to expand your assortment of Ethereum tools. Fortunately, we will explore all the must-haves of the Ethereum tools as we move forward. In short, this article will help you start creating Ethereum projects by taking the path of least resistance. 

Now, whether you want to create dapps based on existing smart contracts or your own contract, you need to have an active Moralis account. So, make sure to create your free Moralis account and start BUIDLing!

How to Build Ethereum Projects Using Ethereum Tools

Building dapps based on existing smart contracts is by far the simplest solution. If you opt for the right tools and use your legacy dev skills combined with some Web3 basics, you can get to the finish line relatively quickly. That said, you essentially have two options to build Ethereum projects:

1. Use the ultimate Ethereum boilerplate.
2. Create dapps from scratch.   

Option 1: Using the Ultimate Ethereum Boilerplate to Build Dapps

When you choose to use Moralis and the Ethereum boilerplate as your go-to Ethereum development tools, you get to create dapps using the following four steps:

1. Clone the Ethereum boilerplate code
2. Obtain your Moralis Web3 API key and other environmental variables
3. Install the required dependencies
4. Run your dapp

By completing the above four steps, you get to create a neat-looking dapp that supports Web3 authentication and displays transfer history, NFTs, and ERC-20 tokens in a matter of minutes:

If you’d like to build such a dapp (as presented in the above demo) with minimum effort, you need to use the above “Ethereum boilerplate code” link and clone the code:

Then, create a new folder (e.g., “Boilerplate”) and open it in Visual Studio Code (VSC). Next, clone the above-copied code by using VSC’s terminal and the “git clone” command followed by the repo URL:

With the boilerplate in place, “cd” into the “ethereum-boilerplate” folder:

There, you’ll see the “.env.local.example” file. Open that file and populate it with your environmental variables as instructed in the file template. For instance, to get your Moralis Web3 API key, you’ll need to log in to your free Moralis account. Then, you’ll be able to obtain your API key from the Moralis admin area with two clicks:

With your environmental variables in place, rename your “.env.local.example” file to “.env.local”. 

Moving on, install all the required dependencies with “npm i” or “yarn” command. Finally, you can run your dapp with “npm run dev” or “yarn run dev” command. 

Option 2: Creating Dapps from Scratch

Of course, to build dapps the easy way, you don’t have to use the above-presented Ethereum boilerplate. Instead, you can use other Ethereum dev tools to create dapps from scratch. In that case, you’ll need to complete some standard steps:

1. Set up your backend dapp
2. Set up your frontend dapp
3. Obtain your Moralis Web3 API key
4. Copy-paste the Moralis EVM API endpoint and utilize other Ethereum tools
5. Add Web3 functionality and frontend styling

Note: A great example of the above-outlined steps is our tutorial on how to clone Zapper!

When it comes to creating your backend, the Moralis JS SDK and Python SDK (Python for Ethereum) are the most popular options. However, you can also use other leading programming languages to get the job done. On the other hand, JavaScript (ReactJS and NextJS) is still the king when it comes to creating the frontend for your dapps. As far as obtaining your Web3 API key goes, use the two-click process presented above. Then, you’ll be ready to start adding Web functionalities to your backend. This is where the Web3 documentation from Moralis streamlines things. Aside from guides and tutorials, the docs provide API reference pages where you can copy the necessary lines of code. For example, by using the Web3 Data API documentation, you can easily implement the two methods presented in the intro and many others. 

Essentially, you just need to access the relevant API endpoint reference page, select the programming language/framework you want to work with, and copy the code. Here’s an example of using NodeJS for the “getWalletNFTs” endpoint:

Beyond the Web3 Data API

Looking at the above screenshot, you can see the “Streams API” and “Authentication API” options in the top menu bar. The former enables you to listen to on-chain events, and the latter allows you to implement Web3 authentication effortlessly. When using these two Ethereum tools, the following snippets of code are the ones you’ll want to use:

Web3 Authentication API – Request EVM Challenge

• NodeJS:

const result = await Moralis.Auth.requestMessage(options);

• Python:

result = auth.challenge.request_challenge_evm(options)

Web3 Authentication API – Verify EVM Challenge

• NodeJS:

const verifiedData = Moralis.Auth.verify(options);

• Python:

result = auth.challenge.verify_challenge_evm(options)

Moralis Streams API – Create a Stream

• NodeJS:

const { result } = await Moralis.Streams.add(options);

• Python:

result = streams.evm.add_streams(options)

Plus, when it comes to working with Moralis Streams, you can use the Moralis SDK, as presented above, or use the Moralis admin UI:

The Moralis Streams API is the superior Notify API alternative and makes the leading Web3 libraries, such as ethers.js, obsolete in many ways. Consequently, before diving into ethers.js dapp development, do a proper ethers.js vs Web3 streams comparison. However, if you still prefer to use Web3 libraries, make sure to determine which one is the best for you by diving into the Web3.js vs ethers.js and Web3.py vs Web3.js comparisons.

With these Ethereum tools outlined, you can easily create all sorts of dapps around existing smart contracts. Now, if you decide to create your own smart contracts, you’ll need to reach for some other Ethereum development tools. Let’s take a closer look at some of those. 

Note: Even if you decide to start creating your own smart contracts, you’ll still want to use one of the above two options to create killer dapps that utilize your smart contracts.

Exploring Ethereum Dev Tools for 2023

The majority of Ethereum development tools and assisting tools that help create and utilize Ethereum smart contracts and dapps fall into one of the following categories:

• Node Providers – Thanks to node providers, you don’t need to run your own Ethereum nodes. This can save you a lot of time. After all, running a node is a full-time commitment. The leading node providers include Infura, Alchemy, QuickNode, Chainstack, GetBlock, Pocket Network, and RunNode.    
• Web3 API Providers – When it comes to building dapps, reliable Web3 APIs are the most important Web3 tools. With Web3 APIs, you can fetch various precompiled and precalculated on-chain data. The leading representatives of Web3 API providers include Moralis, The Graph, Covalent, QuickNode, Bitquery, Alchemy, and Biconomy.
• Smart Contracts Development Tools – These tools include programming languages, frameworks, IDEs, Web3 libraries, testnets, crypto faucets, etc. The leading examples of smart contract development tools include Solidity, Remix, Brownie, Hardhat, Truffle, OpenZeppelin, the Goerli testnet, the Sepolia testnet, a Goerli faucet, a gwei to ETH calculator, etc.
• Web3 Wallets – Crypto wallets enable you to send, receive, and store cryptocurrencies, do Web3 logins, confirm on-chain transactions, test dapps, and more. The leading Web3 wallets include MetaMask, Rainbow, Trust Wallet, Argent, and Coinbase Wallet.

• Blockchain Explorers – Dapps that enable you to explore on-chain data and even interact with smart contracts on a supported chain. For the Ethereum mainnet and its testnets, Etherscan serves that purpose.
• Web3 Computing Solutions – These “assisting” Ethereum dev tools come in the form of shared/decentralized storage protocols, blockchain oracles, IoT protocols, private computing protocols, and shared networks. Key representatives of Web3 computing solutions are Filecoin (shared storage), Chainlink (oracle), Helium (IoT), and IPFS.

Now that you know how to classify the Ethereum development tools listed in the introduction correctly, let’s look at the essential ones more closely.

MetaMask 

MetaMask is arguably the most popular and well-established cryptocurrency wallet. Its browser extension is particularly popular among dapp and smart contract developers. MetaMask enables you to connect to the Ethereum blockchain, which is this Web3 wallet’s default chain. However, you can manually add other EVM-compatible chains and use MetaMask as a cross-chain tool. 

With MetaMask, you can connect to Ethereum dapps, confirm on-chain transactions, store, send, and receive ETH, Goerli ETH, Sepolia ETH, ERC-20 tokens, ERC-1155 and ERC-721 NFTs, and other EVM-compatible crypto assets. If you wish to deploy a smart contract or test your dapp functionality, such as Web3 authentication or registering on-chain transactions, MetaMask is a must-have Ethereum tool.

Solidity 

Solidity is a high-level programming language that serves devs to create smart contracts that run on Ethereum or other EVM-compatible blockchains. It remains the leading choice among smart contract programming languages. From a command and conceptual point of view, Solidity has many similarities to JavaScript (JS). However, there are variations in the syntax. As the native language of Ethereum, Solidity has built-in commands that access a part of the blockchain (a timestamp, an address of a particular block, etc.). With these built-in functions, you can program Solidity smart contracts easily. 

Solidity is a contract-oriented language, which means its emphasis is on contracts and functions. Furthermore, Solidity is typed statically and supports libraries, inheritance, and other more complex user-defined features. This programming language compiles all the instructions into a sandbox of bytecode. As such, the instructions can be read and interpreted in the Ethereum network. So, if you are serious about Ethereum smart contract programming, make sure to add Solidity at the top of your “Web3 programming languages for 2023” list.

Remix IDE 

Remix IDE is an open-source development environment. It comes in the form of a web and desktop application and offers a rich set of plugins that help foster a fast development cycle via intuitive GUI. Remix IDE focuses on facilitating the entire process of smart contract development, including creating, compiling, deploying, and verifying. Since Remix IDE can be accessed with web browsers, it is arguably the simplest way to create smart contracts on Ethereum.

Ethereum Testnets 

Ethereum testnets are testing environments where devs test Ethereum updates and smart contracts before deploying them to the mainnet. They can come in the form of local testing environments; however, when talking about Ethereum testnets, we usually have public blockchains in mind. Among the latter, only Sepolia and Goerli are actively maintained. Other Ethereum testnets (Ropsten, Rinkeby, Kovan) have been deprecated. So, if you plan on deploying smart contracts to Ethereum, make sure to first test them on one of the active two testnets.

Ethereum Faucets

If you want to use public testnets, you will need testnet cryptocurrency to cover transaction fees (just like on the mainnet). The Ethereum development tools providing you with testnet ETH are known as Ethereum faucets. Moreover, most crypto faucets come in the form of web applications, where users enter their wallet addresses to receive a small amount of “test” coins.

If you want to test your smart contracts or dapps on the Sepolia testnet, you need to use a reliable Sepolia faucet. Also, if you want to focus on testing on the Goerli network, you must fetch Goerli ETH from a user-friendly Goerli faucet. Fortunately, you can find vetted faucets for Ethereum and other learning chains on the Moralis Pure Faucets page.  

Etherscan 

Etherscan is the official Ethereum blockchain explorer and deserves a spot among the essential Ethereum dev tools. As the screenshot indicates, Etherscan supports the Ethereum mainnet and its testnet. Furthermore, it is the place to look for any Ethereum address, transaction, token, smart contract, and more. Also, this is where you can find Ethereum addresses, smart contract codes, smart contract ABIs, etc. Once on a smart contract’s page, Etherscan even lets you interact with that smart contract via its “read” and “write” functions:

Ethereum Development Tools – How to Build Ethereum Projects in 2023 – Summary

Today’s article taught you everything you need to know about the Ethereum tools for building Ethereum projects. You found out that in order to create Ethereum dapps, you don’t need to create your own smart contract. Instead, you can focus on building dapps around existing smart contracts. This approach gives you two simple methods of building Ethereum projects:

1. Use the ultimate Ethereum boilerplate.
2. Create dapps from scratch.

You also found out that both of these options are as straightforward as it gets when using one of the best Ethereum development tools: Moralis. In addition, you even learned how to easily use the three main products from Moralis: the Web3 Data API, Moralis Streams API, and Authentication API. Nonetheless, you had a chance to take a closer look at other essential Ethereum dev tools when it comes to creating your own smart contracts. So, now you know that MetaMask, Solidity, Remix IDE, Ethereum testnets, Ethereum faucets, and Etherscan are six of the essential tools. 

If you are ready to use enterprise blockchain solutions from Moralis, create your free Moralis account and start building killer dapps! Also, for additional guidance, use our tutorials that await you in the Moralis documentation, on the Moralis YouTube channel, and on the Moralis blog. Moreover, by taking on example projects on those channels, you can learn Web3 programming in no time. Then you’ll be able to make the most out of the scalable Web3 infrastructure provided by Moralis. However, if you wish to explore the current blockchain tech stack in a more professional way, we encourage you to consider enrolling in Moralis Academy. There, you can become blockchain-certified by completing pro-grade development courses on all things blockchain. However, make sure to first get your blockchain and Bitcoin fundamentals straight.