Chapter 3: Writing and Compiling Solidity Smart Contracts using Hardhat

It is foundational for smart contract development. It covers writing basic Solidity contracts, using state variables, functions, and modifiers. Hardhat is introduced for compiling contracts and managing artifacts (ABI and bytecode). The chapter likely touches on project setup, compilation, and possibly deployment basics. Artifact management is crucial for contract interaction. A FAQ section clarifies key concepts like view vs. pure functions and the constructor. Practice is key; this chapter provides the base for building more complex dApps.

1. Creating a Solidity Smart Contract

• Structure: A Solidity settlement typically starts with a pragma statement specifying the Solidity compiler version. Then, you outline the settlement the use of the contract key-word, accompanied via the contract name and curly braces {} enclosing the contract’s code.

Solidity

pragma solidity ^0.8.0; // Specify compiler version

contract MyContract {
    // State variables (data stored in the contract)
    uint public myVariable;

    // Functions (logic of the contract)
    function myFunction(uint x) public {
        myVariable = x;
    }
}

• State Variables: These are variables that hold the contract’s data. Common types include uint (unsigned integer), string, address, bool, mapping, and arrays. The public, private, internal, and external keywords control their visibility.
• Functions: Functions define the contract’s behavior. They can modify state variables, interact with other contracts, or perform calculations. Function visibility (public, non-public, internal, external) is vital. Modifiers like `view ` (for study-only functions) and `pure ` (for features that don’t read or write state) may be used.
• Example (Simple Token):

Solidity

pragma solidity ^0.8.0;

contract MyToken {
    string public name = "MyToken";
    string public symbol = "MYT";
    uint public totalSupply = 1000000;
    mapping(address => uint) public balanceOf;

    constructor() {
        balanceOf[msg.sender] = totalSupply; // Give initial supply to the contract creator
    }

    function transfer(address recipient, uint amount) public {
        require(balanceOf[msg.sender] >= amount, "Insufficient balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[recipient] += amount;
    }
}

2. Compiling with Hardhat

Hardhat is a popular development surroundings for Ethereum smart contracts. Here’s a normal workflow:

1. Installation: npm install --save-dev hardhat
2. Project Setup: npx hardhat (Follow the prompts to create a basic project).
3. Writing Contracts: Place your Solidity contracts in the contracts directory.
4. Compilation: Use the command npx hardhat collect. Hardhat will collect your contracts and generate artifacts (JSON files containing the contract’s ABI and bytecode) in the artifacts listing.
5. Configuration (hardhat.Config.Js): This file permits you to personalize Hardhat’s conduct, along with specifying the Solidity compiler version, community configurations, and different settings.

JavaScript

require("@nomiclabs/hardhat-ethers");

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.0", // Specify the Solidity compiler version
  networks: {
    hardhat: { // Default Hardhat network
    },
    // Example: Configuring a Goerli test network (you'll need to add your Infura/Alchemy API key)
    goerli: {
      url: "YOUR_GOERLI_RPC_URL", // e.g., "https://goerli.infura.io/v3/YOUR_INFURA_PROJECT_ID"
      accounts: ["YOUR_PRIVATE_KEY"], // Be VERY careful with private keys! Use environment variables.
    },
  },
};

3. Managing Artifacts:

• ABI (Application Binary Interface): The ABI is a JSON representation of your contract’s interface. It’s essential for interacting with your contract from other contracts or client-side applications (e.g., using JavaScript libraries like ethers.js).
• Bytecode: The bytecode is the compiled contract code, which is what receives deployed to the Ethereum community.

Hardhat places these artifacts in the artifacts directory after compilation. You’ll typically use these files when deploying and interacting with your contract.

4. FAQ:

• Q: What is the difference between view and pure functions?
  • view: A view function can read the contract’s state but cannot modify it.
  • pure: A pure function does not read or modify the contract’s state. It only uses its input parameters to calculate a return value.
• Q: How do I deploy a contract to a test network (like Goerli)?
  • You’ll need to configure your hardhat.config.js with the network details (URL and accounts). Then, you can use a deployment script (often written using ethers.js) to deploy the contract. Hardhat provides helpful tools for this.
• Q: What are modifiers in Solidity?
  • Modifiers are a way to reuse code and add conditions to functions. For example, you can create a modifier that checks if a user is the contract owner before allowing them to execute a function.
• Q: How do I interact with a deployed contract?
  • You’ll need the contract’s address and ABI. Libraries like ethers.js can be used to create a contract instance and call its functions from your JavaScript code.
• Q: What is the motive of the constructor?
  • The constructor is a special feature this is achieved simplest as soon as when the contract is deployed. It’s used to initialize the settlement’s state variables.