Intro

Welcome to Part 4 of our blockchain journey! In this installment, we'll be diving into the creation of our very own ERC-20 token called "Galactic Credit," using the powerful OpenZeppelin library. Representing the governance of our future blog series, the Galactic Credit token will showcase the seamless integration of the ERC-20 token standard, OpenZeppelin, and Remix IDE in the world of decentralized finance.

Together, we'll navigate the process of developing a custom token, exploring the various components and functionalities that make ERC-20 tokens the backbone of numerous blockchain projects. With a solid foundation in the basics of ERC-20, OpenZeppelin, and Remix IDE, we're all set to embark on this exciting adventure, bringing the Galactic Credit token to life. So, buckle up and join me as we continue our exploration into the fascinating realm of blockchain and token development!

Galactic Credit?

In the following section, we'll take a closer look at the creation of our custom ERC-20 token, "Galactic Credit," with the symbol "CREDIT." This Solidity code leverages the power of OpenZeppelin's smart contract library to inherit from the ERC20, ERC20Burnable, and Ownable contracts, ensuring our token adheres to the ERC-20 standard, has burnable capabilities, and is owned by the deployer of the contract. As we examine the constructor function, you'll see how the token is initialized with its name and symbol, while an initial supply of 100 tokens (multiplied by the token's decimals) is minted and assigned to the deployer's address.

Now, let's dive into the code:

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract BlockByBlock is ERC20, ERC20Burnable, Ownable {
    constructor() ERC20("Galactic Credit", "CREDIT") {
        _mint(msg.sender, 100 * 10 ** decimals());
    }

}

As we continue to explore the process of deploying a contract, it's essential to understand its key components. This will not only help you gain a deeper understanding of the steps involved but also enable you to create and deploy your own contracts confidently.

Part 1: Writing the Code

The first component involves writing the code for the smart contract in a .sol file. This file contains the Solidity code that defines your contract's structure, logic, and functionalities. In our case, we wrote the code for the Galactic Credit token, utilizing the OpenZeppelin library to inherit from the ERC20, ERC20Burnable, and Ownable contracts.

Part 2: Compiling the Code

Once the code is written, the next step is to compile it. This process converts the human-readable Solidity code into machine-readable bytecode that can be executed on the Ethereum Virtual Machine (EVM). Compiling the code also generates an Application Binary Interface (ABI), which is a JSON representation of the contract's functions and events, allowing users and other contracts to interact with it.

Connecting MetaMask: Before deploying the contract, you'll need to connect your MetaMask wallet to the development environment. MetaMask is a browser extension that allows you to manage your Ethereum accounts and interact with smart contracts easily.

Part 3: Deploying the Contract

Now that we have written and compiled our Galactic Credit token contract, it's time to deploy it to the Ethereum Mainnet. In this part of our blockchain journey, we'll walk through the process of deploying the smart contract, ensuring that our token is live and ready for interaction.

1. Preparing for Deployment: Before we proceed with deployment, double-check that the contract code is compiled and that you have connected your MetaMask wallet to the development environment. Ensure that your wallet contains enough Ether to cover the gas fees associated with deploying the contract.

2. Selecting the Network: In your development environment (e.g., Remix IDE), choose the appropriate network for deployment. In our case, we'll be deploying to the Ethereum Mainnet. However, you can also deploy to various test networks (e.g., Ropsten, Rinkeby, Goerli) for testing purposes.

3. Deploying the Contract: In the "Deploy & Run Transactions" panel, select the compiled contract from the dropdown menu (MyToken in our case) and click the "Deploy" button. MetaMask will prompt you to confirm the transaction, displaying the associated gas fees. Review the transaction details and confirm the deployment.

4. Confirming transaction receipt or looking up the contract address on an Ethereum block explorer (e.g., Etherscan). Your newly deployed Galactic Credit token contract should now be visible, and you can start interacting with its functions.

   Congratulations! You have now successfully deployed your custom ERC-20 token, Galactic Credit, to the Ethereum Mainnet. This marks an important milestone in our blockchain journey, as we have brought our token to life and made it accessible for users to interact with.

Live Contract:

Ending

And there you have it! We have successfully minted 100 Galactic Credit tokens and deployed the contract on the Ethereum Mainnet, marking the completion of Part 1 of our thrilling blockchain journey. I hope this adventure has provided valuable insights and piqued your interest in the world of ERC-20 tokens and their potential applications. As we move forward in our series, we'll continue to explore new aspects of blockchain development and expand our knowledge together.

In the meantime, if you'd like to get your hands on some freshly minted Galactic Credits from the Mainnet, feel free to drop me a message! Who knows, perhaps one day these tokens will play a crucial role in the governance of our blog series. Until then, keep learning, experimenting, and embracing the endless possibilities that the world of blockchain has to offer!