Hardhat 또는 Truffle 설정

Remix is fantastic for quick tests and learning Solidity basics. However, for building real-world smart contract projects, you need more robust tools.

Development frameworks like Hardhat and Truffle provide a professional environment for managing your entire project lifecycle. They streamline tasks like:

• Automated testing of your contracts
• Managing deployments to different networks
• Running a fast, local blockchain for development
• Organizing complex project structures

They make development faster, more efficient, and more reliable.

Hardhat and Truffle are the two most popular development frameworks in the Ethereum ecosystem.

• Hardhat: A modern, flexible framework built specifically for Ethereum. It's known for its speed, extensive plugin system, and excellent developer experience.
• Truffle: An older, more established framework with a broader ecosystem. It supports various EVM-compatible chains and has a large community.

Both are powerful tools. For this lesson, we'll primarily focus on setting up Hardhat due to its growing popularity and developer-centric design.

Before we install a framework, you'll need two essential tools on your computer:

• Node.js: A JavaScript runtime environment.
• npm (Node Package Manager): Comes bundled with Node.js, used for installing software packages.

These are crucial for managing project dependencies and running development tools. You can check if they're installed by typing node -v and npm -v in your terminal.

If you don't have them, download and install Node.js from the official Node.js website.

Let's get Hardhat installed! First, create a new empty directory for your project and navigate into it using your terminal. Then, install Hardhat as a development dependency.

Installing it this way ensures each project can use its own specific Hardhat version, avoiding conflicts between projects.

Once Hardhat is installed locally, you can initialize a new project. This command will prompt you with a few options to set up a basic project structure.

Choosing 'Create a basic sample project' is a great way to start. It generates a sample contract, test file, deployment script, and the crucial hardhat.config.js file.

The hardhat.config.js file is the central configuration hub for your entire Hardhat project. It's written in JavaScript and allows you to define:

• The Solidity compiler version to use (e.g., 0.8.19)
• Custom networks for deployment (like testnets or mainnet)
• Plugins you want to use (e.g., for Ethers.js, Waffle)
• Custom tasks to extend Hardhat's functionality

Here's what a minimal hardhat.config.js might look like:

One of Hardhat's most powerful features is its built-in Hardhat Network.

This is a local Ethereum network designed specifically for development and testing. It's incredibly fast, isolated, and automatically resets on each run, providing a clean slate every time you test your contracts.

You don't need to run a separate local blockchain client (like Ganache) when using Hardhat; it's all integrated, making your development workflow seamless and efficient!

While we're focusing on Hardhat, it's good to know how to set up Truffle, as it's also widely used. The process is similar to Hardhat:

1. Install Truffle globally using npm.
2. Create a new directory for your project.
3. Initialize a new Truffle project within that directory.

Truffle often works hand-in-hand with Ganache, a personal Ethereum blockchain for local development, which you would typically run separately.

A Truffle project also follows a logical structure to organize your smart contract development:

• contracts/: This is where all your Solidity source code files (.sol) live.
• migrations/: Contains JavaScript files that help you deploy your contracts to the blockchain.
• test/: Your JavaScript and Solidity test files for verifying contract logic.
• truffle-config.js: The main configuration file for your Truffle project.

Understanding these standard project layouts helps you navigate and manage your smart contract projects effectively.

Let's check your understanding of development frameworks for smart contracts.

Congratulations! In this lesson, you've taken the first big step into professional smart contract development.

We learned why frameworks like Hardhat and Truffle are essential, how to set up a new Hardhat project, and understood the importance of the hardhat.config.js file.

You also got a glimpse of Hardhat's powerful built-in local network and an optional overview of Truffle setup. A solid development environment is your foundation for building robust and reliable smart contracts!