Compiling, Deploying, Verifying, Testing Smart Contract Through Hardhat.

Linus — Fri, 18 Oct 2024 16:20:49 +0000

Hello, everybody.
If you’re a developer looking to deploy your first smart contract using Hardhat, this guide is for you. I’ll walk you through the process step-by-step, from setting up your project to deploying your contract on the Ethereum network.

Step 1: Project Setup
Create a new project directory:
mkdir smart-contract-guide

cd smart-contract-guide

Initialize a Node.js project and install Hardhat:

npm init -y 
npm install --save-dev hardhat

Step 2: Write the Smart Contract

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract BasicNft is ERC721 {
    string public constant TOKEN_URI =
        "ipfs://bafybeig37ioir76s7mg5oobetncojcm3c3hxasyd4rvid4jqhy4gkaheg4/?filename=0-PUG.json";
    uint256 private s_tokenCounter;

    constructor() ERC721("Dogie", "DOG") {
        s_tokenCounter = 0;
    }

    function mintNft() public returns (uint256) {
        _safeMint(msg.sender, s_tokenCounter);
        s_tokenCounter = s_tokenCounter + 1;
        return s_tokenCounter;
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        // require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
        return TOKEN_URI;
    }

    function getTokenCounter() public view returns (uint256) {
        return s_tokenCounter;
    }
}

Step 3: Deployment using ignition module.
Inside the ignition/module directory, create a file named BasicNft.ts:

import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";


const DeployMyTokenModule = buildModule("DeployMyTokenModule", (m) => {
  const myToken = m.contract("BasicNft");

  return { myToken };
});

export default DeployMyTokenModule;

Step 4: Configure Hardhat
Create a file named hardhat.config.js:

module.exports = {
  solidity: "0.8.0",
  networks: {
    // Define your networks here, such as "sepolia", "goerli", "mainnet", etc.
    // Example:
    // sepolia: {
    //   url: "<SEPOLIA_RPC_URL>",
    //   accounts: ["0xYOUR_PRIVATE_KEY"],
    // },
  },
};

Step 5: Test Your Contract
Step 6: Deploy Your Contract

npx hardhat ignition deploy ./ignition/modules/BasicNft.ts --network <networkname>

Congratulations! 🎉 You’ve completed the guide on deploying and interacting with a simple smart contract using Hardhat. This hands-on experience sets you on the path to exploring more complex contract functionality and advanced features.

Keep exploring the exciting world of Ethereum smart contracts and enjoy your coding journey! 💡🚀

Building a Microservices Application Using Spring Boot

Linus — Tue, 06 Aug 2024 19:00:03 +0000

Hello, Everyone. In this time I'd like explain cloud computing and containerization technologies continue to evolve, microservices architecture has become increasingly prominent. Organizations are now actively seeking professionals skilled in Microservices Architecture. This article will guide you through developing a microservices application for top sports brands using Spring Boot and Netflix Eureka Server.

The Need for Spring Boot

Spring Boot offers numerous benefits that facilitate the rapid development of production-ready applications:

Embedded Servers: Simplifies the deployment process within containers.
Component Monitoring: Enhances the monitoring of various application components.
External Configuration: Streamlines the external configuration of components.

Challenges in Microservices Architecture

Although microservices can simplify the development process, they introduce certain complexities:

Automation: The automation of builds, deployments, and monitoring for multiple small services can be intricate.
Visibility: Ensuring comprehensive visibility across numerous small components is essential for effective monitoring and problem identification.
Configuration Management: Maintaining consistent configurations across different environments is crucial.
Debugging: Centralized logging and dashboards are vital for simplifying error detection and debugging.
Consistency: Maintaining a consistent set of tools, languages, platforms, and technologies is important for effective decentralized governance.

Spring Boot Microservices: Developing a Top Sports Brands Architecture

In this example, we will create a Top Sports Brands application comprising three distinct services:

1. Eureka Service

Purpose: Manages the registration of each microservice and facilitates service discovery for client microservices.
Implementation: Utilizes Netflix Eureka and Spring Cloud for a declarative approach to service registration and invocation.

2. Item Catalog Service

Purpose: Provides a catalog of popular sports brands.
Dependencies: Includes Actuator, Eureka Discovery, JPA, H2, Rest Repositories, Web, DevTools, and Lombok.

3. Edge Service

Purpose: Serves as a gateway, offering fallback mechanisms to prevent HTTP errors during service unavailability.
Dependencies: Incorporates Eureka Discovery, Feign, Zuul, Rest Repositories, Web, Hystrix, and Lombok.

Essential Tools

Java 8
Eclipse IDE Oxygen
Spring Tool Suite

Service Creation Steps

Eureka Service

Setup: Initialize a new EurekaServer Spring Starter Project in Eclipse IDE.
Configuration: Add necessary dependencies and adjust properties to set the port and disable self-registration.
Startup: Launch the application and verify the Eureka Server at http://localhost:8761.

Item Catalog Service

Setup: Initialize a new project named item-catalog-service.
Dependencies: Add essential dependencies including Actuator, Eureka Discovery, JPA, H2, Rest Repositories, Web, DevTools, and Lombok.
Configuration: Specify the application name and port in the properties file.
Cloud Properties: Configure cloud properties for Eureka integration.
Startup: Launch the application and verify its registration with the Eureka Server.

Edge Service

Setup: Initialize a new project named edge-service.
Dependencies: Add dependencies such as Eureka Discovery, Feign, Zuul, Rest Repositories, Web, Hystrix, and Lombok.
Configuration: Set the application name and port in the properties file.
Cloud Properties: Configure cloud properties for Eureka integration.
Implementation: Develop DTOs, Feign clients, and controllers with fallback methods using Hystrix.
Startup: Launch the application and ensure successful service registration and functionality.

Conclusion

By following these detailed steps, you can establish a robust microservices architecture for a Top Sports Brands application using Spring Boot and Netflix Eureka Server. This architecture ensures scalability, resilience, and efficient monitoring, effectively addressing the common challenges associated with microservices development.

DEV Community: Linus