DEV Community: ORJI CECILIA O.

React Hooks Explained: A Beginner's Guide

ORJI CECILIA O. — Fri, 07 Mar 2025 16:36:39 +0000

What is a Hook?

**
Hooks were added to React in version 16.8. They allow function components to access state and other React features. Hooks allows us to "hook" into React features such as state and lifecycle methods.

In summary, Hooks are special functions that let function components use features that were only available in class components before React 16.8. Simply put, they let function components "do more" without needing a class.

For example:

import React, { useState } from 'react';

const Counter = () => {
  //useState hook to manage count state
  const [count, setCount] = useState(0);  

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => setCount(count + 1)}>Increase</button>
    </div>
  );
};

export default Counter;

Explanation:

useState(0) creates a state variable count starting at 0.
setCount(count + 1) updates the count when the button is clicked.
Every time the button is clicked, React re-renders the component with the new count.

This is a simple example of how hooks let function components manage state without needing a class component.

Hook Rules
There are 3 rules for hooks:

Hooks can only be called inside React function components.
Hooks can only be called at the top level of a component.
Hooks cannot be conditional

Let's go into the different react hooks;

useState

The React useState Hook allows us to track state in a function component. state generally refers to data or properties that need to be tracked in an application. Just like in the example above, A simple counter that remembers the number when you click a button.

useEffect

This runs code when something changes. Think of it as a way to run code when your component loads or updates.

Example: Fetching data from an API when the page loads.

import React, { useState, useEffect } from 'react';

const FetchData = () => {
  const [data, setData] = useState([]);

  useEffect(() => {
    fetch('https://jsonplaceholder.typicode.com/posts')
      .then((res) => res.json())
      .then((data) => setData(data));
  }, []); //runs only once when the component loads

  return <p>Data Loaded: {data.length} items</p>;
};

export default FetchData;

Explanation

useEffect(() => {...}, []) runs once when the component loads.
It fetches data and stores it in state using setData(data).
Without useEffect, this code would run every time the component updates, causing an infinite loop!

useContext

This is used to avoid passing props manually. This is a way to share data across components without passing props down manually.

Example: Managing a theme (dark/light mode) globally.

import React, { createContext, useContext } from 'react';

//create a Context for the theme
const ThemeContext = createContext('light');

const ThemedComponent = () => {

   //access the theme value
  const theme = useContext(ThemeContext);
  return <p>Current theme: {theme}</p>;
};

const App = () => (
  <ThemeContext.Provider value="dark">
    <ThemedComponent />
  </ThemeContext.Provider>
);

export default App;

Explanation

createContext('light') creates a global state (default theme is "light").
useContext(ThemeContext) allows any component to access the theme without prop drilling.

useRef

This keeps a value without re-rendering. Think of it as a way to store a value that React won’t forget but won’t trigger re-renders.

Example: Automatically focus on an input field when the page loads.

import React, { useRef, useEffect } from 'react';

const FocusInput = () => {
  const inputRef = useRef(null);

  useEffect(() => {

    //focuses on the input when the page loads
    inputRef.current.focus(); 
  }, []);

  return <input ref={inputRef} type="text" placeholder="Type here..." />;
};

export default FocusInput;

Explanation

useRef(null) creates a reference to an input field.
inputRef.current.focus() makes the input auto-focus when the page loads.
Unlike useState, useRef does not trigger a re-render when updated

useMemo

This is used to improve performance.
Think of it as a way to "remember" a value so React doesn’t calculate it every time.
Example: Squaring a number without unnecessary recalculations.

import React, { useState, useMemo } from 'react';

const ExpensiveCalculation = ({ number }) => {
  const squared = useMemo(() => {
    console.log('Calculating square...');
    return number * number;
  }, [number]);

  return <p>Squared: {squared}</p>;
};

Explanation

useMemo(() => number * number, [number]) remembers the calculation and only updates if number changes.
Without useMemo, React would re-calculate the square every render, which is inefficient.

useCallback

This prevents unnecessary re-creation of functions. It is used to prevent functions from being recreated when not needed.

Example: Preventing unnecessary re-renders in child components.

import React, { useState, useCallback } from 'react';

const Button = ({ handleClick }) => {
  console.log('Button re-rendered');
  return <button onClick={handleClick}>Click me</button>;
};

const Parent = () => {
  const [count, setCount] = useState(0);

  const memoizedHandleClick = useCallback(() => {
    setCount((prev) => prev + 1);
  }, []);

  return (
    <div>
      <p>Count: {count}</p>
      <Button handleClick={memoizedHandleClick} />
    </div>
  );
};

Explanation

useCallback(() => {...}, []) stores the function so it doesn’t change unless dependencies change.
Without useCallback, the button would re-render unnecessarily on every parent re-render

React also supports custom hooks which are reusable logic inside hooks. Instead of copying logic between components, you can create a custom hook and reuse it. They are commonly used for fetching data, managing authentication, or handling forms.

React Hooks make function components more powerful by letting us manage state, side effects, and performance optimizations without needing class components.

If you’re just starting, focus on useState for state management, useEffect for side effects like API calls, and useContext for sharing global data. As you grow, explore hooks like useRef, useMemo, and useReducer for better performance and complex logic.

Mastering hooks will help you write cleaner, more efficient React apps—so keep practicing and building!

Building Fully On-Chain NFTs with Solidity: A Step-by-Step Guide

ORJI CECILIA O. — Thu, 27 Feb 2025 04:06:07 +0000

Introduction
In the world of NFTs, most digital assets rely on off-chain storage solutions like IPFS or centralized servers for storing metadata and images. But what if you could store everything directly on the blockchain—including the NFT artwork?

In this article, we’ll walk through the creation of an on-chain NFT using Solidity. This NFT contract generates SVG images dynamically, encodes them in Base64, and serves them directly from the smart contract—ensuring permanence and full decentralization.

By the end, you'll understand how to:

Generate on-chain SVG images for NFTs
Use Base64 encoding to store images within smart contracts
Implement a fully decentralized ERC-721 contract

Let's get into it!

Understanding On-Chain NFTs
Traditional NFTs store images and metadata off-chain, meaning if a hosting service goes down, the NFT might lose its artwork. On-chain NFTs, on the other hand, embed all data within the blockchain, ensuring that they remain accessible as long as Ethereum exists.

In this tutorial, we’ll create a fully on-chain NFT that:

Uses Solidity to generate an SVG image
Stores both the image and metadata directly on the blockchain
Mints NFTs dynamically without relying on external storage

This means that every NFT image is programmatically generated and stored directly inside the smart contract.

The Smart Contract
Here’s the full Solidity code for our on-chain NFT contract.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

contract OnChainNFT is ERC721 {
    using Strings for uint;
    uint256 public tokenId;

    constructor() ERC721 ("ceceNFT", "cece") {
        tokenId = 1;
    }

    event NFTMinted(address indexed owner, uint256 tokenId);

    function generateSVG() internal pure returns (string memory) {
        string memory svg = string(
            abi.encodePacked(
            '<svg xmlns="http://www.w3.org/2000/svg" width="500" height="500">',
            '<rect width="100%" height="100%" fill="black" />',
            '<circle cx="250" cy="250" r="210" fill="orange" />',
            '<circle cx="250" cy="250" r="190" fill="white" />',
            '<circle cx="250" cy="250" r="170" fill="red" />',
            '<circle cx="250" cy="250" r="150" fill="yellow" />',
            '<circle cx="250" cy="250" r="130" fill="green" />',
            '<circle cx="250" cy="250" r="110" fill="blue" />',
            '<circle cx="250" cy="250" r="90" fill="purple" />',
            '<circle cx="250" cy="250" r="70" fill="pink" />',
            '<circle cx="250" cy="250" r="50" fill="brown" />',
            '<circle cx="250" cy="250" r="30" fill="black" />',
            '</svg>'
        ));
        return string(abi.encodePacked("data:image/svg+xml;base64,", Base64.encode(bytes(svg))));
    }

    function mintNFT() public {
        tokenId++;
        _safeMint(msg.sender, tokenId);
        emit NFTMinted(msg.sender, tokenId);
    }

    function tokenURI(uint256 tokenTxId) public view override returns (string memory) {
        ownerOf(tokenTxId);

        string memory name = string(abi.encodePacked("cece ", Strings.toString(tokenTxId)));
        string memory description = "My NFT";
        string memory image = generateSVG();

        string memory json = string(
            abi.encodePacked(
                '{"name": "', name, '", ',
                '"description": "', description, '", ',
                '"image": "', image, '"}'
            )
        );
        return string(abi.encodePacked("data:application/json;base64,", Base64.encode(bytes(json))));
    }
}

Now, let’s break this contract down step by step.
1. Contract Setup

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

ERC721.sol → Standard implementation for NFTs.
Base64.sol → Used to encode images & metadata in Base64 format.
Strings.sol → Helps convert numbers to string format.

If you haven't installed OpenZeppelin yet, run in your terminal

npm install @openzeppelin/contracts

2. Generating the SVG Image

function generateSVG() internal pure returns (string memory) {

This function creates the SVG artwork for the NFT.
Each circle inside the SVG creates a layered bullseye effect.
The final SVG is Base64 encoded so it can be stored directly in the smart contract.

Example Output of generateSVG()
data:image/svg+xml;base64,PHN2ZyB...

This can be directly displayed in browsers or NFT marketplaces.

3. Minting the NFT

function mintNFT() public { tokenId++; _safeMint(msg.sender, tokenId); emit NFTMinted(msg.sender, tokenId); }

Calls _safeMint() to safely assign a new NFT to msg.sender.
Uses an incrementing tokenId to ensure each NFT has a unique identifier.
Emits an event to log the minting.

4. Generating Metadata for Marketplaces

function tokenURI(uint256 tokenTxId) public view override returns (string memory) {

Generates the NFT metadata in JSON format.
Encodes everything in Base64 to be fully on-chain.

Example Output (for tokenTxId = 1)

{ "name": "cece 1", "description": "My NFT", "image": "data:image/svg+xml;base64,PHN2ZyB..." }
NB - This metadata is formatted to match OpenSea & other marketplaces.

Why On-Chain NFTs Are Revolutionary
Unlike traditional NFTs that rely on external servers or IPFS, on-chain NFTs ensure:

Permanence → Your NFT never disappears (even if IPFS goes offline).
Decentralization → No third-party hosting needed.
Immutability → The image & metadata live forever on the blockchain.

Deploying Your On-Chain NFT to Base Sepolia

Now that we've built our fully on-chain NFT contract, let's deploy it to Base Sepolia, a testnet optimized for Ethereum L2 solutions.

Setting Up Your Deployment Script (deploy.ts)

Create a new file inside the scripts/ folder:
scripts/deploy.ts

`import { ethers } from "hardhat";

async function main() {
console.log("Deploying NFT contract...");

const NFT = await ethers.getContractFactory("OnChainNFT");
const nft = await NFT.deploy();

await nft.waitForDeployment();

const contractAddress =  await nft.getAddress();

console.log("Minting first NFT...");

const tx = await nft.mintNFT();
await tx.wait();

console.log("NFT minted at address:", contractAddress);

}

main().catch((error) => {
console.error("deployment failed:",error);
process.exitCode = 1;
});
`
This script does the following:

Compiles the NFT contract
Deploys it to the Base Sepolia network
Mints the first NFT automatically after deployment

Configuring Hardhat for Base Sepolia

Now, update your Hardhat configuration to support Base Sepolia.
hardhat.config.ts

import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import "@nomicfoundation/hardhat-verify";
import "dotenv/config"; // Use dotenv for environment variables

const { 
  ALCHEMY_BASE_SEPOLIA_API_KEY_URL,
  ACCOUNT_PRIVATE_KEY, 
  ETHERSCAN_API_KEY 
} = process.env;

const config: HardhatUserConfig = {
  solidity: "0.8.28",

  networks: {
    base_sepolia: {
      url: ALCHEMY_BASE_SEPOLIA_API_KEY_URL,
      accounts: ACCOUNT_PRIVATE_KEY ? [`0x${ACCOUNT_PRIVATE_KEY}`] : [],
      timeout: 120000, 
    },
  },

  etherscan: {
    apiKey: ETHERSCAN_API_KEY,
  },
};

export default config;

What This Does:

Configures Base Sepolia testnet using Alchemy
Loads private keys securely from .env
Enables contract verification on Etherscan

Setting Up Environment Variables (.env File)

Create a .env file in the root of your Hardhat project and add:

ALCHEMY_BASE_SEPOLIA_API_KEY_URL="https://basesepolia.alchemyapi.io/v2/YOUR_ALCHEMY_KEY"
ACCOUNT_PRIVATE_KEY="YOUR_WALLET_PRIVATE_KEY"
ETHERSCAN_API_KEY="YOUR_ETHERSCAN_API_KEY"

NB - Never hardcode private keys in your code. Always use environment variables.

Deploying the NFT to Base Sepolia

A - Install Dependencies
If you haven’t already installed Hardhat and the required plugins:

npm install @nomicfoundation/hardhat-toolbox @nomicfoundation/hardhat-verify dotenv ethers hardhat
B - Compile the Contract
Run:
npx hardhat compile
C - Deploy the Contract
Run:
npx hardhat run scripts/deploy.ts --network base_sepolia
Deploys the OnChainNFT contract to Base Sepolia
Automatically mints the first NFT after deployment

D - Expected output after deployment

npx hardhat run scripts/deploy.ts --network base_sepolia Compiled 1 Solidity file successfully (evm target: paris). Deploying NFT contract... Minting first NFT... NFT minted at address: 0x81783AC13C6Bdf030d8De279a13b63E4406287Da

Verifying the Contract on Etherscan
This is optional and it is to make your contract publicly viewable, verify it on Base Sepolia Etherscan:

npx hardhat verify --network base_sepolia 0xYourDeployedContractAddress
This allows anyone to interact with your NFT contract directly from Etherscan.

Viewing Your On-Chain NFT on OpenSea
To view on opensea, go to url, signup and connect your wallet if you are not signed up. Go to your account or profile and you can view your nft. Here is our minted nft

MY ERC20 WALKTHROUGH

ORJI CECILIA O. — Wed, 26 Feb 2025 15:23:04 +0000

What is an ERC20?

**
Ethereum Request for Comment 20 (ERC20) is a standard for the Ethereum blockchain that defines a set of required functions and events for creating fungible tokens within a smart contract. ERC20 can be thought of as a set of predefined function signatures that any token contract must implement to be compatible with Ethereum's ecosystem.

By the end of this article, you will gain a clear understanding of function signatures, particularly those found in ERC20, and how to create custom functions using established patterns. We will also explore events, their practical applications, and examine real-world use cases of ERC20, along with examples of decentralized applications (dApps) that utilize ERC20.
**
Use Cases of ERC20**

Decentralized Finance (DeFi) ERC-20 tokens play a critical role in decentralized finance (DeFi) by enabling various financial applications:

Stablecoins: ERC-20 tokens represent fiat-pegged digital assets to provide stability for users.
Lending and Borrowing: Users can earn interest on ERC-20 assets or use them as collateral to access liquidity.
Decentralized Exchanges (DEXs): ERC-20 tokens allow peer-to-peer trading without intermediaries.
Yield Farming: Users earn rewards by providing liquidity to DeFi protocols.
ERC-20 tokens have transformed traditional finance by providing decentralized alternatives to banking, lending, and trading.

2. Non-Fungible Tokens (NFTs)
Although NFTs are primarily based on ERC-721 and ERC-1155, ERC-20 tokens still play a key role in the NFT ecosystem:

Wrapped NFTs: ERC-20 tokens can represent ownership of NFTs, allowing them to be traded on decentralized exchanges.
NFT Marketplaces: ERC-20 tokens act as the primary currency for buying and selling NFTs.
Platform Governance: Some NFT projects use ERC-20 tokens for voting and decision-making within their ecosystems.
By integrating ERC-20 tokens, the NFT market has expanded its liquidity, accessibility, and interoperability.

3. Gaming
The gaming industry is leveraging ERC-20 tokens in multiple ways:

In-Game Currency: Players use ERC-20 tokens to purchase virtual assets and access premium content.
Asset Ownership: Blockchain gaming platforms use ERC-20 tokens to allow true ownership of digital assets.
Decentralized Economies: Play-to-earn games use ERC-20 tokens as rewards for gameplay achievements.
Community Governance: Some gaming platforms let players vote on game updates using ERC-20 tokens.
ERC-20 tokens have revolutionized gaming by creating decentralized economies where players have true ownership and financial incentives.

4. Supply Chain Management
ERC-20 tokens are increasingly integrated into supply chain management to improve transparency and efficiency:

Product Tracking: Companies tokenize physical goods with ERC-20 tokens for real-time tracking on the blockchain.
Inventory Management: Automated token-based inventory systems reduce errors and fraud.
Supply Chain Financing: Companies tokenize invoices and purchase orders for faster payments and financing.
Sustainability Tracking: Consumers can verify the environmental and ethical impact of a product.
By leveraging ERC-20 tokens, supply chain networks become more secure, transparent, and efficient.

5. Tokenized Assets
ERC-20 tokens facilitate fractional ownership of assets, making high-value investments more accessible:

Real Estate: Investors can own fractions of real estate through ERC-20 tokens.
Stocks & Bonds: Traditional securities can be tokenized, allowing global, 24/7 trading.
Intellectual Property: Artists and creators can sell tokenized shares of their work.
Art & Collectibles: Rare assets can be fractionalized and traded on digital marketplaces.
Tokenization using ERC-20 removes barriers to investment and increases asset liquidity.

6. Stablecoins
ERC-20 tokens are at the core of stablecoin development, enabling price-stable cryptocurrencies:

Fiat-Pegged Stablecoins: Tokens like USDT, USDC, and DAI are backed by real-world assets.
Algorithmic Stablecoins: Some ERC-20 stablecoins maintain stability without collateral by using smart

EXAMPLE OF DECENTRALIZED APPLICATIONS THAT USES ERC20

Some prominent examples of decentralized applications (dApps) that utilize ERC-20 tokens include Uniswap (a decentralized exchange for trading ERC-20 tokens), Aave (a DeFi platform for lending and borrowing crypto assets), and Compound (another DeFi platform for lending and borrowing), all of which operate on the Ethereum blockchain and rely on the ERC-20 standard for token functionality.

In order to Properly understand what the function in ERC20, here are some basics you should take note of:

*What is a function signature?
*
A function Signature is a unique identifier for a function in a program. It is the hash of a function’s component which are:

Function name: The function name is the name given to the function as a unique entity

Function parameters: These are the inputs that a function receives. They can be one or many. They can vary in number and type.

Function visibility: This refers to where can a function be visible from(i.e within or from outside your code) when a user wants to interact with it . Its visibility can include public, internal, external and private.

Function return types: This refers to the kind of value that the function returns. It could be a single value, an array of values, an object or any data type.

Function modifiers: Modifiers are keywords that are added to the definitions of functions to alert the functionality of a function. They can be used to control access to the function, to modify the return type of the function, or to impose other restrictions or allowances on the function.

WHAT ARE EVENTS IN SOLIDITY?

In Solidity, events are a way to log and notify external entities (such as user interfaces or other smart contracts) about specific occurrences within a smart contract. They serve as a mechanism for emitting and recording data onto the blockchain, making it transparent and easily accessible. Emits, on the other hand, are used to trigger or emit events within the smart contract code.

Defining and Emitting Events:

a. Event Declaration:

To define an event, you need to declare it within the contract. An event declaration consists of the event’s name, a list of parameters (if any), and their data types. Here’s an example:

In this example, we define an event named “NewTransaction” that takes three parameters: transactionId (an unsigned integer), sender (an Ethereum address), and amount (an unsigned integer).

b. Emitting Events:

To emit an event within the contract, you use the “emit“ keyword followed by the event name and any necessary parameters. Here's an example of emitting the Successfultxn event:In this example, we define an event named “Successfultxn” that takes three parameters: transactionId (an unsigned integer), sender (an Ethereum address), and amount (an unsigned integer).

b. Emitting Events:

To emit an event within the contract, you use the “emit“ keyword followed by the event name and any necessary parameters. Here's an example of emitting the succussfultxn event:

So lets get into the code

Here the code started with me declaring the license Identifier as unlicensed meaning that the code base is not under any open source license and does not grant permission for others to use, modify or distribute.

Followed immediately is version of solidity compiler that solidity uses (0.8.28). Then the name of the contract was named as “erc20”.

State variables named name, symbol, _decimals and total supply was declared with the data type string, string, uint8 and uint256 respectively.

Also an address data type name owner was declared. Then both a mapping and a 2D mapping data type was declared name balances and allowances where both were given the visibility as public meaning, that under the hood, a getter function has also been declared to us.

Custom errors was also written that would be used in the contract. These custom errors are name InvalidAddress, InsufficientFunds, InsufficientAllowance, OnlyOwnerAllowed and InvalidAmount.

Then comes the 2 events need when interacting with an ERC20 standard. The Transfer and the Approval. The minted event was added by me. The Transfer event carries three parameters, the from with an address data type, to also with an address data type and value with a unsigned Integer data type. As for Approval, its parameters includes owner with address data type, spender also with an address data type and an unsigned Integer named value.

Then a modifier is defined. Remember one of the details that can be found in a function signature is a function modifier and this function modifier was written like how the modifier called onlyOwner is written. It carries a condition that if msg.sender(a users interacting with a particular function in our contract) isnt equals to the owner that was declared earlier the, code should be reverted with OnlyOwnerAllowed custom error that was defined above.

Now lets go to our functions declarations.

The first function declared in the contract is name(). It has public visibility, a view function modifier, and returns a string stored in memory. This function serves as a getter function, retrieving the value of the _name state variable declared earlier in the contract.

Since Ethereum operates as a state machine, this function simply reads the value stored in the _name variable. The public visibility means the function can be called both internally (within the contract) and externally (by other contracts or users). The view modifier ensures that the function does not modify the blockchain state but only retrieves data. The returns keyword specifies the expected return data type, which in this case is a string—matching the _name state variable.

This same principle applies to other getter functions like symbol(), decimals(), and totalSupply(), each of which retrieves the corresponding state variable value without modifying the blockchain state.

The balanceOf function is responsible for retrieving the token balance of a specific address. It takes an address parameter (owner) and has a function visibility of public with a view modifier. This means it does not alter blockchain data but only reads and returns an unsigned integer (uint256) representing the balance.

Before returning the balance, the function first performs a sanity check to ensure the provided address is not the zero address (0x0). If the check fails, it triggers a custom error InvalidAddress, preventing invalid balance lookups.

In Solidity, mappings are used to store key-value pairs. The balanceOf function retrieves a balance using the balances mapping, where the key is an address, and the value is the associated token balance. This mapping ensures efficient storage and retrieval of token balances without the need for looping through data.

By following this structure, balanceOf efficiently tracks token ownership, ensuring security and accuracy in ERC20 token implementations.

The balances mapping is publicly accessible and is used to store the token balance of each address. It is defined with the address data type as the key and uint256 as the value. This means that each Ethereum address is associated with a specific numeric balance representing the amount of tokens it holds.

To retrieve the balance of a particular address using this mapping, the key (the address) is passed in as follows:

The _owner inside the square bracket act as the key pointing to a value with the data type uint256 and this uint256 is what is been returned from the function.

It is worthy to recognize that the function balanceOf returns a uint256 with an implicit return name balance. So the balance which has a data type of uint256 is set to the balances mapping .

The transfer function takes two arguments, the address data type named to and a uint256 named value, and returns a boolean implicitly name success. The function checks if address argument to is an address zero and if true return the InvalidAddress custom error. Also the function check if argument value is greater than the balance of the msg.sender(a user interacting with the function), if true return InsufficientFunds custom error. Then the balances mapping of the msg.sender is decremented by the value passed as an argument, while the balances mapping of the to address passed in the argument is incremented with the value passed into the argument since we are trying to transfer from the caller of the function to the receiver , in this case the to address. Also remember that an event was set earlier in our contract called Transfer. That event is emitted whenever this function is called. Recall that the event received three parameters and because of this the emit also would have to hold three parameter relative to the parameter in the event. The parameters to be emit are the address of the msg.sender, the address of the to and the value. Since the function returns a boolean implicitly named success, success is set to true.

Bitcoin Mining and the 51% Attack

ORJI CECILIA O. — Sat, 24 Feb 2024 02:32:20 +0000

WHY DOES MINING EXIST?

**
To start at the beginning, let's look at why mining exists in the first place. The whole premise of Bitcoin is decentralization. So whose responsibility is it to provide security to the users of the network? When you use Visa or PayPal, it is Visa and PayPal who provide the security to the services they provide. But no one owns Bitcoin. No one intrinsically has the incentive to make sure it's safe. This could be a problem.

So a decentralized method of providing security was invented and made the lifeblood of Bitcoin. Instead of one person or entity handling security, now it's everyone's responsibility. That's what mining is—a decentralized security mechanism.

The mining process consists of collecting transactions broadcasted on the network and putting them into a block to be verified.

Miners have alternative methods, often referred to as "out-of-band," for receiving transactions. These include direct transactions sent to miners or utilizing services such as mempool.space, Twitter, or nostr. However, the primary and preferred source is the peer-to-peer (P2P) network. It is crucial to maintain this reliance on the P2P network to mitigate the risks associated with mining centralization. Encouraging transaction propagation through the P2P network ensures a decentralized and robust system, reinforcing the principles of security and integrity within the mining ecosystem.

Bitcoin Mining: The Core Process

Collecting Transactions and Building Blocks
The first step in mining is gathering transactions broadcasted on the Bitcoin network. These transactions represent transfers of Bitcoin between different users. Miners collect these transactions and group them into a new "block." This block becomes a permanent record of these transactions on the blockchain.

The Crucial Role of Proof of Work (PoW)
The central element of Bitcoin mining is the PoW algorithm. This complex mathematical puzzle acts as a security measure by making it computationally difficult to create new blocks. This difficulty discourages malicious actors from attempting to manipulate the blockchain, ensuring its integrity and stability.

Solving the Puzzle: Miners vs. Algorithms
Miners compete to solve the PoW puzzle by taking specific data, including the collected transactions, and running it through a hashing algorithm (SHA-256 in Bitcoin's case). They also include a random number called a "nonce" in the hashing process. The goal is to find a nonce that generates a hash with a specific number of leading zeroes, determined by the current network difficulty. This difficulty automatically adjusts based on mining activity, ensuring a consistent block creation rate.

The Trial and Error of Mining
Finding a valid hash is a computationally intensive process. Miners constantly adjust the nonce and re-run the hashing algorithm, hoping to hit the target. This trial and error can take hours or even days, depending on individual mining power. Specialized hardware called "mining rigs" hash at incredible speeds, increasing the chances of finding a valid block.

Success! But the Work Never Stops
When a miner successfully solves the PoW puzzle, they create a new block, adding it to the blockchain and earning a reward in Bitcoin. However, the mining process is never truly finished. New transactions constantly appear, requiring more blocks to be created and verified, ensuring the smooth operation and security of the Bitcoin network.

Upon a successful mine, the miner receives a reward of bitcoins. Bitcoin miners are rewarded with new bitcoins for their efforts. As of February 2024, the reward is 6.25 bitcoins per block. The block reward is halved every 210,000 blocks or approximately every four years.

Bitcoin Mining Attacks

Bitcoin mining attacks refer to various malicious activities targeting the cryptocurrency mining process. Some common types of attacks related to Bitcoin mining are:

51% Attack:
Sybil Attack:
Eclipse Attack:
Selfish Mining:
Application-Specific Integrated Circuits(ASIC) Hardware Vulnerabilities, and so on

The 51% Attacks

According to Investopedia "A 51% attack is an attack on a cryptocurrency blockchain by a group of miners who control more than 50% of the network's mining hash rate".

Imagine you're playing a voting game with your friends to decide what movie to watch. Everyone votes anonymously, and the majority vote wins. This is similar to how Bitcoin mining works, where miners vote on valid transactions through their computing power.

Now, imagine one player (or a group of friends) secretly buys a bunch of extra votes (more computing power). Suddenly, their vote counts way more than anyone else's! This is essentially what happens in a 51% attack on Bitcoin mining:

Gaining Control: A malicious actor gets over 50% of the mining power (voting power). This could be done by renting a lot of computing power or hijacking existing miners.
Messing with the System: With this majority, they can:

Block transactions: They can prevent certain transactions from being confirmed, effectively stopping them.
Double-spend: They can create fake transactions, spend the same Bitcoin twice, and get away with it.
Change the past: In rare cases, they could rewrite parts of the transaction history, but this is very difficult and risky.

Has there been a successful 51% Attack on the Bitcoin Network?

The answer is NO. While smaller cryptocurrencies and forks of Bitcoin have been targeted, the immense cost and resources needed to attack the Bitcoin network have so far deterred any attempts.

Here's a breakdown of why a 51% attack on Bitcoin remains highly unlikely:

Massive Computing Power Required: Controlling 51% of the Bitcoin network's hash rate would require access to a huge amount of specialized hardware and significant electricity to power it. As of February 2024, estimates suggest this would cost billions of dollars, making it a daunting financial undertaking.
Network Difficulty Adjustment: The Bitcoin network automatically adjusts its difficulty based on the total mining power, making it harder to solve blocks as more miners join. This increases the cost and effort required to achieve a 51% attack as the network grows.
Decentralized Nature: Bitcoin's decentralized structure further complicates such attempts. Attackers wouldn't just need to control mining power but also convince other miners to follow their malicious version of the blockchain, which is highly unlikely given the extensive security measures in place.
Community Monitoring: The Bitcoin community actively monitors the network for suspicious activity, making it difficult for an attacker to remain undetected for long. Any attempt to manipulate the network would likely be identified and countered quickly.
Economic Disincentive: Successfully manipulating transactions for personal gain wouldn't necessarily benefit the attacker in the long run. The entire value of Bitcoin relies on its trust and security, and a successful attack would likely damage its reputation and value, ultimately hurting the attacker as well.

While the possibility of a future attack should never be completely dismissed, the significant barriers and potential negative consequences make it highly unlikely for Bitcoin to fall victim to a 51% attack in the foreseeable future.

In conclusion, a 51% attack undermines the whole system's trust and security. People might lose confidence in Bitcoin if they think someone can manipulate it. As such, there is a need for continued improvements in the network's security and community vigilance which will further strengthen this resistance.

Creating a Bitcoin Address in Golang with btcd

ORJI CECILIA O. — Tue, 30 Jan 2024 15:30:30 +0000

Imagine bitcoin as digital cash. To receive it, you need a unique identifier called a bitcoin address. You can share this address publicly to receive payments.
But how do you access and manage your Bitcoin? That's where a Bitcoin wallet comes in.
It's like a secure digital container that holds your keys and allows you to send bitcoin, receive bitcoin, and track how many bitcoins were sent to your address.

What is a bitcoin address?
A Bitcoin address is a unique identifier used to receive or send bitcoin in the Bitcoin network.
You can use it to receive or request payments. It is typically a string of letters and numbers, and it plays a role similar to an account number in traditional banking.
Keep in mind that a Bitcoin address is just one part of a Bitcoin wallet, which also includes private keys, which is a cryptographically generated random number that allows you to spend the bitcoin sent to your bitcoin addresses.

Different types

Legacy Addresses (P2PKH): These are traditional Bitcoin addresses that start with a '1'. They are derived from the public key and are widely used. For example, a legacy address might look like: 1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2.
Segregated Witness (SegWit) Addresses (bech32 encoding format): SegWit is an upgrade to the Bitcoin protocol that makes various changes to the protocol one of such is introducing a new bitcoin address format called segwit addresses.
SegWit addresses have 32 characters, which comprise lowercase letters a-z and numbers 0-9, it starts with '3' and are more space-efficient, resulting in lower transaction fees. For example, a SegWit address might look like: 3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy

A private key is a secret, alphanumeric string that allows you to access and control the funds associated with a specific public address.

NB:
Keep your private keys safe, like your regular wallet's pin.
Never share your private keys with anyone!

Let's dive into it
Requirements
Ensure you have go installed

on MacOs
brew install go
Verify the installation
go version
on Windows:

Download the MSI installer from the official Golang website.
Run the installer and follow the installation prompts.
Open a new Command Prompt or PowerShell window, and verify the installation by running go version

Step 1: Set Up Your Go Module
a. Open your terminal.
b. Create a new folder for your project:
mkdir btc-wallet- generator
c. Change into the project directory:
cd btc-wallet-generator
d. Create a new Go module:
go mod init btc-wallet-generator
e. Run go mod tidy to clean up and update dependencies.

Step 2: Install Dependencies
Run the following command to install the btcd library, which is used for wallet generation:
go get github.com/btcsuite/btcd@v0.22.1

Step 3: Create main.go File
Create a main.go file in your project folder and add the following content below:

package main

import (
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"

    "github.com/btcsuite/btcd/chaincfg"
    "github.com/btcsuite/btcd/btcec"
    "github.com/btcsuite/btcutil"
)

Step 4: Write the Main Function

func main() {
    createP2PKHAddress()
}

Step 5: Generate P2PKH Address Function
Add the createP2PKHAddress function to your main.go file:

func createP2PKHAddress() {
    // Choose the Bitcoin network (testnet in this case)
    params := &chaincfg.TestNet3Params

    // Generate a new private key
    privKey, err := btcec.NewPrivateKey(btcec.S256())
    if err != nil {
        log.Fatal(err)
    }

    // Get the corresponding public key
    pubKey := privKey.PubKey()

    // Create a P2PKH address
    addr, err := btcutil.NewAddressPubKeyHash(btcutil.Hash160(pubKey.SerializeCompressed()), params)
    if err != nil {
        log.Fatal(err)
    }

    // Display the generated address and private key
    fmt.Printf("| Public Address | %s |\n", addr.EncodeAddress())
    fmt.Printf("| Private Key     | %s |\n", hex.EncodeToString(privKey.Serialize()))

    // Save the wallet information to a JSON file
    wallet := map[string]string{
        "address":    addr.EncodeAddress(),
        "privateKey": hex.EncodeToString(privKey.Serialize()),
    }

// Serialize wallet information to JSON format with indentation
walletJSON, err := json.MarshalIndent(wallet, "", "    ")
if err != nil {
    log.Fatal(err)
}

// Write the serialized JSON to a file named "wallet.json" //with read-write permissions (0644)
err = ioutil.WriteFile("wallet.json", walletJSON, 0644)
if err != nil {
    log.Fatal(err)
}

// Print a message indicating that the wallet has been created //and saved to "wallet.json"
fmt.Println("Address created and saved to wallet.json")
}

Step 6: Run the Program
Run the following command in your terminal to compile and execute the Go program:
go run main.go

Step 7: Check Your Address on Mempool
The program will generate a public address and private key, save them to wallet.json, and display a message. Copy the generated address and visit coinfaucet to get free bitcoin which in this case is just for testing purposes.

After receiving some funds, check your UTXO and other information on mempool-testnet.

In conclusion, this article aims to guide developers through the process of setting up a development environment, using btcd, writing Golang code, and testing a basic Bitcoin address.

Career Opportunities as an Open-source contributor

ORJI CECILIA O. — Fri, 17 Feb 2023 08:52:24 +0000

Open-source software refers to software whose source code is publicly available and can be modified and distributed by anyone. Contributing to open-source projects can be a valuable way to gain experience and develop skills, as well as to demonstrate your abilities to potential employers.

There are many ways to contribute to open-source projects, and not all of them require programming skills. Some examples of ways to contribute include:

Technical writing and documentation: Open-source projects often require documentation, user guides, and other written materials to help users understand how to use the software. Technical writers can contribute by writing and editing these materials.
Bug reporting and testing: Users of open-source software can help improve the software by reporting bugs and issues they encounter, as well as testing new features and releases.
User experience design: User experience (UX) designers can contribute to open-source projects by designing user interfaces and improving the overall usability of the software.
Community management: Open-source projects require active communities to thrive, and community managers can contribute by organizing events, moderating online forums, and promoting the project.

In addition to the skills you can gain by contributing to open-source projects, there are also many career opportunities in the open-source space. Some of these include:

Open-source software development: Many companies use open-source software in their products and services, and they need developers who are familiar with the software to customize and maintain it.
DevOps: DevOps is a field that focuses on software development and operations, and it often involves using open-source tools and technologies to build and deploy software.
Technical writing and documentation: As mentioned earlier, open-source projects often require documentation and user guides, so technical writers with experience in open-source software can find job opportunities in this field.
Community management: Companies that develop and use open-source software often need community managers to engage with users, promote the project, and build a strong community around the software.

Also, some open-source projects offer paid internships and other opportunities for contributors. Outreachy, for example, is a program that provides paid internships to people from underrepresented groups who want to contribute to open-source projects. The Linux Foundation also offers mentorship programs and other opportunities for people interested in open-source software.

If you're interested in finding paid opportunities to contribute to open-source projects, you can check out this paid opportunities. It provides a compilation of open-source projects that offer paid internships and mentorship programs.

Overall, contributing to open-source projects can be a great way to build skills, network with other professionals, and explore career opportunities in the tech industry.

Mid-Point Project Progress: Reflecting on My Outreachy Internship Experience

ORJI CECILIA O. — Fri, 27 Jan 2023 01:11:37 +0000

As an Outreachy intern working on the Tor Browser project, I have reached the mid-point of my internship, and it's been a challenging and rewarding experience so far. For those who may not be familiar, Outreachy is a program that provides internships for underrepresented groups in technology, including women, people of color, and members of the LGBTQ+ community.

When I first applied for the program, I had no experience with open-source development and was nervous about my ability to contribute to such a high-profile project. However, with the support of my mentors, the Tor Browser community, the Outreachy Community Administrators (Omotola, Sage, and Anna), and the other Outreachy interns, I have been able to make meaningful contributions to the project, improve my technical skills, and Interpersonal skills.

My main project for the internship is to extend GetTor, a service that allows users to download the Tor Browser on censored networks over instant messaging and social media platforms. This involves working with a variety of technologies, including Golang, WhatsApp API, writing tests, and so on.

One of the biggest challenges I've faced so far is understanding the codebase and development process of the Tor Browser. As someone who is new to open-source development, it can be overwhelming to navigate a large and complex codebase. However, by asking questions and seeking help from my mentor and the community, I have been able to gain a better understanding of the project and make progress on my task.

Another challenge I've faced is dealing with the uncertainty and ambiguity that comes with working on an open-source project. In a traditional work setting, there are often clear expectations and deadlines, but in open-source development, things can be more fluid. This can be frustrating at times, but it has also taught me the importance of communication, flexibility, and patience.

Despite these challenges, I have also had many positive experiences during my internship. One of the most rewarding aspects has been seeing my contributions merge into the main codebase and knowing that they will be used by real users to access the internet safely and anonymously.

Additionally, I have had the opportunity to learn from and collaborate with a diverse group of people from all over the world. The Tor Browser community is a welcoming and supportive group, and it has been a privilege to be a part of it.

As I move into the second half of my internship, I am looking forward to continuing my work on GetTor and exploring other areas of the project. I am also excited to continue learning and growing as a developer and open-source contributor. I would like to thank my mentor(Meskio) and the project manager(Gaba), the Tor Browser community, and the Outreachy program for giving me this opportunity and supporting me along the way.

In conclusion, My mid-point experience has been a challenging but rewarding one. I have faced many obstacles, but with the support of my mentors, and the Tor Browser community, I have been able to make meaningful contributions to the project and improve my technical skills. I am excited to see what the next half of my internship holds and I am looking forward to continuing my work on GetTor and exploring other areas of the project.

"Think About Your Audience" [Extend Gettor Browser]

ORJI CECILIA O. — Fri, 06 Jan 2023 12:55:59 +0000

My audience in this case refers to you reading this blog post about the Tor browser. In this post, I want to break down some terms that were difficult for me to understand when I joined the project newly and this is me putting myself in your shoes.

What is Tor Browser?

TorBrowser is often used to access censored content, and because of that some countries or network operators block access to the downloads in torproject.org. A mechanism we have to avoid those blocks is GetTor:gettor browser. The Tor Browser is a free open-source internet anonymity tool created as a response to online censorship. By sending your data through a network of volunteer servers, it hides your IP from the destination server and hides the destination server IP from your ISP. As a result, the Tor browser is a great tool to unblock sites.

What is a censor?

According to vocabulary.com, To "censor" is to review something and to choose to remove or hide parts of it that are considered unacceptable. Censorship is the name for the process or idea of keeping things like obscene words or graphic images from an audience. There is also such a thing as self-censorship, which is when you refrain from saying certain things — or possibly re-wording them — depending on who is listening. Internet censorship is the legal control or suppression of what can be accessed, published, or viewed on the Internet. Censorship is most often applied to specific internet domains (such as Wikipedia.org) but exceptionally may extend to all Internet resources located outside the jurisdiction of the censoring state.

Censored content can be measured using OONI (Open Observatory of Network Interference). You can install the OONI Probe on a mobile device or desktop.

What I am contributing to

My team [#tor-anticensorship] works to extend GetTor to distribute TorBrowser on other IM and social media (like Twitter, iMessage, or WhatsApp). My first task included extending Gettor either on WhatsApp or on Twitter. I choose WhatsApp cause I am from Nigeria and here we have a lot of demography using Whatsapp cause of its simplicity. Currently, I created a dummy WhatsApp bot which will be used to extend gettor to share links over WhatsApp.

Here are once again some of the key terms you should be familiar with:

Censorship: The act of suppressing or prohibiting the free expression of ideas, thoughts, or information. In the context of the Tor browser, censorship can refer to the efforts of governments or other organizations to block access to certain websites or restrict the ability of users to communicate freely online.
Anonymity: The state of being unidentified or unknown. In the context of the Tor browser, anonymity refers to the ability of users to protect their online identity and activities from being traced or monitored.
Encryption: The process of converting data into a form that is unreadable without a special key or password. Encryption is used to protect the privacy and security of online communications, including those made through the Tor browser.
Onion routing: A technique for anonymous communication over a computer network, in which messages are passed through multiple layers of encryption to hide the identity of the sender and recipient. Onion routing is used by the Tor network to protect the privacy of its users.
Exit node: A computer on the Tor network that forwards traffic from the network to the regular Internet. Exit nodes play a critical role in the anonymity of the Tor network, as they are the last point at which the traffic is encrypted and can be traced back to the user.

Conclusion

By understanding these terms and concepts, you will be better equipped to navigate the technical challenges of working on the Tor browser and contribute to the development of a powerful tool for online privacy and freedom of expression.

PS: Kindly drop a comment in the comment box if you need clarification on anything relating to the Tor browser.

"Everybody struggles"

ORJI CECILIA O. — Sat, 24 Dec 2022 16:57:29 +0000

I am an Outreachy intern (3 weeks now, wow!) working on the Tor Browser, a free and open-source software project that allows users to browse the internet anonymously but particularly to Extend GetTor to distribute TorBrowser on censored networks over IM and social media. I have come to realize that everyone struggles at some point in their career. No matter how skilled or experienced you are, there will always be challenges and obstacles that you need to overcome. Moreso, for someone just starting out professionally, the feeling of inadequacy is extremely poignant.

What are my struggles?

So... my struggle initially when I came on the project was running the codebase but what helped me a lot is asking questions, then came the problem of understanding the entire codebase and what is happening which if I am been sincere I still do not totally know what is happening but I just focus on what I am working on what is happening there.

As an intern, I have struggled with understanding complex technical concepts(I use Google most time) and getting up to speed on the project's development process. These struggles are natural and are a part of the learning and growth process as I have been told during the live chats on the Outreachy community channel.

One thing that has helped me to cope with these struggles is to remember that I am not alone. Every developer, no matter their level of expertise, goes through similar struggles. It's important to seek out support from colleagues and mentors (of which my mentor "meskio" and the other community members have been of immense help) and to remember that it's okay to ask for help.

Another thing that is helping me to overcome my struggles is keeping an open mind and a positive attitude. It's easy to get discouraged when things don't go as planned, but it's important to stay focused and to keep trying. By approaching challenges with a positive attitude, I have been able to find solutions and make progress in my work.

What's Next?

Despite the challenges that I have faced, I am learning a lot during my time as an intern with the Tor Browser, and I am grateful for the opportunity to be a part of this amazing open-source project. I hope that by sharing my experiences, I can encourage others to embrace their struggles and to keep pushing forward, no matter how difficult things may seem.

As I continue to work on the Tor Browser, I am looking forward to learning even more and contributing to the project in meaningful ways. I am excited to see where my journey as an intern takes me and to see what the future holds for me in the world of open-source software development.

Introducing Cecilia

ORJI CECILIA O. — Fri, 09 Dec 2022 11:18:08 +0000

A bit about myself

My name is Orji Cecilia Olanma, a graduate of the University of Lagos Nigeria and, studied Geography and Planning. I got introduced to Programming by one of my best friend Azuma Margret. I remember returning back from Youth Service and I had gone to her place, she just got accepted to Andela and she was gisting me about it and the opportunities one can get as a Software Developer.

I attended a 4 weeks Bootcamp with She Hacks Africa under the WAAW (Working to Advance STEM Education for African Women) Foundation where I learned HTML5, CSS3, JavaScript, and a little bit of Nodejs. I went to work with OPAy as a customer support agent for almost 3 years but while working I continued learning and enrolled in some virtual internships like start.ng, HNG, DevCareer and Progate, Zuri & Ingressive 4 Good. I applied to Decagon and got accepted in January 2022 so I had to leave my job and face it fully. At Decagon, I focused on Golang and React.js but I am more backend-heavy.

My areas of interest include web3, Blockchain, Open-source contribution, and Cloud Computing.

My core values

3 major core values important to me are;

Community: This is because this represents family, a support system. Family is an institution that matters very much to me. I believe that your family can never put you away. Development in society starts from the unit called family. Our world will become a better place if every family takes responsibility for the individuals that form a part of it. The support that a family gives cannot be underestimated. This support goes a long way in creating mental structures that motivates you to become whatever you want to be. This support also often translates to an undiluted belief in your capabilities, which gives is comforting to know that there are people who are ready to do their best to ensure your success.
Kindness: According to the Oxford dictionary, It is " the quality of being friendly, generous, and considerate". I believe if we all can be just a little bit kind to our neighbors the world will be a better place. We already have a lot going on in the world (Climate change, floods, drought, eruptions, etc).
Service: I believe in service and giving back to society. This quote by Albert Einstein:

"It is every man’s obligation to put back into the world at least, an equivalent of what he takes out of it"

is my mantra and motivation for giving back to the community, and for affecting the lives of girls through active empowerment.

What motivated me to apply to Outreachy
Hmmm... It was cause I have always been interested in contributing to Open-source projects and remember one of my core values listed above is service and giving back after receiving so much from the earth and people in general.

I got introduced by a friend to Outreachy and I remember adding my mail to the mailing list and waiting for the next application. I applied, passed to the contribution stage, and chose

Tor Project ( Extend GetTor to distribute TorBrowser on censored networks over IM and social media) as the project I want to contribute to as it aligns with my values. I made my first contribution and the merging of my pull request gave me immense joy. Eventually, I got accepted as an Outreachy intern!