Private Blockchain Setup with Geth: Step-by-Step Tutorial

This segment covers the process of connecting additional nodes to an existing private network and verifying successful connections. The instructor explains how to retrieve private keys from node data directories, start additional nodes with the appropriate network ID and existing node addresses, and verify that nodes have successfully synchronized. The segment emphasizes that each node must use a different port number to avoid conflicts, and that proper verification ensures the network is functioning correctly before proceeding with further operations.

Static nodes configuration allows administrators to pre-define which nodes can access the network. The permissioned node file lists static nodes with their IP addresses and peer-to-peer ports, establishing initial network access. Bootnodes serve as initial discovery points for new nodes joining the network. The node identifier (enode) consists of the public key, IP address, and peer-to-peer port. Static nodes are explicitly whitelisted in the configuration, while bootnodes facilitate initial network discovery. This configuration ensures that only authorized nodes can participate in the network from the start.

Bootnodes are pre-configured nodes that help new nodes join the network. They are the first nodes that interact with a new node during network synchronization. Bootnodes do not validate blocks but facilitate peer discovery. They can be configured in two ways: (1) Directly within the Genesis File as a parameter, or (2) Through CLI commands when starting the node. Bootnodes are used in both public Ethereum networks and private networks. When starting a new node, it queries bootnodes to obtain a list of active peers for connection.

When starting a new node, boot nodes specify existing nodes to connect to for initial network discovery. Using the loopback address (127.0.0.1) with the target port allows nodes on the same machine to discover each other. Once connected, nodes can peer and participate in block production.

This tutorial demonstrates how to build a private Ethereum network using Docker containers and the Geth client, covering the complete process of creating accounts with public addresses and private keys, configuring the genesis block to set initial balances and network parameters, initializing and connecting multiple nodes manually since private networks lack public discovery services, and performing transactions including mining rewards to demonstrate the complete blockchain lifecycle.

This segment covers testing and deployment capabilities in Hardhat. The workflow includes: (1) Writing test files in the tests/ directory using JavaScript, (2) Executing tests with 'npx hardhat test' to verify contract functionality, (3) Understanding test results with green checkmarks for passing tests, (4) Deploying contracts to networks using Hardhat's deployment scripts, (5) Monitoring deployed contracts showing account balances and storage values, (6) Configuring custom networks with specific RPC URLs and chain IDs, and (7) Interacting with deployed contracts through JavaScript scripts. This comprehensive workflow enables developers to verify contract behavior and deploy to various network environments.

Smart contracts are self-executing code on blockchains that eliminate intermediaries, and developers can choose between two primary testing frameworks: Hardhat (a JavaScript-based framework using Node.js modules, ethers, and Chai for integration testing) and Foundry (a pure Solidity framework using Git submodules and VM libraries for in-depth unit testing with detailed error tracing). Hardhat is better suited for front-end integration testing, while Foundry excels at detailed Solidity unit testing with features like test_revert and test_fail keywords for handling expected failures.

This comprehensive tutorial covers the complete workflow of integrating Hardhat with Foundry for Ethereum development. The process begins with Foundry repository setup using 'forge init', including DS Test submodule installation for testing infrastructure. Hardhat is then initialized with TypeScript configuration, and the hardhat-foundry plugin is installed to enable seamless integration. The tutorial demonstrates developing a price feed contract using OpenZeppelin's Ownable pattern, with functions to set proxy addresses and read price data. Testing requires implementing mock oracle contracts to simulate price feed responses. The section provides an in-depth comparison of testing methodologies: Hardhat uses JavaScript/TypeScript for accessibility, while Foundry uses Solidity for deeper contract-to-contract insights. Foundry's 'prank' function simulates transactions from specific addresses, while 'setBlockTimestamp' enables time-based testing. For deployment, Hardhat offers built-in verification tools and streamlined deployment scripts, while Foundry requires manual parameter entry for the 'forge create' command. The tutorial emphasizes organizing environment variables for different chains, including RPC endpoints, private keys, and API keys for verification services. This integration enables developers to leverage the strengths of both frameworks within a single project.

Hardhat's testing framework uses Waffle combined with Mocha and Chai. Tests can deploy contracts, call functions, and verify results. The ephemeral network feature allows tests to spin up a fresh chain for each test run, ensuring clean state. The require() function in Solidity enforces conditions before executing contract code - if the condition is false, the transaction reverts (fails) and no state changes are applied. This is a critical security mechanism for implementing access controls. When testing, you need to handle reverted transactions properly using expectRevert() to test that a transaction should fail. Hardhat can fork the current state of mainnet and run it locally, allowing you to test your contracts against the actual state of mainnet without deploying to it. Hardhat's hardhat.config.js allows you to configure different networks (localhost, hardhat, Rinkeby, mainnet) with RPC endpoints, chain IDs, accounts (private keys or mnemonics), gas prices, and gas multipliers. Private keys should never be committed to version control - store them in environment variables with .gitignore protection. When deploying to public networks, use separate accounts with their own private keys, not the default Hardhat accounts.

This comprehensive section covers the complete Foundry smart contract development workflow. It begins with course introduction explaining Foundry's advantages over Remix and Hardhat, particularly in caching and transaction management. The section details installation including VS Code Solidity extension, choosing between Git Bash or WSL for Windows users, running foundryup command, and configuring PATH. It covers the four core tools: forge (compilation, testing, deployment), anvil (local node), cast (contract interaction), and chisel (Solidity REPL). The instructor explains project initialization using forge init, the three main folders (src, test, scripts), the built-in forge-std library, Foundry.toml configuration, and organizing different test types. The section covers the development workflow including forge build for compilation, forge test for running tests in simulated environment, and the critical distinction between simulation and forking real networks. It details the deployment process including running Anvil with pre-funded accounts, configuring private keys, understanding transaction simulation versus actual deployment, and the distinction between local simulation and network forking. The section concludes with broadcasting transactions to networks using the --broadcast flag and contract verification through services like Etherscan.

This video demonstrates how to deploy and monitor a Hyperledger Besu permissioned blockchain network on AWS EKS using ChainLens for block exploration, Prometheus for metrics collection, and Grafana for visualization, including the deployment of smart contracts and real-time monitoring of network transactions and performance metrics.

This section covers deploying Prometheus and Grafana containers using Docker Desktop. Prometheus (port 9090) scrapes and stores metrics, while Grafana (port 3000) visualizes data. The default Grafana login is admin/admin. Both containers are deployed using Bitnami images and mapped to host ports for local access.

This video tutorial demonstrates how to set up Grafana for Prometheus monitoring by first installing Grafana using either Docker or pre-built binaries, then configuring a Prometheus data source pointing to the public demo server at demo.prometheus.io, and finally creating a dashboard with three basic panel types: a time series chart displaying 95th percentile request latency using PromQL transformations, a gauge panel showing CPU usage with threshold-based color coding, and a table panel displaying top request rates; the tutorial also covers organizing panels into thematic rows and customizing visual elements like legends, units, and thresholds.

Prometheus is an open-source monitoring system that collects and stores metrics from various targets (servers, containers, applications) through a scraping mechanism, while Grafana provides visualization capabilities to create customizable dashboards for monitoring server health, resource utilization, and performance metrics; together they form a powerful centralized monitoring solution where Prometheus handles data collection and storage, and Grafana enables intuitive data visualization through its query language and dashboard builder.

Enterprise blockchain monitoring requires integrated solutions combining Prometheus for metrics collection and Grafana for visualization. Hyperledger Fabric's operation service emits metrics in Prometheus format, enabling centralized monitoring within Kubernetes clusters. Prometheus automatically discovers and scrapes metrics from all components using Kubernetes labels, supporting dynamic scaling. Grafana provides intuitive dashboards displaying critical metrics including chain height, transaction counts, consensus status, validation latency, block cutter duration, peer leadership roles, and smart contract execution times. This comprehensive monitoring enables proactive network management and rapid issue detection.