DEV Community: EHO Koku Hermann

Working with AI review is very important

EHO Koku Hermann — Sun, 19 Apr 2026 09:21:11 +0000

I started working with AI recently, and I have to say that it is a very powerful tool. It can help you with a lot of things, from writing code to generating content. However, how can you be sure that the content generated by AI is accurate and relevant? And when we add automation to our AI workflow, where AI can automatically write a full feature, here is where the review process becomes crucial. In this article, I will share my experience with working with AI and how I ensure that the content generated is of high quality.

With AI automation capabilities, i start asiging issues to AI, or asking hime to write a full feature.
But a full feature written by AI, need to be reviewed and tested by a human, to ensure that the code is of high quality, and that it meets the requirements of the project.

I teat the user as another Team Member. A Developper in my team that i ask to write a feature. And when you ask a developper to write a feature, you expect him to write a high quality code, and when he release the code, you expect it to be tested and reviewed by other members of the team. The same thing applies to AI, when you ask it to write a feature, you expect it to write a high quality code, and when it release the code, you expect it to be tested and reviewed by other members of the team.

This is the process.

I ask AI to write a feature, and I give it the requirements of the project.
AI writes the code, and releases it.
I review the code, and test it to ensure that it meets the requirements of the project, and that it is of high quality.
If the code is not of high quality, I ask AI to rewrite it, and I repeat the process until the code is of high quality.
Once the code is of high quality, I merge it to the main branch, and I deploy it to production.

In this case AI becomes a Team Member, and it is important to treat it as such, and to ensure that the code it generates is of high quality, and that it meets the requirements of the project. This is why the review process is crucial when working with AI, and it is important to ensure that the code generated by AI is of high quality, and that it meets the requirements of the project.

I said the review process is crucial when working with AI, but also it is important even when you are not working with AI, it is important to review the code of your team members, to ensure that the code is of high quality, and that it meets the requirements of the project. The review process is a crucial part of the software development process, and it is important to ensure that the code generated by your team members is of high quality, and that it meets the requirements of the project.

What is Unichain? A Deep Dive into Uniswap’s Layer 2 Blockchain

EHO Koku Hermann — Wed, 12 Feb 2025 11:54:03 +0000

What is Unichain? A Deep Dive into Uniswap’s Layer 2 Blockchain

Introduction

As the blockchain ecosystem evolves, scalability and transaction costs remain critical challenges, especially in the decentralized finance (DeFi) space. To address these issues, Uniswap Labs has introduced Unichain, a Layer 2 (L2) blockchain designed to enhance DeFi applications by reducing fees and improving transaction speeds. Built on the OP Stack framework, Unichain operates as an optimistic rollup, processing transactions off-chain before finalizing them on the Ethereum mainnet. This architecture significantly lowers costs and increases efficiency, making Uniswap's ecosystem more accessible and scalable.

How Unichain Works

Unichain is designed as a Layer 2 solution to alleviate congestion on Ethereum by executing transactions on a secondary network before settling them on the mainnet. Its key features include:

Optimistic Rollup Technology: Unichain batches multiple transactions off-chain and submits them as a single transaction on Ethereum, reducing gas fees by up to 95%.
Fast Block Times: Initially set at one second per block, Unichain plans to further reduce block times to 250 milliseconds, ensuring near-instant transactions.
Native Interoperability: As part of the Optimism Superchain, Unichain seamlessly integrates with other rollups, facilitating cross-chain liquidity and token transfers.
Decentralized Validation: Unichain introduces a decentralized validation network, allowing nodes to verify transactions and improve finality, reducing risks of reorgs or invalid blocks.
Enhanced Security Measures: It employs verifiable block building through a trusted execution environment (TEE) to ensure fair transaction ordering and prevent failed trades.

The Role of Unichain in DeFi

Unichain aims to become a liquidity hub, ensuring efficient swaps and trading across multiple blockchain networks. By reducing transaction fees and improving execution speed, it makes decentralized trading more accessible to users worldwide. It also supports developers by providing a scalable infrastructure for DeFi applications, including decentralized exchanges (DEXs), lending protocols, and yield farming platforms.

Current Development and Future Plans

Unichain is currently in its testnet phase, allowing developers and users to explore its functionalities before the mainnet launch. Uniswap Labs is actively gathering feedback to refine the network and optimize its performance. Future developments may include further security enhancements, governance mechanisms, and deeper integrations with Ethereum and other blockchain ecosystems.

Conclusion

Unichain represents a significant step forward for DeFi, offering a more efficient and cost-effective way to trade, provide liquidity, and build decentralized applications. With its innovative technology and commitment to scalability, Unichain has the potential to redefine how users interact with DeFi platforms, making financial services more inclusive and accessible for everyone.

As Unichain continues to develop, it will play a crucial role in shaping the future of decentralized finance, bridging liquidity across chains, and ensuring seamless transactions for users and developers alike.

Mastering Docker Image Optimization: Best Practices and Techniques

EHO Koku Hermann — Mon, 20 Nov 2023 14:48:02 +0000

In the realm of modern software development, Docker has emerged as a game-changer, revolutionizing how applications are built, shipped, and deployed. At the heart of this containerization technology lies Docker images, the building blocks of containerized applications. Optimizing these images is crucial for efficient deployment, improved performance, enhanced security, and streamlined maintenance.

A- Understanding Docker Image Optimization

Docker images encapsulate everything needed to run an application - the code, runtime, system tools, libraries, and settings - in a portable, immutable package. Optimizing these images involves crafting them in a way that maximizes efficiency without compromising functionality.

B- Advantages of Optimizing Docker Images

Optimizing Docker images offers a myriad of benefits:

Reduced Image Size: Smaller images consume less disk space, transfer faster, and enable quicker container startup times.
Improved Performance: Faster deployment, scaling, and overall enhanced application performance due to optimized resource utilization.
Enhanced Security: Minimized attack surfaces and reduced vulnerabilities by removing unnecessary components and regularly updating dependencies.
Easier Maintenance: Simplified debugging, updating, and management tasks due to leaner and more manageable images.

C- Best Practices for Optimizing Docker Images

1- Use of Official Base Images

Starting with trusted, official base images from repositories like Docker Hub ensures reliability and security from the get-go.

2- Multi-Stage Builds

Leverage multi-stage builds to reduce the number of layers and discard unnecessary dependencies, resulting in smaller final images.

3- Reducing Layers

Consolidate related commands in Dockerfiles to minimize the number of layers, enhancing efficiency and optimizing caching mechanisms.

4- Optimizing Package Installation

Use package managers' clean or autoremove commands to remove unnecessary dependencies after installation, reducing image size.

5- Utilizing .dockerignore

Create a .dockerignore file to exclude unnecessary files and directories from the build context, further reducing image size.

6- Choosing the Right Base Image

Select base images that align with your application's specific needs, such as using Alpine Linux for smaller image sizes.

7- Optimizing Image Layers

Order commands in the Dockerfile strategically to maximize caching and minimize the rebuilding of unchanged layers.

8- Compressing and Minimizing Files

Utilize compression tools to minimize file sizes within the image, reducing overall image footprint.

9- Implementing Runtime Optimizations

Configure application settings within containers to optimize resource usage and improve overall performance.

10- Regularly Updating Images

Frequently update base images and dependencies to incorporate security patches and new features, maintaining security and efficiency.

D- Conclusion

Optimizing Docker images is not just a technical endeavor; it's a strategic move toward building more efficient, secure, and scalable applications. By implementing these best practices and techniques, developers and DevOps teams can unlock the full potential of Docker containerization, paving the way for faster deployments, enhanced security, and improved performance in the ever-evolving landscape of software development.

This comprehensive guide aims to equip developers and DevOps professionals with the knowledge and strategies needed to optimize Docker images effectively, enabling them to harness the full power of containerization in modern software development.

How to Set up automatic builds and deploys with GitHub on an existing frontend APP on firebase hosting.

EHO Koku Hermann — Sun, 12 Nov 2023 14:10:04 +0000

A wordy heading. Yes i know. But we must recognize that this makes it specific to our situation.

So in my last article we talk about How to deploy your frontend APP on firebase hosting..

Now let see how we can set up automatic build and deploy with github.

1- Set up the GitHub Action to deploy to Firebase Hosting

1.1- Github Repo

Fork this repo

git clone https://github.com/hermannleboss/vue-typescript.git

Then checkout branch feature/github

I assume you have already followed the step to enable Firebase hosting on this repository. If not follow this :How to deploy your frontend APP on firebase hosting..

Or you can just create a GitHub repository (public or private) or use an existing one. You must have admin permissions for the repository.

1.2- Set up the GitHub Action part of Hosting

Now let dig deeper.

If you've NOT set up Hosting, run this version of the command from the root of your local directory:

firebase init hosting

If you've ALREADY set up Hosting, then you just need to set up the GitHub Action part of Hosting. Run this version of the command from the root of your local directory:

firebase init hosting:github

Follow the CLI prompts, and the command will automatically take care of setting up the GitHub Action:

Creates a service account in your Firebase project with permission to deploy to Firebase Hosting.
Encrypts that service account's JSON key and uploads it to the specified GitHub repository as a GitHub secret.
Writes GitHub workflow yaml configuration files that reference the newly created secret. These files configure the GitHub Action to deploy to Firebase Hosting.

Setup the repo with the format user/repository : here hermannleboss/vue-typescript

You will have two files inside .github/workflows/

#.github/workflows/firebase-hosting-merge.yml
# This file was auto-generated by the Firebase CLI
# https://github.com/firebase/firebase-tools

name: Deploy to Firebase Hosting on merge
'on':
  push:
    branches:
      - main
jobs:
  build_and_deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - run: npm install && npm run build
      - uses: FirebaseExtended/action-hosting-deploy@v0
        with:
          repoToken: '${{ secrets.GITHUB_TOKEN }}'
          firebaseServiceAccount: '${{ secrets.FIREBASE_SERVICE_ACCOUNT_XXXX }}'
          channelId: live
          projectId: xxxxxx

Make sure you have line 14

- run: npm install && npm run build

Now commit your update then push it.
Now you can create your branch add your commits the create a Pull Request

PS: If you some build error on deploy check that your workflow can edit your repository.

Set it to read and write

How to deploy your frontend APP on firebase hosting.

EHO Koku Hermann — Sat, 11 Nov 2023 14:34:10 +0000

When you build your beatifull app you need to show it to your friends.

In the dynamic landscape of web development, showcasing your masterpiece to the world involves more than just crafting impeccable code—it requires a reliable and efficient hosting solution. Firebase Hosting emerges as a beacon in this realm, offering developers a seamless platform to deploy their frontend applications with ease. In this guide, we'll embark on a journey to demystify the process and explore the steps to deploy your frontend app on Firebase Hosting. Whether you're a seasoned developer or a coding enthusiast, buckle up as we unravel the secrets to unleashing your web creation upon the digital stage.

What is Firebase hosting

Firebase Hosting is like the VIP lounge for your web applications—it provides a first-class ticket to the online world with its secure, fast, and globally distributed hosting service. Developed by Google as part of the Firebase suite, Hosting allows you to deploy your web content effortlessly, turning your code into a polished and accessible experience for users worldwide.

At its core, Firebase Hosting simplifies the deployment process, sparing developers from the complexities of server management. Instead of grappling with server configurations and infrastructure intricacies, you can focus on perfecting your frontend code. The hosting service leverages a Content Delivery Network (CDN) to ensure that your application is delivered swiftly to users, irrespective of their geographical location.

In essence, Firebase Hosting is your backstage pass to a hassle-free deployment experience, allowing you to shine on the digital stage without breaking a sweat.

How to deploy on it ?

Init the project

Clone this repo
git clone https://github.com/hermannleboss/vue-typescript.git
This is a VueJs Project
To run it in local : npm run dev
For build: npm run build
Build create files inside /dist folder.
Create A Firebase Project
- Install firebase CLI with npm npm install -g firebase-tools
- Connect to firebase firebase login
- Init the firebase hosting firebase init hosting

Before we get started, keep in mind:

  * You are currently outside your home directory
  * You are initializing within an existing Firebase project directory

? Are you ready to proceed? (Y/n)

Create a new project if you don’t have an existing one, or select your project.

? Please select an option: (Use arrow keys)
> Use an existing project
  Create a new project
  Add Firebase to an existing Google Cloud Platform project
  Don't set up a default project

Type you build directory : here dist

? What do you want to use as your public directory? dist
? Configure as a single-page app (rewrite all urls to /index.html)? Yes
? Set up automatic builds and deploys with GitHub? No
? File dist/index.html already exists. Overwrite? No

Now you will have two files

firebase.json and .firebaserc that contain firebase config

//firebase.json
{
  "hosting": {
    "public": "dist",
    "ignore": [
      "firebase.json",
      "**/.*",
      "**/node_modules/**"
    ],
    "rewrites": [
      {
        "source": "**",
        "destination": "/index.html"
      }
    ]
  }
}

You can edit the firebase.json file to do the same thing as the CMD.

Deploy Your App:

Before deployment, build the project with:

npm run build

Then deploy to firbase

firebase deploy

ou'll receive a Hosting URL to view your freshly deployed website.

Now, your frontend marvel is live on Firebase Hosting, ready to dazzle audiences worldwide! Keep refining your craft, and happy coding!

Test Isolation: Ensuring Reliable and Robust Code Testing

EHO Koku Hermann — Sat, 12 Aug 2023 07:08:34 +0000

In the realm of software development, testing plays a pivotal role in ensuring that code performs as expected, providing confidence in its functionality and reliability. One of the fundamental principles that contribute to effective testing is test isolation. Test isolation refers to the practice of designing tests that are independent of each other, ensuring that the outcome of one test does not impact the results of another. This approach is crucial for maintaining a stable and robust testing process, ultimately leading to higher quality software.

The Importance of Test Isolation

Imagine a scenario where tests are tightly coupled or interdependent. If one test fails, it could set off a chain reaction, causing multiple other tests to fail as well. This not only makes it challenging to identify the root cause of the issue but also undermines the reliability of the entire testing suite. Test isolation addresses this challenge by emphasizing the creation of independent test cases, each focusing on a specific behavior or functionality.

Test isolation provides several key benefits:

**Enhanced Debugging: **Isolated tests simplify the debugging process. When a test fails, developers can confidently focus on the specific test case, its inputs, and expected outputs, without being distracted by failures caused by other tests.
Accurate Issue Localization: With isolated tests, pinpointing the exact source of a problem becomes more straightforward. If a test fails, it's likely due to the code being tested, rather than cascading failures from other tests.
Flexibility in Execution Order: Independent tests can be executed in any order. This flexibility allows for parallel test execution, speeding up the testing process and enabling better resource utilization.
Confident Refactoring: When making changes to the codebase, isolated tests instill confidence that the changes won't inadvertently break unrelated parts of the application. This encourages refactoring and code improvement.
Clear Documentation: Isolated tests inherently provide clearer documentation of the software's behavior. Each test case acts as an example of how the code should function under specific conditions.

Strategies for Achieving Test Isolation

Achieving test isolation requires careful consideration and implementation. Here are strategies to ensure effective test isolation:

Unit Tests: Embrace the practice of unit testing, where individual components or functions are tested in isolation. This ensures that the behavior of each component is well-understood and isolated from other parts of the system.
Mocking and Stubs: For unit tests that interact with external dependencies like APIs, databases, or services, use mocking or stubbing frameworks to create simulated versions of these dependencies. This prevents external factors from affecting the test outcomes.
Shared Fixtures: In situations where tests share setup or teardown logic, ensure that each test's setup does not depend on the state or output of previous tests. Use fresh, isolated fixtures for each test.
Test Parameters: Tailor test inputs to cover a range of scenarios, including edge cases and boundary conditions. This ensures that tests are comprehensive and that they uncover potential issues.
Test Data Management: Manage test data separately from production data. This prevents test data modifications from inadvertently affecting other tests or the production environment.
Continuous Integration: Integrate tests into a continuous integration (CI) pipeline to automatically run tests whenever code changes are made. This ensures that the tests are consistently executed in a controlled environment.

Conclusion

Test isolation is a cornerstone of effective software testing. By designing tests that are independent of each other, developers can achieve higher confidence in the functionality and reliability of their code. Isolated tests simplify debugging, enhance issue localization, and provide the flexibility to execute tests in parallel. Implementing strategies such as unit testing, mocking, and careful management of test data contributes to a robust and reliable testing process. Ultimately, test isolation empowers development teams to deliver high-quality software that meets user expectations and withstands the challenges of a dynamic software landscape.

Embark on an Exciting Journey with VueForge: Unleash the Power of Vue.js!

EHO Koku Hermann — Thu, 27 Jul 2023 22:11:46 +0000

Hey there, fellow developers and Vue.js enthusiasts! Have you heard about VueForge? If not, you're in for an absolute treat! VueForge is an incredible, hands-on event coming up on August 2-3, 2023, and trust me, you won't want to miss it!

So, what is VueForge all about? It's an immersive event that brings together the entire Vue.js community to collaborate on building something truly groundbreaking – a SaaS Project Management App! You, me, and a bunch of passionate developers, side by side, working together to craft an app that will change the game! How amazing does that sound?

Now, I know what you might be thinking: "But, I'm not a Vue.js expert." Fear not, my friend! Whether you're a seasoned Vue.js pro or just starting your journey with this fantastic framework, VueForge welcomes everyone with open arms. It's a judgment-free zone where we learn, create, and grow together.

Here's a sneak peek into what awaits you at VueForge Episode 4:

The Marvelous Technologies: We'll be diving headfirst into some cutting-edge technologies, and it's going to be a blast! You'll get hands-on experience with Kadena, a powerful blockchain network, to develop a crowd-funding app using Vue.js. Oh, and don't worry if you're new to blockchain – we'll guide you through all the Web 3 aspects, making it super accessible!

We'll also be wielding the prowess of Nuxt 3, an open-source framework that'll help us build type-safe, performant, and mind-blowing web applications and websites with Vue.js. Exciting, right?

A Toolbox of Awesomeness: At VueForge, we'll equip you with some incredible tools to conquer the app development realm! You'll get to play around with TypeScript, which will supercharge your JavaScript skills, giving you better tooling for your projects. And let's not forget Tailwind CSS and daisyUI – the dynamic duo that'll make styling the app an absolute breeze!

But wait, there's more! We'll be utilizing the Composition API to build Vue components like never before. Plus, Vite will revolutionize your front-end tooling game, making things faster and smoother. And the cherry on top? VueUse, a treasure trove of essential Vue Composition Utilities – a developer's dream come true!

Why Should You Join? Ah, now comes the most exciting part – why you should be a part of this epic event! For starters, you'll have the golden opportunity to learn from some of the brightest minds in the Vue.js community. They'll share their expertise, tips, and tricks, propelling you to new heights as a developer!

And that's not all – VueForge is all about collaboration! You'll be teaming up with other talented developers, brainstorming ideas, and collectively creating the SaaS Project Management App of your dreams. Talk about a power-packed experience!

Did I mention we're all about open-source love? By participating in VueForge, you'll contribute to open-source projects, leaving your mark on the global Vue.js community – how cool is that?

Plus, brace yourself for live coding sessions with our amazing event speakers! You can keep up with the action in real-time through the official project repository on GitHub. It's like having a front-row seat to an exhilarating coding adventure!

So, what are you waiting for? VueForge is calling your name! Don't miss out on this incredible opportunity to learn, connect, and make a difference. Head over to the official website, register, and secure your spot in this unforgettable event.

Gather your Vue.js passion and join us at VueForge – together, we'll forge a future filled with boundless possibilities! See you there! 🚀

Why You Should Support Open Source Projects with Donations

EHO Koku Hermann — Mon, 17 Apr 2023 08:22:49 +0000

If you are a user or a developer of open-source software, you might have wondered why some projects ask for donations. After all, isn't open source software supposed to be free? Well, yes and no. Free as in freedom, not as in free beer. In this article, I will explain why supporting the open source project by making donations is important, and how you can do it.

First of all, what is open source software? Open source software is software that has its source code available for anyone to inspect, modify, and distribute. This means that you can use the software for any purpose, study how it works, improve it, and share it with others. Open source software is often developed collaboratively by volunteers or organizations who share a common vision or goal.

However, developing and maintaining open source software is not easy or cheap. It requires a lot of time, effort, skills, and resources. Think about all the things that go into making a software project successful: coding, testing, debugging, documenting, hosting, distributing, updating, supporting, etc. All these tasks require money to pay for things like servers, bandwidth, licenses, tools, hardware, etc. And of course, the developers themselves need to make a living and cover their expenses.

This is where donations come in. Donations are voluntary contributions that users or supporters of an open source project make to show their appreciation and gratitude for the work done by the developers. Donations can be monetary or non-monetary. Monetary donations can be made through platforms like PayPal, Patreon, Open Collective, GitHub Sponsors, etc. Non-monetary donations can be things like code contributions, bug reports, feedback, reviews, translations, documentation, promotion, etc.

Donations are important for several reasons. First of all, they help cover the costs of running and developing the project. This ensures that the project can continue to exist and grow without compromising its quality or functionality. Secondly, they motivate and reward the developers for their hard work and dedication. This helps them feel valued and appreciated by the community and encourages them to keep improving the project. Thirdly, they create a sense of ownership and responsibility among the users and supporters of the project. This fosters a positive and collaborative culture where everyone contributes to the common good.

So how can you support the open source project by making donations? The answer depends on the project itself. Different projects have different ways of accepting and managing donations. Some projects have a dedicated website or page where you can find information on how to donate. Some projects have badges or buttons on their GitHub repositories or other platforms where you can click and donate. Some projects have sponsors or partners who match or multiply your donations. Some projects have tiers or rewards for different levels of donations.

The best way to find out how to donate to an open source project is to visit its official website or repository and look for any links or instructions on how to do so. You can also contact the developers directly and ask them how you can help. You can also search online for platforms or organizations that support open source projects and see if your favorite project is listed there.

Donating to an open source project is not only a generous act but also a smart investment. By donating to an open source project, you are supporting its development and maintenance, ensuring its quality and security, enhancing its features and performance, benefiting from its updates and improvements, and becoming part of its community and culture. You are also contributing to the advancement of technology and innovation in general.

So next time you use or enjoy an open source software project, consider making a donation to show your support and appreciation. It doesn't have to be a lot; every little bit counts. Remember: open source software is free as in freedom, not as in free beer.

How to setup a Web3 Project

EHO Koku Hermann — Sat, 18 Mar 2023 11:22:03 +0000

This guide provides step-by-step instructions for setting up a Web3 project using Hardhat and the Nonic Foundation hardhat-toolbox. Hardhat is a development environment to compile, test, and deploy your Ethereum smart contracts, while Nonic Foundation hardhat-toolbox is a set of tools and helpers to make it easier to build, test, and deploy smart contracts.

1. Project setup

1.1. Introduction

Before diving into the steps, it's important to understand the purpose of the tools we will be using. Hardhat is a development environment to compile, test, and deploy your Ethereum smart contracts. It provides a suite of powerful and configurable tools that make it easier to develop, test, and deploy smart contracts. Nonic Foundation hardhat-toolbox is a set of tools and helpers that complements Hardhat, providing additional functionality such as contract upgradability and contract verification.

1.2. Setup a node Project

To get started, you need to create an empty Node.js project with default options. You can do this by running the following command in your terminal:

npm init -y

This creates a package.json file in your project directory, which will keep track of all the dependencies and scripts for your project.

1.3. Install Hardhat & Nonic Foundation hardhat-toolbox

Next, you need to install Hardhat and Nonic Foundation hardhat-toolbox as development dependencies. Run the following command in your terminal:

npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox

This installs the latest version of Hardhat and the Nonic Foundation hardhat-toolbox.

1.4. Setup Project

After installing Hardhat and Nonic Foundation hardhat-toolbox, you can set up your project by running the following command in your terminal:

npx hardhat

This command creates a hardhat.config.js file in your project directory, which is the main configuration file for Hardhat.

1.5. Importing OpenZeppelin Contracts

To use OpenZeppelin smart contracts in your project, you can install the @openzeppelin/contracts package by running the following command in your terminal:

npm install @openzeppelin/contracts

This installs the latest version of the OpenZeppelin Contracts library.

1.6. Make Contract upgradable

If you need to create an upgradable smart contract, you can follow these additional steps:

1.6.1. Install openzeppelin/hardhat-upgrades

After installing Hardhat and the Nonic Foundation hardhat-toolbox, you also need to install Hardhat Upgrades as a development dependency. Hardhat Upgrades is a plugin that allows you to upgrade your smart contracts in a safe and transparent way. To install Hardhat Upgrades, run the following command in your terminal:

npm install --save-dev @openzeppelin/hardhat-upgrades

1.6.2 Install openzeppelin/contracts-upgradeable

OpenZeppelin Contracts Upgradeable is a library of reusable smart contracts for Ethereum development that can be easily upgraded. To install it, run the following command in your terminal:

npm install @openzeppelin/contracts-upgradeable

2. Run script

Now that you've set up your project and installed the necessary dependencies, you can start compiling your Solidity code, testing your smart contracts, and starting an Ethereum local node.

2.1. Compiling Solidity

To compile your Solidity code, run the following command in your terminal:

npx hardhat compile

This command compiles all the Solidity contracts in the contracts/ directory and generates the artifacts in the
artifacts/ directory.

2.2. Test the smart contract

To test your smart contract, run the following command in your terminal:

npx hardhat test

This command runs all the tests in the test/ directory and generates a report with the results.

2.3 Start Ethereum local node Solidity

To start an Ethereum local node, run the following command in your terminal:

npx hardhat node

This command starts a local Ethereum node with a few pre-funded accounts, which you can use for testing and development purposes. You can interact with this node using the Hardhat console or any other Ethereum client.

3.Conclusion

In summary, this guide provides a step-by-step process for setting up a Web3 project using Hardhat and the Nonic Foundation hardhat-toolbox. The key takeaways include the importance of using a development environment like Hardhat to compile, test, and deploy Ethereum smart contracts, and the convenience of using Nonic Foundation hardhat-toolbox to enhance functionality such as contract upgradability and verification. Other important steps include setting up a Node.js project, installing dependencies, importing OpenZeppelin Contracts, and running various commands for compiling Solidity, testing smart contracts, and starting an Ethereum local node. With these steps, you can begin developing and testing smart contracts for various decentralized applications.

How to pass argument to your node script

EHO Koku Hermann — Tue, 04 Oct 2022 09:35:54 +0000

Sometimes you need to pass arguments to your node script so they can be more dynamic. Let's see how to do that.
Let imagine you have a node project with script part like that

{
 "scripts": {
    "example": "echo 'hello world'",
    "webpack": "webpack serve"
  },
}

You can run
npm run example
The you will have hello world as result
Or npm run webpack
then you have a webpack server who starts running.
Now if we want to pass arg when executing the CLI command, you can do that.

{
 "scripts": {
    "example": "echo \"Hello world, i'm $npm_config_first npm_config_last\" ",
    "webpack": "webpack serve --first=’Amah’ --second=’Kwatcha’ "
  },
}

Then run:
npm run example --last=Amah --first=Kwatcha
or npm run webpack.
With the first one you will get Hello world, i'm Kwatcha Amah
Then in your project when we run the webpack script, you can access the arguments in your environment variables.
process.env.npm_config_[args_name]
here in process.env.npm_config_first & process.env.npm_config_last.