DEV Community: Azeez Abidoye

5 Important Logics to Understand About Liquidity Book Pair

Azeez Abidoye — Wed, 15 Apr 2026 22:59:21 +0000

Introduction: Trader Joe

Trader Joe is a decentralized exchange (DEX) and DeFi protocol built on the Avalanche. It combines automated market maker technology with lending, staking, and launchpad features, making it one of the most comprehensive decentralized finance platforms within the Avalanche ecosystem. Launched in 2021, Trader Joe is notable for its innovative “Liquidity Book” model and cross-chain expansion.

However, a Liquidity Book (LB) Pair is an advanced Automated Market Maker (AMM) design used by Trader Joe, this tutorial focuses on the key logics Liquidity Providers (LP) have to understand to enjoy seamless and profitable trade.

1. Architectural Overview

At its core, LBPair.sol is the engine that powers Trader Joe V2, also known as the "Liquidity Book." Unlike typical automated market makers (AMMs) such as Uniswap V2, which distribute liquidity marginally across a continuous curve equation, the Liquidity Book utilizes Discrete Bins.

Imagine an array of numerous little buckets, each representing a specific, fixed price. Individual buckets (bins) are used by liquidity providers (LPs) to store tokens. When traders swap tokens, they buy or sell from these buckets one at a time.The active bucket determines the current exact pricing.

Role in the System:
LBPair.sol manages the reserves of two tokens (Token X and Token Y) for a specific trading pair. It processes swaps, calculates dynamic fees based on market volatility, mints LP tokens to represent liquidity within certain price bins, and facilitates flash loans.

Code Walkthrough

You can find the complete implementation of LBPair.sol in this GitHub repository.

Take some time to explore the codebase for a deeper understanding, and feel free to contribute — your improvements and insights are welcome.

Let's break down the LBPair.sol contract logically:

Contract Declaration & Modifiers

Inheritance:

contract LBPair is LBToken, ReentrancyGuardUpgradeable, Clone, ILBPair {
    // contract logics...
}

The contract inherits multi-token functionality (LBToken), security features against re-entrancy (ReentrancyGuardUpgradeable),proxy-like deployability (Clone), and implements the interfaces mapping out its functions (ILBPair).

onlyFactory: A modifier restricting certain setup actions (like initialization) strictly to the core Factory contract that created this pair.
onlyProtocolFeeRecipient: Ensures only the protocol's designated fee wallet can collect platform-level fees.

State Variables (The Storage)

The contract groups its data efficiently to save gas:

_parameters: A tightly packed variable that stores the active bin ID, fee configurations, and volatility trackers all in one location.
_reserves & _protocolFees: Track the total available tokens actively sitting in the contract.
_bins: A mapping structure in which each numeric ID corresponds to a specific "bucket" containing the reserves for Token X and Token Y at the specified price.
_tree: A specialized binary tree data structure for quickly locating the next liquid bin (jumping over empty bins quickly).
_oracle: Keeps track of previous price and volatility data to inform the dynamic fee system and stop price manipulation.

Core Functions

initialize: Runs once upon creation to set the base fees and the starting active price bin (activeId).
View Functions (getReserves, getActiveId, getBin, etc.): These serve as read-only windows, allowing you to monitor the quantities and parameters of the pools without paying gas.
getSwapIn & getSwapOut: Simulates trades so that users and front-end interfaces may see exactly how many tokens they will receive or spend before they click confirm.
swap: The trading engine. It iterates through the bins, taking tokens from the user and sending back the swapped tokens. It recalculates fees defensively based on current market volatility during the swap.
flashLoan: Allows users to borrow funds without collateral under the strict condition that they repay the funds (plus a fee) at the end of the same transaction.
mint: Allows LPs to deposit Token X and Token Y into specific bins. In return, the pair contract gives them LP tokens reflecting their share in those exact bins.
burn: The reverse of mint. Users burn their LP tokens to retrieve their underlying Token X, Token Y, and any earned trading fees.

Imports and Dependencies

LBPair.sol contract relies on a large web of supportive files:

OpenZeppelin Contracts

IERC20.sol: The standard interface for ERC-20 tokens, ensuring LBPair can safely interact with any standard token deposited into it.

Custom Interfaces

ILBFactory, ILBFlashLoanCallback, ILBHooks, etc.: Interfaces serves as blueprints defining "what" functions exist in other sections of the protocol without specifying "how" they work. It ensures that LBPair.sol works correctly with external components, such as the Factory (which creates pairs) and external Hook plugins.

Custom Libraries (Math & Logic)

Due to Ethereum's stringent restriction on contract size, a large portion of the complicated arithmetic and logic is outsourced to libraries.

Math Libraries (PackedUint128Math, SafeCast, TreeMath, etc.): Highly optimized formulae for computing precise bin prices, putting numerous small numbers into one storage slot to save gas, and navigating empty vs. filled bins efficiently.
FeeHelper & PairParameterHelper: Manage the dynamic fee logic, which naturally increases trading fees during periods of high volatility to protect LPs from temporary losses.
OracleHelper: Manages time-weighted price/volume data securely.
ReentrancyGuardUpgradeable: A critical security layer ensuring a function cannot be interrupted and called again maliciously before it finishes.

2. `LBToken` & `ILBToken` Integration

The Problem: Traditional LPs receive a single type of token that represents their share of the pool. Liquidity Book allows LPs to spread liquidity over multiple pricing bins at the same time. It would be hard to create a standard ERC-20 token with thousands of potential bins.

The Solution: An ERC-1155 style "Multi-Token."

Roles & Interaction

ILBToken.sol: This is the interface blueprint. It defines the events and functions (like balanceOf, batchTransferFrom, approveForAll) that a multi-token contract must have.
LBToken.sol: This abstract contract builds the actual logic defined by ILBToken. It links user balances to multiple token IDs (representing bins).
Integration: Unlike a standard ERC-1155 token which triggers an external function call on the receiver's end (posing a security and re-entrancy risk), LBToken.sol strips this risky feature out for safety and speed. LBPair natively inherits LBToken. This means LBPair is the token contract. When you mint liquidity into LBPair, the LBPair directly updates your token ID balances in its own internal ledger.

3. Core Logic and Use Cases

Dynamic Fees: If the market is extraordinarily volatile, typical AMMs expose LPs to arbitrage ("temporary loss"). LBPair monitors this volatility.

Use Case: During massive price swings, an LP that pairs a volatile asset (like as ETH) against a stablecoin significantly earns much higher trading fees.

Concentrated Liquidity: LPs put their money exactly where they want.

Use Case: A market maker anticipates a stablecoin pair (e.g., USDC/USDT) to stay exclusively around $1.00. They can deposit all of their money strictly in the $0.999, $1.000, and $1.001 bins and earn huge profits on sideways trading.

Zero-Slippage Swaps (swap): Because a single bin represents a fixed price, trades happening entirely inside that bin suffer absolutely zero slippage. You get exactly what the bin advertises until the bin is empty.

4. Security Review

Reentrancy: Since LBPair handles arbitrary ERC-20 tokens (some of which can execute nasty hidden code), the contract utilizes _nonReentrantBefore() and _nonReentrantAfter(). This completely locks the contract during execution, protecting it from re-entrancy attacks.
Hook Vulnerabilities: Trader Joe V2 introduced "Hooks" (plugins injected before/after swaps and mints). If a pool creator attaches a malicious or poorly-coded Hook, it could freeze user access or break swaps.
Flashloan Security: The flashLoan function relies on exactly verifying a returned success value. If external callbacks deviate from requirements, transactions revert, protecting the pool.
Oracle Manipulation: OracleHelper defends against flash-loan price manipulation by using time-weighted, block-delayed snapshots. However, developers must always ensure they fetch long-term averaged data rather than instantaneous snapshots to remain safe.

5. Real-World Context

Decentralized Finance (DeFi) has grown into a pursuit of capital efficiency.
Older AMM models expanded liquidity from $0 to infinity. As a result, 99% of the deposited capital is never used to generate daily trading volume. Trader Joe's Liquidity Book is a direct competitor to Uniswap V3's concentrated liquidity model, aiming to be superior by using vertical pricing "bins" rather than horizontal "ticks".

The Liquidity Book architecture ensures zero-slippage executions within brackets and includes an innovative dynamic fee engine. Developers will find it considerably easier to stack LP positions inside other yield farms when they are stored as natively fungible multi-tokens (LBToken) rather than non-fungible (NFT) positions in Uniswap V3.

Conclusion

LBPair.sol bridges the gap between traditional order-book precision and Automated Market Maker decentralization. A strong ecosystem is created by combining discrete price bins, a customized multi-token representation for liquidity providers, and dynamic volatility-based fees. It provides good, predictable pricing to everyday traders while actively protecting Liquidity Providers, making it one of the most sophisticated and efficient trading engines on modern blockchain networks.

Build Your First FHE Smart Contract with Fhenix: A Hands-On Beginner's Guide

Azeez Abidoye — Mon, 06 Apr 2026 15:48:17 +0000

Gm Devs 🤗

Welcome to this beginner-friendly tutorial on smart contract using FHE (Fully Homomorphic Encryption). This guide will help you understand how encrypted variables and operations work in Solidity.

What is FHE (Fully Homomorphic Encryption)?

Fully Homomorphic Encryption (FHE) is a cryptographic breakthrough that allows computations to be performed on encrypted data without decrypting it first. In traditional smart contracts, all data is public. Even private variables are visible on the blockchain. With FHE, the data remains encrypted at all times during computation, enabling privacy-preserving applications simultaneously with smart contract transparency.

For a beginner: Imagine a locked opaque box with arm holes. You can stick your hands in the holes and manipulate objects inside the box, but you can't tell what the objects look like, and nobody else can see them either. The contents remain secure, yet you can still work with them.

In this contract, we use FHE to keep our counter values entirely secret, demonstrating how to handle sensitive user data on the blockchain.

Prerequisites 🛠️

NodeJs (v20 or later)
PNPM (recommended)
MetaMask
Testnet Ethers
Fundamental knowledge of Solidity & Hardhat

Let the hacking begin... 👨‍💻

Step 1: Initialize the FHE project & navigate into the new project directory

git clone https://github.com/fhenixprotocol/cofhe-hardhat-starter.git
cd cofhe-hardhat-starter

Step 2: Install dependencies

pnpm install

Folder Structure 📚

Contracts: This directory contains all of your project's smart contract files. It currently contains a Counter.sol smart contract written in Solidity.
deployments: Structured to save the contract address after deployment. Though currently empty, the json file with the contract address will automatically save in this directory after deployment.
tasks: The directory includes five Typescript files with various configurations and execution logics:
- deploy-counter.ts: Contains all of the logic run for the successful deployment of the Solidity smart contract.
- increment-counter.ts: Contains the code executed to interact with the deployed contract by calling the increment() function.
- index.ts: This is the configuration file that exports all written contract interaction logics.
- reset-counter.ts: Contains the code executed to interact with the deployed contract using the reset() function
- utils.ts: Utility file containing code logic that generates a new file automatically after contract deployment to save deployment information in the ./deployments directory
test: Contract test files are saved in this directory, which currently contains the Counter.test.ts file.
- Counter.test.ts: Contains all of the test logics for the solidity smart contract.

Code Walkthrough: Line by Line 🔍

Let's break down the Counter.sol contract to see how it operates.

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

Line 1: Declares the software license (UNLICENSED means it isn't licensed for general public distribution).
Line 2: Defines the required Solidity compiler version (^0.8.25), meaning any version starting from 0.8.25 up to 0.8.99 will work.

import "@fhenixprotocol/cofhe-contracts/FHE.sol";

Line 4: Imports the FHE library from the Fhenix protocol. This library provides all the specialized tools to create, manipulate, and decrypt encrypted values safely on the blockchain.

contract Counter {

Line 6: Begins the declaration of our smart contract named Counter.

    euint32 public count;
    euint32 public ONE;
    ebool public isInitialized;

Lines 7-9: We declare our state variables. Instead of the standard uint32 or bool, we use euint32 (encrypted unsigned integer of 32 bits) and ebool (encrypted boolean). These variables store encrypted data directly on the blockchain.
- count: Stores the encrypted current count.
- ONE: Stores an encrypted value of 1, to be used in math operations.
- isInitialized: A flag to keep track of if our contract has been set up.

    constructor() {
        ONE = FHE.asEuint32(1);
        count = FHE.asEuint32(0);

Lines 11-13: Contains the constructor function, which runs only once upon deployment. We assign encrypted values to our state variables using FHE.asEuint32(). This securely encrypts 1 into ONE and 0 into count.

        isInitialized = FHE.asEbool(false);
        isInitialized = FHE.asEbool(true);

Lines 15-16: Initializes the isInitialized boolean securely.

        FHE.allowThis(count);
        FHE.allowThis(ONE);

Lines 18-19: Grants the smart contract itself the permission to use and access the encrypted values count and ONE. Managing viewing rights is crucial for FHE!

        FHE.gte(count, ONE);

Line 21: Performs an encrypted "Greater Than or Equal to" (>=) comparison between count and ONE. This line is generally used during test deployments to ensure the FHE comparison coprocessor is running healthily.

        FHE.allowSender(count);
    }

Lines 23-24: Grants the deployer of the contract permissions to view the count variable and closes the constructor.

    function increment() public {
        count = FHE.add(count, ONE);
        FHE.allowThis(count);
        FHE.allowSender(count);
    }

Lines 26-30: A public function increment() that anyone can call. Instead of standard Solidity additions like count++, it uses FHE.add(count, ONE) to securely add the encrypted variables. It then updates permissions using allowThis and allowSender over the new encrypted result.

✍️ Practical Use Case: Imagine updating user voting tallies secretly without revealing individual votes.

    function decrement() public {
        count = FHE.sub(count, ONE);
        FHE.allowThis(count);
        FHE.allowSender(count);
    }

Lines 32-36: A public function decrement(). It uses FHE.sub() to securely subtract the encrypted ONE from count, and re-assigns permissions exactly like the increment() function.

    function reset(InEuint32 memory value) public {
        count = FHE.asEuint32(value);
        FHE.allowThis(count);
        FHE.allowSender(count);
    }

Lines 38-42: A public function reset(). It takes a special parameter InEuint32 value (an incoming encrypted number passed directly by a user). It casts this to a persistent encrypted value count = FHE.asEuint32(value) and updates access permissions for it.

✍️ Practical Use Case: A user setting a confidential PIN or private bid in an auction without exposing their true number on the live network.

    function decryptCounter() public {
        FHE.decrypt(count);
    }

Lines 44-46: Initiates the decryption process for our encrypted count. For security and computational reasons, actual network decryption is often an asynchronous process in FHE-based blockchains.

    function getDecryptedValue() external view returns(uint256) {
        (uint256 value, bool decrypted) = FHE.getDecryptResultSafe(count);
        if (!decrypted)
            revert("Value is not ready");

        return value;
    }
}

Lines 48-55: Closes our contract. A function to finally read the decrypted result. It uses FHE.getDecryptResultSafe(count) which returns the plain integer value and a boolean decrypted indicating if the asynchronous decryption process initiated earlier is finished. If it's not ready, it reverts with an error message.

Comparison: FHE vs. Standard Boilerplate 📝

If you are coming from standard development environments like Foundry, you may be familiar with the default Counter.sol boilerplate code:

Standard Boilerplate:

contract Counter {
    uint256 public number;

    function setNumber(uint256 newNumber) public { number = newNumber; }
    function increment() public { number++; }
}

Here's an analysis of the key structural, functional, and architectural differences compared to our FHE Counter:

1. Variables and Data Structure

Standard: Uses uint256 which is an entirely public data type. Anyone auditing the blockchain can see its exact value.
FHE Counter: Uses euint32 and ebool. These variables are homomorphically encrypted. Their real values are strictly hidden, and the state stored on-chain relies primarily on ciphertexts rather than plain numbers.

2. Performing Math (Functional Differences)

Standard: You can use native Solidity operators like number++ or number + 1.
FHE Counter: Because data is heavily encrypted, standard EVM commands won't work on them. We must instead use FHE library functions like FHE.add(count, ONE) and FHE.sub(count, ONE). This functionally routes the math to an encrypted state coprocessor.

3. Permissions Structure

Standard: Security is primarily established on deciding who can call specific state-changing methods. (e.g. require(msg.sender == owner)).
FHE Counter: You must now explicitly manage Data Access Rights. Whenever a secure variable is interacted with, the Counter re-establishes who can actually read the new encrypted wrapper via FHE.allowThis(count) and FHE.allowSender(count).

4. Reading Storage (Decryption Architecture)

Standard: You quickly write a view function or use auto-generated getters like counter.number() to fetch current variable numbers efficiently and instantly.
FHE Counter: Exposing data safely requires deliberate multi-step intention. Functioning safely with FHE means first triggering a rigorous on-chain decryption process (decryptCounter), and subsequently retrieving the resulting answers once finished (getDecryptedValue).

Why These Differences Exist & Implications

These changes heavily exist because Fhenix brings off-chain-like computing privacy onto a public architecture. Instead of all validator nodes directly calculating plain logic streams, specialized operations are routed to FHE coprocessors carefully integrated alongside the core EVM.

The primary implication for developers is a major shift in coding mindset: As a programmer, you must now safely and proactively manage data visibility. This paradigm slightly raises code complexity but fundamentally unlocks completely new architectural possibilities such as; private DAOs, confidential NFT bids, and unseen trading executions that were simply never possible on public chains before.

Step 3: Compile the contract

pnpm compile

The compilation's output should look like this::

> hardhat compile

Generating typings for: 18 artifacts in dir: typechain-types for target: ethers-v6
Successfully generated 34 typings!
Compiled 8 Solidity files successfully (evm target: cancun).

Step 4: Test with Mock Environment

pnpm test

Step 5: Configure test network

By default, @cofhe/hardhat-plugin in the hardhat.config.ts file automatically injects FHE-compatible networks.
For this tutorial, we will deploy the contract on the Ethereum-Sepolia test network, with the following configuration:

// some config code here...

defaultNetwork: 'hardhat',
    // defaultNetwork: 'localcofhe',
    networks: {
        // The plugin already provides localcofhe configuration

        // Sepolia testnet configuration
        'eth-sepolia': {
            url: process.env.SEPOLIA_RPC_URL || 'https://ethereum-sepolia.publicnode.com',
            accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [],
            chainId: 11155111,
            gasMultiplier: 1.2,
            timeout: 60000,
            httpHeaders: {},
        },

        // other network config here...
    },

Step 6: Setup environment variables

In the root folder, create a new file named .env, this file contains the environment variables required to run the contract deployment.

touch .env

Save your environment variables in the .env file as follows:

PRIVATE_KEY=your_private_key_here
SEPOLIA_RPC_URL=your_sepolia_rpc_url

Step 7: Deploying the contract

In this tutorial, we will deploy on the eth-sepolia network using the following command.

pnpm eth-sepolia:deploy-counter

✍️ The command above is a combination of the CLI command pnpm, the network of choice as specified in the hardhat.config.ts file, and the logic provided in the ./tasks/deploy-counter.ts file.

The successful deployment should produce the following results:

> hardhat deploy-counter --network eth-sepolia

Deploying Counter to eth-sepolia...
Deploying with account: 0xCD30EA918A09FbdCB7421f5227d5eEB97fDDC25c
Counter deployed to: 0x0ccb4863881Bc1914DDDe6cEa0e8ab903073EB50
Deployment saved to /Users/azeezabidoyemac/Desktop/cofhe-hardhat-starter/deployments/eth-sepolia.json

Yipee...Congratulations 🎉 You have successfully deployed your FHE contract!

✍️ The contract address is automatically provided in a new file named eth-sepolia.json saved in the ./deployments directory, which was previously empty.

Interacting with the contract

Execute the following command to call the increment() function provided in the contract

pnpm eth-sepolia:increment-counter

The output should be as follows:

// > hardhat increment-counter --network eth-sepolia

Using Counter at 0x0ccb4863881Bc1914DDDe6cEa0e8ab903073EB50 on eth-sepolia
Using account: 0xCD30EA918A09FbdCB7421f5227d5eEB97fDDC25c
Current count: 0x62e83fbfdb28600fc2055640374222e623c6707f29b7ac7f3758fc56bcf08400
Incrementing counter...
Transaction hash: 0x252a28051b8d33bbc45761fb1bd6fffd7864f91c3ca2762c5d9e7dafef9253c4
New count: 0xf4b982aeb531d1c2fdeb3f64b030656a02036cc6ca7d2155bf4a8e927b210400
Unsealing new count...
1n

✍️ The command above is a combination of the CLI command pnpm, the network of choice as specified in the hardhat.config.ts file, and the logic provided in the ./tasks/increment-counter.ts file.

Execute the following command to call the reset() function provided in the contract. This resets the count back to the initial value of zero

pnpm eth-sepolia:reset-counter

The output should be as follows:

> hardhat reset-counter --network eth-sepolia

Using Counter at 0x0ccb4863881Bc1914DDDe6cEa0e8ab903073EB50 on eth-sepolia
Using account: 0xCD30EA918A09FbdCB7421f5227d5eEB97fDDC25c
Resetting counter...
Transaction hash: 0xe9eeaba8ad045e58ddf992796c54fefc12accf7f5337ce778654ee2747664eea
New count: 0xa1d49b27cccc811029b4874ad8866f8f2682b540729936a7481a79d069220400

Conclusion

This tutorial explained the basics of Fully Homomorphic Encryption (FHE) and how writing Solidity smart contracts changes when you account for encrypted data. It walked through the starter kit step by step to show how FHE-enabled contracts handle variables, encryption, and decryption differently from standard smart contracts. It also covered the key steps needed to successfully deploy an FHE smart contract, helping you avoid common mistakes along the way.

As you continue building, start thinking about how to protect user data on-chain. Explore and use the Fhenix Coprocessor (CoFHE), visit www.fhenix.io to build applications that prioritize privacy while shaping the future of Web3.

The Complete Guide to Solidity Inheritance

Azeez Abidoye — Sat, 14 Feb 2026 20:30:38 +0000

If you're new to blockchain development, understanding inheritance in Solidity will make your smart contracts less complicated, more efficient, and easier to maintain. Let's break down this fundamental concept in a way that makes sense, even if you're completely new to it.

What is solidity?

Solidity is the primary programming language used to create smart contracts for the Ethereum blockchain and other compatible networks. Consider it the language that enables blockchain applications, such as decentralized finance (DeFi) protocols and NFT marketplaces. Smart contracts are self-executing programs that automatically enforce agreements without the need for intermediaries, and developers use Solidity to create them.

What Does Inheritance Mean?

Inheritance is a programming technique that enables you to generate a new contract from an existing one. Assume you're developing a variety of vehicles, including automobiles, trucks, and motorcycles. Instead of implementing the code for wheels, motors, and steering from scratch for each vehicle, you could create a base "Vehicle" layout and have each unique type inherit those shared elements.

In Solidity, inheritance works the same way. You can create a parent contract with common functionality, then create child contracts that inherit everything from the parent while adding their own unique features. This approach is powerful because:

Code Reusability: Write once, use many times
Easier Maintenance: Fix a bug in the parent contract, and all children will benefit
Accurate Organization: Keep related functionality grouped logically
Reduced Errors: Less code duplication lowers the possibilities of errors

How Inheritance Works in Solidity

In Solidity, when one contract inherits from another, it acquires access to all of the parent contract's functions, variables, and modifiers. The child contract can use the inherited features as if they were written in its own code.

Let's look at a simple example:

// Parent contract
contract Animal {
    string public name;

    constructor(string memory _name) {
        name = _name;
    }

    function speak() public pure virtual returns (string memory) {
        return "Some generic animal sound";
    }
}

// Child contract inheriting from Animal
contract Dog is Animal {
    constructor(string memory _name) Animal(_name) {}

    function speak() public pure override returns (string memory) {
        return "Woof! Woof!";
    }
}

In this example, Dog inherits from Animal using the is keyword. The Dog contract automatically has access to the name variable from Animal, but it customizes the speak() function to return a dog-specific sound.

Understanding Function Overriding.

Function overriding occurs when a child contract defines its own implementation of a function that already exists in the parent contract. This is incredibly helpful when you want to maintain the same function structure while changing the behaviour for specific instances.

Here's where the virtual and override keywords come into play:

virtual: Added to a function in the parent contract to indicate it can be overridden by child contracts
override: Added to a function in the child contract to indicate it's replacing the implementation of the parent contract

Think of virtual as the parent saying, "You can change this if you need to," and override as the child saying, "Thanks, I'm changing it."

contract BankAccount {
    uint256 public balance;

    constructor(uint256 initialBalance) {
        balance = initialBalance;
    }

    // Virtual function - can be overridden
    function withdraw(uint256 amount) public virtual {
        require(amount <= balance, "Insufficient funds");
        balance -= amount;
    }
}

contract PremiumBankAccount is BankAccount {
    uint256 public bonusPoints;

    constructor(uint256 initialBalance) BankAccount(initialBalance) {
        bonusPoints = 0;
    }

    // Override the withdraw function to add bonus points
    function withdraw(uint256 amount) public override {
        require(amount <= balance, "Insufficient funds");
        balance -= amount;
        bonusPoints += amount / 100; // Earn 1 point per 100 withdrawn
    }
}

In this example, PremiumBankAccount inherits the basic functionality of BankAccount but overrides the withdraw function to add a bonus points system. The child contract maintains the same basic logic but extends it with additional features.

Practical Real-World Use Cases

1. Token Standards
One of the most common applications of inheritance in Solidity is the implementation of token standards. The ERC-20 standard defines a basic token interface, and developers create their own tokens by inheriting from the base ERC-20 implementation.

// Simplified base ERC-20 contract
contract ERC20 {
    mapping(address => uint256) public balanceOf;

    function transfer(address to, uint256 amount) public virtual returns (bool) {
        require(balanceOf[msg.sender] >= amount, "Insufficient balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

// Custom token with added features
contract RewardToken is ERC20 {
    mapping(address => uint256) public stakingRewards;

    // Add custom functionality specific to this token
    function claimRewards() public {
        uint256 reward = stakingRewards[msg.sender];
        stakingRewards[msg.sender] = 0;
        balanceOf[msg.sender] += reward;
    }
}

2. Access Control Systems
Inheritance is perfect for building access control systems where different contracts need different permission levels:

contract Ownable {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Not the owner");
        _;
    }
}

contract Marketplace is Ownable {
    uint256 public platformFee;

    // Only owner can set the fee
    function setPlatformFee(uint256 newFee) public onlyOwner {
        platformFee = newFee;
    }
}

3. Pausable Contracts
Many smart contracts need emergency stop functionality. Inheritance makes this pattern reusable:

contract Pausable {
    bool public paused;

    modifier whenNotPaused() {
        require(!paused, "Contract is paused");
        _;
    }

    function pause() internal virtual {
        paused = true;
    }
}

contract TokenSale is Pausable {
    function buyTokens() public whenNotPaused {
        // Token purchase logic here
    }
}

Common Mistakes and How to Avoid them

1. Forgetting the virtual and override keywords
A common beginner mistake is attempting to override a function without first declaring the parent function as virtual, or failing to use override in the child contract. Solidity will return a compilation error if you miss these terms, which is really helpful because it drives you to be precise about your goals.

Wrong:

contract Parent {
    function getValue() public pure returns (uint) {
        return 10;
    }
}

contract Child is Parent {
    function getValue() public pure returns (uint) {
        return 20;
    }
}
// This will not compile!

Correct:

contract Parent {
    function getValue() public pure virtual returns (uint) {
        return 10;
    }
}

contract Child is Parent {
    function getValue() public pure override returns (uint) {
        return 20;
    }
}

2. Not Calling Parent Constructors Properly
When your child contract's constructor needs to initialize the parent contract, you must explicitly call the parent's constructor:

contract Token {
    string public name;

    constructor(string memory _name) {
        name = _name;
    }
}

// Correct way to call parent constructor
contract CustomToken is Token {
    constructor(string memory _name) Token(_name) {
        // Additional initialization
    }
}

3. Visibility Issues
Remember that private functions and variables in the parent contract are not accessible to child contracts. Use internal if you want inherited contracts to access these members:

contract Parent {
    uint256 private secretValue;    // NOT accessible to children
    uint256 internal sharedValue;   // Accessible to children
}

Best Practices for Using Inheritance

Keep It Simple: Avoid complex inheritance hierarchies. If you find yourself inheriting from multiple layers of contracts, think about how your design may be simplified.
Use meaningful names: To demonstrate the relationship between your contracts, give them explicit names. Base contracts frequently use names like "Base," "Abstract," or descriptive terms like "Ownable" or "Pausable."
Document your code: Include comments that explain what each contract does and why you choose to use inheritance. In the future, you (and other developers) will enjoy it.
Test thoroughly: When overriding functions, test both the parent and child implementations to ensure that they work properly together.
Consider security: If not handled properly, inheritance can raise security risks. Always audit inherited code and understand what you're getting, especially when using third-party contracts.

Conclusion

In Solidity, inheritance is an efficient tool that allows you to create smart contracts that are easier to maintain. Understanding how to use parent and child contracts, function overriding, and the virtual and override keywords will allow you to better structure your code to avoid repetition.
Begin with simple examples like those in this article, practice overriding functions, and then progress to more sophisticated inheritance patterns. Remember that the goal is not to develop the most complex inheritance tree possible, but to write code that is simple to comprehend, maintain, and secure.
As you progress through your Solidity journey, inheritance will become a natural part of your development workflow, allowing you to construct stronger smart contracts with less code and fewer errors.

[Boost]

Azeez Abidoye — Mon, 14 Jul 2025 15:12:14 +0000

Azeez Abidoye

Jun 26 '25

Optimize Gas Usage and Build Efficient Smart Contracts on CrossFi

#blockchain #web3 #crossfi #hardhat

Comments 4

4 min read

Optimize Gas Usage and Build Efficient Smart Contracts on CrossFi

Azeez Abidoye — Thu, 26 Jun 2025 14:14:24 +0000

What is Gas Optimization? 🤷‍♂️

Optimizing gas in smart contracts means writing Solidity code and structuring contracts in ways that reduce the amount of gas (computation cost) needed to deploy and execute them. Since every transaction or operation on a blockchain requires gas — paid in the network's native token — optimization helps make your applications faster, cheaper, and more scalable.

What It’s Like to Optimize Gas ⚙️

Think of it as performance tuning for the blockchain:

You analyze how your contract reads/writes data.
You replace costly patterns with cheaper alternatives.
You reduce redundancy in logic and storage.
You measure how much gas is used before and after optimizations (with tools like hardhat-gas-reporter or solidity-coverage).

Why CrossFi? 🤔

CrossFi is a blockchain platform built to enable seamless cross-chain asset transfers and decentralized finance (DeFi) applications. With a focus on interoperability, security, and scalability, CrossFi provides developers and users with a powerful ecosystem for deploying decentralized applications (DApps) that can operate across multiple blockchain networks.

Prerequisites 📚

NodeJs
NPM
MetaMask
Testnet Tokens
Coinmarketcap API
CrossFi Alchemy URL

Dev Tools ⚒️

Yarn

npm install yarn -g

Step 1: Create & open project directory

mkdir fundxfi && cd fundxfi

Step 2: Initialize a new project

yarn init -y

Step 3: Install Hardhat package

yarn add hardhat

Step 4: Initialize new Hardhat framework

yarn hardhat init

✍️ Choose JavaScript and install other dependencies

Step 5: Set up ENV

Create a new .env file in the root directory
Populate it with the following variables:

PRIVATE_KEY="insert-private-key-here"
CROSSFI_ALCHEMY_URL="your-crossfi-alchemy-url-here"
CONINMARKET_API_KEY="add-coin-market-cap-api-here"

Install a new package for .env configuration

yarn add dotenv -D

Step 6: [Optional] Delete old files

✍️ To keep a clean slate, delete contracts/Lock.sol and test/lock.js files

Step 7: Configure framework

Rename hardhat.config.js file to hardhat.config.cjs
List and configure all imports

require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();
require("hardhat-gas-reporter");
require("solidity-coverage");

Import environment variables

const { PRIVATE_KEY, CROSSFI_ALCHEMY_URL } = process.env;

Configure network


module.exports = {
  solidity: "0.8.28",
  networks: {
    hardhat: { chainId: 1337 },
    crossfiTestnet: {
      url: CROSSFI_ALCHEMY_URL,
      accounts: [PRIVATE_KEY],
      chainId: 4157,
    },
  },
};

Step 8: Create Solidity smart contract

Navigate to ./contracts directory
Create new FundXFI.sol file
Populate with the following code:
Unoptimized Contract

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

contract FundXFI {
    address public owner;
    uint256 public minimumAmount = 20 * 1e18; // ETH to Wei
    mapping(address => uint256) public addressToAmountFunded;
    mapping(address => bool) private hasFunded;
    address[] private funders;

    constructor() {
        owner = msg.sender;
    }

    function fund() external payable {
        require(msg.value > minimumAmount, "Send some ETH");

        if (!hasFunded[msg.sender]) {
            hasFunded[msg.sender] = true;
            funders.push(msg.sender);
        }

        addressToAmountFunded[msg.sender] += msg.value;
    }

    function withdraw() public onlyOwner {
        uint256 len = funders.length;

        for (uint256 i = 0; i < len; i++) {
            address funder = funders[i];
            addressToAmountFunded[funder] = 0;
            hasFunded[funder] = false;
            unchecked {
                ++i;
            } // Save gas by skipping overflow check
        }

        funders = new address[](0);
        payable(owner).transfer(address(this).balance);
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

    function getFunders() external view returns (address[] memory) {
        return funders;
    }
}

Step 9: Compile Contract

yarn hardhat compile

Result:

Compiled 1 Solidity file successfully (evm target: paris).
✨ Done in 3.15s.

Step 10: Setup Contract for deployment

Create new directory for deployment in the root directory

mkdir scripts

Create new deploy.cjs file in the ./scripts directory
Populate with the following code:

const { ethers } = require("hardhat");

async function main() {
  // Get the contract factory
  const FundXFI = await ethers.getContractFactory("FundXFI");

  console.log("Deploying contract...");
  const fundxfi = await FundXFI.deploy(); // No constructor args needed
  await fundxfi.waitForDeployment();
  const fundxfiAddr = await fundxfi.getAddress();

  console.log(`✅ Contract deployed at: ${fundxfiAddr}`);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error("❌ Deployment failed:", error);
    process.exit(1);
  });

Step 11: Deploy Contract on CrossFi Testnet

yarn hardhat run scripts/deploy.cjs --network crossfiTestnet

Result:

Deploying contract...
✅ Contract deployed at: 0x7bEf72A46D8f0af065fC6Dd96e3048ABC6924E45
✨ Done in 33.35s.

Bonus: 🎁 Gas Optimization Tools

Solidity Coverage:

yarn hardhat coverage

Result:

Version
=======

> solidity-coverage: v0.8.16

# Instrumenting for coverage...

> FundXFI.sol

# Compilation:

Compiled 1 Solidity file successfully (evm target: paris).

# Network Info

> HardhatEVM: v2.25.0
> network: hardhat

0 passing (0ms)

-----------------|----------|----------|----------|----------|----------------|
File | % Stmts | % Branch | % Funcs | % Lines |Uncovered Lines |
-----------------|----------|----------|----------|----------|----------------|
contracts/ | 0 | 0 | 0 | 0 | |
FundXFI.sol | 0 | 0 | 0 | 0 |... 41,45,46,50 |
-----------------|----------|----------|----------|----------|----------------|
All files | 0 | 0 | 0 | 0 | |
-----------------|----------|----------|----------|----------|----------------|

> Istanbul reports written to ./coverage/ and ./coverage.json
> ✨ Done in 5.33s.

Hardhat Gas Reporter:

✍️ See documentation for more guidance

Get API Key and update variable in the .env file
Import API key in the hardhat.config.cjs file

const { PRIVATE_KEY, CROSSFI_ALCHEMY_URL, CONINMARKET_API_KEY } = process.env;

Update config as follows:

module.exports = {
  // networks...
    gasReporter: {
      enabled: true,
      currency: "USD",
      coinmarketcap: COINMARKETCAP_API_KEY, 
      showTimeSpent: true,
      excludeContracts: [],
      noColors: false,
    },
};

To view gas analytics report

yarn hardhat test

Replace the ./contracts/FundXFI.sol with the following code:
Optimized Contract

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

contract FundXFI {
    address public immutable i_owner;
    uint256 public constant MINIMUM_AMOUNT = 20 * 1e18; // ETH to Wei
    mapping(address => uint256) public addressToAmountFunded;
    mapping(address => bool) private hasFunded;
    address[] private funders;

    constructor() {
        i_owner = msg.sender;
    }

    function fund() external payable {
        require(msg.value > MINIMUM_AMOUNT, "Send some ETH");

        if (!hasFunded[msg.sender]) {
            hasFunded[msg.sender] = true;
            funders.push(msg.sender);
        }

        addressToAmountFunded[msg.sender] += msg.value;
    }

    function withdraw() external onlyOwner {
        for (uint256 i = 0; i < funders.length; i++) {
            address funder = funders[i];
            addressToAmountFunded[funder] = 0;
            hasFunded[funder] = false;
            unchecked {
                ++i;
            } // Save gas by skipping overflow check
        }

        delete funders;

        (bool success, ) = payable(i_owner).call{value: address(this).balance}(
            ""
        );
        require(success, "Withdraw failed");
    }

    modifier onlyOwner() {
        require(msg.sender == i_owner, "Not owner");
        _;
    }

    function getFunders() external view returns (address[] memory) {
        return funders;
    }
}

APPROACH ♻️

Compile the smart contract

yarn hardhat compile

Deploy the contract to the CrossFi Testnet

yarn hardhat run scripts/deploy.cjs --network crossfiTestnet

Run tests to view the gas analytics report

yarn hardhat test

Compare report

Efficiency Techniques 📊

Techniques	Purpose
Use `immutable` and `constant`	Save storage slot reads
Replace `transfer` with `call`	Avoid 2300 gas cap
Use `external` over `public` when possible	Cheaper gas
Minimize state writes	Especially inside loops
Avoid unbounded loops	For scalability
Pack storage variables	Reduces slot usage

TL;DR: 🧠

Optimizing gas = smart engineering
Advantage = happy users, lower fees, better performance
Why it matters = in blockchain, performance is paid for in tokens

Conclusion

🔗 Checkout: wwww.crossfi.org for more information.

Writing Unit Tests for CrossFi DApp with Mocha & Chai

Azeez Abidoye — Sat, 15 Mar 2025 06:30:11 +0000

Overview

In the previous article, Developing a Rental DApp on CrossFi using Hardhat, we explored the fundamental steps for developing a decentralized rental application covering:

✅ Smart Contract Development: Writing a Solidity smart contract to manage the rental process.

✅ Generating a CrossFi API Key on Alchemy: Setting up Alchemy to interact with the CrossFi blockchain.

✅ Deploying the Contract: Using Hardhat to compile, and successfully deploy the contract on CrossFi chain.

Building on that foundation, this tutorial, focuses on ensuring the reliability of our smart contract through unit testing. We'll explore how to set up a test environment with Mocha and Chai, write comprehensive test cases, and validate the contract's functionality before deploying it to production.

⚠️ Recommended: This tutorial provides a fundamental understanding of the core concepts required in developing a decentralized application on the CrossFi testnet.

Developing a Rental DApp on CrossFi Using Hardhat

Azeez Abidoye
Azeez Abidoye

Azeez Abidoye

Follow

Mar 11 '25

Developing a Rental DApp on CrossFi Using Hardhat

#web3 #crossfi #solidity #blockchain

25 reactions
Comments 3 comments

7 min read

Dev Tool 🛠️

Yarn

npm install -g yarn

Writing unit tests with Mocha and Chai

Unit testing is essential for verifying the functionality of any component, whether it’s a class, a function, or a single line of code.

In this piece, we will explore how to unit test Solidity smart contracts using Mocha, a lightweight Node.js framework, and Chai, a Test-Driven Development (TDD) assertion library for Node.js. Both Mocha and Chai run on Node.js and support asynchronous testing in the browser. While Mocha can be used with various assertion libraries, it is most commonly paired with Chai for its flexibility and readability.

First, make sure you have the required dependencies installed.

yarn add mocha chai@4.3.7 --dev

Create a new file for the Test Script

Navigate to the test directory
Create a new file named rental-test.cjs

Understanding the Test Script

The test script is written using Mocha (a JavaScript test framework) and Chai (an assertion library) along with Hardhat's ethers.js for interacting with the smart contract.

1. Setting Up the Test Environment

const { expect } = require("chai");
const { ethers } = require("hardhat");

Chai provides the expect function for writing assertions.
Ethers.js is used to deploy and interact with the smart contract.

describe("Rental Smart Contract", function () {
  let Rental, rental, owner, renter;
}

describe(...) is Mocha’s way of grouping test cases. We declare variables:
Rental: The contract factory.
rental: The deployed contract instance.
owner: The deployer of the contract.
renter: A second account that acts as a renter.

2. Deploying the Contract Before Each Test

  beforeEach(async function () {
    Rental = await ethers.getContractFactory("Rental");
    [owner, renter] = await ethers.getSigners();
    rental = await Rental.deploy();
    await rental.waitForDeployment();
  });

beforeEach(...) ensures the contract is freshly deployed before every test.
getSigners() gives us two Ethereum accounts (owner and renter).
deploy() deploys the Rental contract.

Test Cases Explained

1. Adding a Renter

  it("Should add a renter successfully", async function () {
    await rental.addRenter(
      renter.address,
      "John",
      "Doe",
      true,
      false,
      ethers.parseEther("1"),
      0,
      0,
      0
    );

    const addedRenter = await rental.renters(renter.address);
    expect(addedRenter.firstName).to.equal("John");
    expect(addedRenter.canRent).to.be.true;
  });

✅ What it does:

Calls addRenter(...) to add a new renter.
Fetches renter data from the contract and checks:
First name should be "John".
canRent should be true.

2. Checking Out a Car

  it("Should allow renter to check out a car", async function () {
    await rental.addRenter(
      renter.address,
      "John",
      "Doe",
      true,
      false,
      ethers.parseEther("1"),
      0,
      0,
      0
    );

    await rental.checkOut(renter.address);
    const updatedRenter = await rental.renters(renter.address);
    expect(updatedRenter.active).to.be.true;
    expect(updatedRenter.canRent).to.be.false;
  });

✅ What it does:

Adds a renter.
Calls checkOut(...) for that renter.
Checks if:
active is true (renter has an active rental).
canRent is false (renter cannot rent another car).

3. Checking In a Car

it("Should allow renter to check in a car", async function () {
    await rental.addRenter(
      renter.address,
      "John",
      "Doe",
      true,
      false,
      ethers.parseEther("1"),
      0,
      0,
      0
    );

    await rental.checkOut(renter.address);
    await rental.checkIn(renter.address);

    const updatedRenter = await rental.renters(renter.address);
    expect(updatedRenter.active).to.be.false;
  });

✅ What it does:

Adds a renter.
Calls checkOut(...) → renter takes a car.
Calls checkIn(...) → renter returns the car.
Checks if:
active is false (rental session ended).

4. Depositing Funds

  it("Should allow renter to deposit funds", async function () {
    await rental.deposit(renter.address, { value: ethers.parseEther("1") });
    const renterBalance = await rental.balanceOfRenter(renter.address);
    expect(renterBalance).to.equal(ethers.parseEther("1"));
  });

✅ What it does:

Calls deposit(...) to add 1 ETH to the renter’s balance.
Verifies if the renter’s balance is exactly 1 ETH.

5. Making a Payment After Check-In

  it("Should allow renter to make payment and reset status", async function () {
    await rental.addRenter(
      renter.address,
      "John",
      "Doe",
      true,
      false,
      ethers.parseEther("1"),
      ethers.parseEther("0.05"),
      0,
      0
    );

    await rental.deposit(renter.address, { value: ethers.parseEther("1") });
    await rental.makePayment(renter.address, {
      value: ethers.parseEther("0.05"),
    });

    const updatedRenter = await rental.renters(renter.address);
    expect(updatedRenter.canRent).to.be.true;
    expect(updatedRenter.amountDue).to.equal(0);
  });

✅ What it does:

Adds a renter and sets an amountDue of 0.05 ETH.
Deposits 1 ETH to the renter’s balance.
Calls makePayment(...) to pay the 0.05 ETH.
Checks if:
canRent is true (renter can rent again).
amountDue is 0 (payment cleared).

6. Preventing Checkout with Pending Balance

  it("Should not allow renter to check out with pending balance", async function () {
    await rental.addRenter(
      renter.address,
      "John",
      "Doe",
      true,
      false,
      ethers.parseEther("1"),
      ethers.parseEther("0.05"),
      0,
      0
    );

    await expect(rental.checkOut(renter.address)).to.be.revertedWith(
      "You have a pending balance!"
    );
  });

✅ What it does:

Adds a renter who already owes 0.05 ETH.
Calls checkOut(...).
Expects the transaction to fail with the message "You have a pending balance!".

Updating the Test Script

This is how rental-test.cjs would look once all the test cases have been included.

const { ethers } = require("hardhat");
const { expect } = require("chai");

describe("Rental Smart Contract", function () {
  let Rental, rental, owner, renter;

  beforeEach(async function () {
    Rental = await ethers.getContractFactory("Rental");
    [owner, renter] = await ethers.getSigners();
    rental = await Rental.deploy();
    await rental.waitForDeployment();
  });

  it("Should add a renter successfully", async function () {
    await rental.addRenter(
      renter.address,
      "John",
      "Doe",
      true,
      false,
      ethers.parseEther("1"),
      0,
      0,
      0
    );

    const addedRenter = await rental.renters(renter.address);
    expect(addedRenter.firstName).to.equal("John");
    expect(addedRenter.canRent).to.be.true;
  });

  it("Should allow renter to check out a car", async function () {
    await rental.addRenter(
      renter.address,
      "John",
      "Doe",
      true,
      false,
      ethers.parseEther("1"),
      0,
      0,
      0
    );

    await rental.checkOut(renter.address);
    const updatedRenter = await rental.renters(renter.address);
    expect(updatedRenter.active).to.be.true;
    expect(updatedRenter.canRent).to.be.false;
  });

  it("Should allow renter to check in a car", async function () {
    await rental.addRenter(
      renter.address,
      "John",
      "Doe",
      true,
      false,
      ethers.parseEther("1"),
      0,
      0,
      0
    );

    await rental.checkOut(renter.address);
    await rental.checkIn(renter.address);

    const updatedRenter = await rental.renters(renter.address);
    expect(updatedRenter.active).to.be.false;
  });

  it("Should allow renter to deposit funds", async function () {
    await rental.deposit(renter.address, { value: ethers.parseEther("1") });
    const renterBalance = await rental.balanceOfRenter(renter.address);
    expect(renterBalance).to.equal(ethers.parseEther("1"));
  });

  it("Should allow renter to make payment and reset status", async function () {
    await rental.addRenter(
      renter.address,
      "John",
      "Doe",
      true,
      false,
      ethers.parseEther("1"),
      ethers.parseEther("0.05"),
      0,
      0
    );

    await rental.deposit(renter.address, { value: ethers.parseEther("1") });
    await rental.makePayment(renter.address, {
      value: ethers.parseEther("0.05"),
    });

    const updatedRenter = await rental.renters(renter.address);
    expect(updatedRenter.canRent).to.be.true;
    expect(updatedRenter.amountDue).to.equal(0);
  });

  it("Should not allow renter to check out with pending balance", async function () {
    await rental.addRenter(
      renter.address,
      "John",
      "Doe",
      true,
      false,
      ethers.parseEther("1"),
      ethers.parseEther("0.05"),
      0,
      0
    );

    await expect(rental.checkOut(renter.address)).to.be.revertedWith(
      "You have a pending balance!"
    );
  });
});

To run the tests, execute the following command.

yarn hardhat test

Your test should pass with the following results:

Rental Smart Contract
✔ Should add a renter successfully
✔ Should allow renter to check out a car
✔ Should allow renter to check in a car
✔ Should allow renter to deposit funds
✔ Should allow renter to make payment and reset status
✔ Should not allow renter to check out with pending balance

6 passing (429ms)

✨ Done in 2.33s.

Conclusion

This test suite verifies the core functionalities of the smart contract:
✅ Adding renters
✅ Checking out cars
✅ Checking in cars
✅ Depositing funds
✅ Making payments
✅ Preventing invalid actions

Developing a Rental DApp on CrossFi Using Hardhat

Azeez Abidoye — Tue, 11 Mar 2025 11:01:48 +0000

What's CrossFi?

Prerequisites

NodeJs
Metamask
Testnet ethers
Alchemy API URL

Dev Tools

npm install -g yarn

Step 1: Creating and launching a new React project

npm create vite@latest rental-dapp --template react && cd rental-dapp

✍️ Choose React and Javascript from the prompt to set up your project.

Step 2: Installing Hardhat Plugin for development

yarn add hardhat

Step 3: Initializing Hardhat Ethereum development environment

npx hardhat init

✍️ To set up your project, select Create a JavaScript project and proceed with the prompt.

Step 4: Configuring Hardhat for development

Open the hardhat.config.cjs file to set up the networks property

require("@nomicfoundation/hardhat-toolbox");

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.28",
  networks: {
    crossfiTestnet: {
      chainId: 4157,
      url: "https://crossfi-testnet.g.alchemy.com/v2/wAz9j4RJUgEBiaMljD1yGbi45YBRKXTK",
      accounts: [
        "8dba19966d85ea2137505039c47d1e6ba35ab560797e51924fuedb939d9d2146"
      ],
    },
  },
};

⚠️ Recommended: Follow this step-by-step guide to generate, configure and secure CrossFi API Key.

Step 5: Creating the smart contract

Navigate to the contracts directory and create a new file named Rental.sol
Populate the file with the following Solidity code:

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

contract Rental {
    address owner;

    constructor() {
        owner = msg.sender;
    }

    // Add a new Renter
    struct Renter {
        address payable walletAddress;
        string firstName;
        string lastName;
        bool canRent;
        bool active;
        uint balance;
        uint amountDue;
        uint start;
        uint end;
    }

    // Mapping wallet addresses to each Renter
    mapping (address => Renter) public renters;

    // Function for adding a Renter to the list of "Renters"
    function addRenter(address payable walletAddress,
        string memory firstName,
        string memory lastName,
        bool canRent,
        bool active,
        uint balance,
        uint amountDue,
        uint start,
        uint end) public {
            renters[walletAddress] = Renter(payable (walletAddress), firstName, lastName, canRent, active, balance, amountDue, start, end);
    }

    // Checkout car ==> Rent a new car
    function checkOut(address payable walletAddress) public {
        require(renters[walletAddress].amountDue == 0, "You have a pending balance!");
        require(renters[walletAddress].canRent == true, "Can't rent a car at the moment!");
        renters[walletAddress].canRent = false;
        renters[walletAddress].active = true;
        renters[walletAddress].start = block.timestamp;
    }

    // Check-in car ==> Return rented car
    function checkIn(address payable walletAddress) public {
        require(renters[walletAddress].active == true, "Kindly checkout the car!");
        renters[walletAddress].active = false;
        renters[walletAddress].end = block.timestamp;

        // Set amount due
        setDueAmount(walletAddress);
    }

    // Calculate the Timespan
    function renterTimespan(uint start, uint end) internal pure returns (uint){
        return end - start;
    }

    // Get total duration of car use
    function getTotalDuration(address payable walletAddress) public view returns(uint) {
        require(renters[walletAddress].active == false, "The car is currently checked out!");
        uint timespan = renterTimespan(renters[walletAddress].start, renters[walletAddress].end);
        uint timespanInMinutes = timespan / 60;
        return timespanInMinutes;
    }

    // Get contract balance
    function balanceOf() public view returns (uint) {
        return address(this).balance;
    }

    // Get Renter's balance
    function balanceOfRenter(address payable walletAddress) public view returns(uint){
        return renters[walletAddress].balance;
    }

    // Set Due amount
    function setDueAmount(address payable  walletAddress) internal {
        uint timespanMinutes = getTotalDuration(walletAddress);
        uint fiveMinutesIncrement = timespanMinutes / 5;
        renters[walletAddress].amountDue = fiveMinutesIncrement * 5000000000000000;
    }

    // Reset renter's position after checking-in
    function canRentCar(address payable walletAddress) public view returns(bool) {
        return renters[walletAddress].canRent;
    }

    // Deposit fund
    function deposit(address walletAddress) payable public {
        renters[walletAddress].balance += msg.value;
    }

    // Make Payment after check-in
    function makePayment(address walletAddress) payable  public {
        require(renters[walletAddress].amountDue > 0, "You do not have anything due at this time!");
        require(renters[walletAddress].balance > 0, "You do not have enough fund to cover payment. Please make a deposit!");
        renters[walletAddress].balance -= msg.value;
        renters[walletAddress].canRent = true;
        renters[walletAddress].active = false;
        renters[walletAddress].amountDue = 0;
        renters[walletAddress].start = 0;
        renters[walletAddress].end = 0;
    }
}

About the smart contract

This Solidity smart contract implements a rental system, likely for renting cars, where users can check out and check in a vehicle while managing their balances and payments. Below is a breakdown of its components:

Contract Overview

The contract is named Rental and enables renters to:

Register themselves in the system.
Check out a car if they meet the required conditions.
Check in a car after use and calculate the rental cost.
Deposit funds to their account.
Make payments for the rental.
Finally, the contract keeps track of renter details, including their balance, rental status, and amount due.

Key Components

1. State variables

address owner;

Stores the owner's address (the deployer of the contract).

2. Constructor

constructor() {
    owner = msg.sender;
}

Assigns the deployer of the contract as the owner.

3. Renter Structure

struct Renter {
    address payable walletAddress;
    string firstName;
    string lastName;
    bool canRent;
    bool active;
    uint balance;
    uint amountDue;
    uint start;
    uint end;
}

Defines a Renter with:
Wallet address (to track user payments).
Name (firstName and lastName).
Rental eligibility (canRent).
Current rental status (active).
Financial details (balance and amountDue).
Timestamps (start and end) to track rental duration.

4. Mapping Renters

mapping (address => Renter) public renters;

A mapping that links wallet addresses to their corresponding Renter records.

5. Adding a Renter

function addRenter(
    address payable walletAddress,
    string memory firstName,
    string memory lastName,
    bool canRent,
    bool active,
    uint balance,
    uint amountDue,
    uint start,
    uint end) public {
        renters[walletAddress] = Renter(
            walletAddress, firstName, lastName, canRent, active, balance, amountDue, start, end);
}

Allows adding a new renter with initial details.

6. Checking Out a Car

function checkOut(address payable walletAddress) public {
    require(renters[walletAddress].amountDue == 0, "You have a pending balance!");
    require(renters[walletAddress].canRent == true, "Can't rent a car at the moment!");

    renters[walletAddress].canRent = false;
    renters[walletAddress].active = true;
    renters[walletAddress].start = block.timestamp;
}

Function ensures:
The renter does not have a pending balance.
The renter is eligible to rent.
Updates rental status and records the start time.

7. Checking In a Car

function checkIn(address payable walletAddress) public {
    require(renters[walletAddress].active == true, "Kindly checkout the car!");

    renters[walletAddress].active = false;
    renters[walletAddress].end = block.timestamp;

    // Calculate the due amount
    setDueAmount(walletAddress);
}

Function ensures:
The renter has an active rental.
Updates rental status and records the end time.
Calls setDueAmount() function to calculate rental cost.

8. Calculating Rental Duration

function renterTimespan(uint start, uint end) internal pure returns (uint) {
    return end - start;
}

Computes the duration in seconds between start and end.

9. Getting Total Rental Duration in Minutes

function getTotalDuration(address payable walletAddress) public view returns(uint) {
    require(renters[walletAddress].active == false, "The car is currently checked out!");

    uint timespan = renterTimespan(renters[walletAddress].start, renters[walletAddress].end);
    uint timespanInMinutes = timespan / 60;

    return timespanInMinutes;
}

Converts the rental duration from seconds to minutes.
Ensures the renter has checked in.

10. Checking Contract Balance

function balanceOf() public view returns (uint) {
    return address(this).balance;
}

Returns the total balance held by the contract.

11. Checking Renter's Balance

function balanceOfRenter(address payable walletAddress) public view returns(uint){
    return renters[walletAddress].balance;
}

Returns the funds available in a renter's balance.

12. Setting the Amount Due

function setDueAmount(address payable walletAddress) internal {
    uint timespanMinutes = getTotalDuration(walletAddress);
    uint fiveMinutesIncrement = timespanMinutes / 5;

    renters[walletAddress].amountDue = fiveMinutesIncrement * 5000000000000000;
}

Calculates the rental fee based on:
timespanMinutes / 5 → Rounds down to 5-minute blocks.
Each block costs 0.005 ETH (5000000000000000 wei).

13. Checking if a Renter Can Rent Again

function canRentCar(address payable walletAddress) public view returns(bool) {
    return renters[walletAddress].canRent;
}

Returns true if the renter is allowed to rent.

14. Depositing Funds

function deposit(address walletAddress) payable public {
    renters[walletAddress].balance += msg.value;
}

Allows renters to add funds to their balance.

15. Making Payment

function makePayment(address walletAddress) payable public {
    require(renters[walletAddress].amountDue > 0, "You do not have anything due at this time!");
    require(renters[walletAddress].balance > 0, "You do not have enough fund to cover payment. Please make a deposit!");

    renters[walletAddress].balance -= msg.value;
    renters[walletAddress].canRent = true;
    renters[walletAddress].active = false;
    renters[walletAddress].amountDue = 0;
    renters[walletAddress].start = 0;
    renters[walletAddress].end = 0;
}

Function ensures:
The renter has an outstanding balance.
The renter has enough funds to cover the cost.
Deducts the amount from the balance and resets rental status.

Summary

Registration: addRenter()
Renting a car: checkOut()
Returning a car: checkIn()
Payment system:
setDueAmount() calculates cost.
deposit() adds funds.
makePayment() clears debts.
Tracking rental duration: getTotalDuration()
Checking balances: balanceOf(), balanceOfRenter()

Step 6: Compiling the smart contract

Add the directory where the automatically created ABI should be stored to the hardhat.config.cjs file

  paths: {
    artifacts: "./src/artifacts",
  }

The modified hardhat.config.cjs file should look as follows:

require("@nomicfoundation/hardhat-toolbox");

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.28",
  paths: {
    artifacts: "./src/artifacts",
  },
  networks: {
    crossfiTestnet: {
      chainId: 4157,
      url: "https://crossfi-testnet.g.alchemy.com/v2/wAz9j4RJUgEBiaMljD1yGbi45YBRKXTK",
      accounts: [
        "8dba19966d85ea2137505039c47d1e6ba35ab560797e51924fuedb939d9d2146",
      ],
    },
  },
}

Execute the following command to compile the contract

yarn hardhat compile

Step 7: Configuring the DApp for deployment

Create a new folder for deployment in the root directory

mkdir deploy

Open the deploy folder and create a new file named 00-deploy-rental.cjs
Install another Hardhat plugin as a package for deployment

yarn add hardhat-deploy --dev

Import hardhat-deploy package to the hardhat.config.cjs file

require("hardhat-deploy");

Install hardhat-deploy-ethers to override the @nomiclabs/hardhat-ethers package

yarn add --dev @nomiclabs/hardhat-ethers@npm:hardhat-deploy-ethers

Configure a deployer account in the hardhat.config.cjs file

networks: {
  // Code Here
},
namedAccounts: {
  deployer: {
    default: 0,
  }
}

Populate the 00-deploy-rental.cjs file with the following code:

module.exports = async ({ getNamedAccounts, deployments }) => {
  const { deploy } = deployments;
  const { deployer } = await getNamedAccounts();
  await deploy("Rental", {
    contract: "Rental",
    from: deployer,
    args: [],
    log: true,
  });
};
module.exports.tags = ["Rental"];

Step 8: Deploying the contract to CrossFi Testnet

yarn hardhat deploy --network crossfiTestnet

The following should be the deployment output if the deployment is successful:

Compiled 1 Solidity file successfully (evm target: paris).
deploying "Rental" (tx: 0x722012ff0b9036f3d56587de9e87549be2b95e3b10a76525b22d489e34f72ffb)...: deployed at 0x0847857BE3dce76060Fabe41648CcbFe7f6898Fc with 1585543 gas
✨  Done in 15.76s.

The Deployed at information provide the contract address

...: deployed at 0x0847857BE3dce76060Fabe41648CcbFe7f6898Fc

Congratulations 🎉 You have successfully developed a decentralized application on the CrossFi test network.

Conclusion

In this tutorial, we explored how to develop a Rental DApp on CrossFi using Hardhat framework, covering smart contract creation and deployment. By leveraging CrossFi’s blockchain infrastructure, we created a decentralized rental system with seamless fund management.

As you continue refining your DApp, consider integrating frontend components with React, enhancing security with access control mechanisms, and optimizing gas fees. Experimenting with CrossFi’s features will further improve scalability and user experience.

Now that you have a solid foundation, what will you build next? 🚀

Getting Started with CrossFi Development: Keplr & MetaMask Wallet Integration

Azeez Abidoye — Wed, 26 Feb 2025 10:07:49 +0000

Why CrossFi 🧐

CrossFi Chain is a layer 1 blockchain with a modular architecture. It consists of two integral parts, Cosmos and EVM. Each part is responsible for its specific functionality, with their work completely synchronized as a single organism.
CrossFi is fully EVM compatible, which means you can use any EVM based developer tooling and libraries. For the purposes of this tutorial, we will create a decentralized application using Foundry.

Main Takeaways 🎁

Understand CrossFi Blockchain
Download & Configure Keplr Wallet
Download & Configure Metamask Wallet
Integrate CrossFi Testnet into MetaMask
Generate CrossFi Testnet Tokens
Import Evmos Address & Balance
Initialize a New dApp using Foundry
Deploy Contract on CrossFi Testnet
Verify Contract with XFI-Scan Explorer

Dev Tools ⚒️

Yarn

npm install -g yarn

Forge

curl -L https://foundry.paradigm.xyz | bash

Step 1: Setup Keplr Wallet for CrossFi Token Generation

We will start this tutorial by establishing a communication channel between our dApp and the blockchain network. Interacting with Ethereum is seamless using wallets like MetaMask or Keplr. Additionally, Cosmos-based blockchains rely on Keplr for asset and fund management.

Follow this link to set up a Keplr wallet for CrossFi testnet token generation.

Step 2: Export Keplr to MetaMask wallet

I assume you have followed the link above to download and configure the Keplr wallet, as well as generated at least 0.01 XFI testnet tokens. You can continue to increase your balance by revisiting the faucet daily. However, importing the Keplr wallet into MetaMask is the next stage in this process.

- Retrieve Keplr wallet recovery phrase

To view your recovery phrase, select the User icon at the top right corner

Click the three-stacked-dots next to your wallet name

Select View recovery phrase from the options

Insert your password and click Confirm to proceed

Select Copy to clipboard to copy your recovery phrase

✍️ Ensure to store your Keplr wallet recovery phrase safely and handy

- Export with Keplr's recovery phrase

✍️ Recommended: Create a new Chrome profile before downloading MetaMask wallet in order to separate the pre-existing MetaMask accounts from the imported Keplr account.

Go to metamask.io and select [Get MetaMask]
Select [Add to Chrome] and click the [Add extension] button in the modal window
Agree to MetaMask's Terms of use and select the [Import an existing wallet] button
[Agree] to continue
Insert the 12-word Keplr wallet recovery phrase that you copied earlier
Create password and select [Import my wallet]
Select [Done] to finalize the installation

Boom 💥 Your MetaMask wallet is ready!

- Adding the CrossFi Test Network to MetaMask

✍️ Currently, your wallet balance may display zero, because the MetaMask network is set to Ethereum by default.

Click on the Network dropdown at the top-left corner of MetaMask page
Turn on the Show test networks switch button
Click the [Add a custom network] button
Fill in the network details as follows and click [Save]:

Network name: CrossFi Testnet
Default RPC URL: https://rpc.testnet.ms
Chain ID: 4157
Symbol: XFI
Block explorer URL: https://scan.testnet.ms

Select the network dropdown again and click the CrossFi Testnet you recently added

Congratulations 🎉 You have successfully imported your Keplr wallet to MetaMask

Step 3: Create a new project directory

mkdir crossfi-foundry-dapp && cd crossfi-foundry-dapp

Step 4: Initialize the Foundry framework

✍️ Foundry initializes a new git repository automatically. This can be prevented by flagging the command.

forge init --no-git

✍️ Recommended: Each of these folders includes an initial file; delete them one by one to start fresh.

Step 5: Create the contract

Navigate to the src directory
Create a new file named SimpleEscrow.sol
Update the SimpleEscrow.sol with the following code:

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

contract SimpleEscrow {
    address public buyer;
    address public seller;
    bool public isLocked;

    constructor(address _seller) payable {
        require(msg.value > 0, "Deposit required");
        buyer = msg.sender;
        seller = _seller;
        isLocked = true;
    }

    function releaseFunds() external {
        require(msg.sender == buyer, "Only buyer can release funds");
        require(isLocked, "Funds already released");

        isLocked = false;
        payable(seller).transfer(address(this).balance);
    }

    function refundBuyer() external {
        require(msg.sender == seller, "Only seller can refund buyer");
        require(isLocked, "Funds already released");

        isLocked = false;
        payable(buyer).transfer(address(this).balance);
    }

    function balanceOf() public view returns (uint) {
        return address(this).balance;
    }
}

Step 6: Compile the contract

To compile the Solidity smart contract using Forge, execute the following command:

forge build

Compilation result, if successful:

[⠊] Compiling...
[⠢] Compiling 1 files with Solc 0.8.27
[⠆] Solc 0.8.27 finished in 101.42ms
Compiler run successfully

Bonus: 💚 Retrieving your Private Key from MetaMask

Click on the three-stacked-dots at the top-right corner of Metamask page
Select Account details
Select [Show private key] button
Insert your password and [Confirm]
Click and hold the [Hold to reveal Private Key] button
Copy your Private Keyand keep it handy

Step 7: Deploying contract on CrossFi Testnet

Navigate to the script directory and create a new file named SimpleEscrow.s.sol
Here is the code for the deploy script

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

import "forge-std/Script.sol";
import "../src/SimpleEscrow.sol";

contract DeployEscrow is Script {
    function run() external {
        address seller = 0x3e61b7C58cb5D0d5F75082b758454a43676C8491;
        uint256 depositAmount = 1 ether;

        vm.startBroadcast(vm.envUint("PRIVATE_KEY"));
        SimpleEscrow escrow = new SimpleEscrow{value: depositAmount}(seller);
        vm.stopBroadcast();

        console.log("Escrow Contract Deployed at:", address(escrow));
    }
}

✍️ You can generate a new seller address here

Execute the following command to deploy your contract:

forge create --rpc-url https://rpc.testnet.ms \
--private-key YOUR_PRIVATE_KEY \
script/SimpleEscrow.s.sol:DeployEscrow

✍️ Replace the YOUR_PRIVATE_KEY variable with the Private Key you copied from your MetaMask wallet

If the deployment is successful, your contract address should appear under "Deployed to" in your terminal.

[⠊] Compiling...
[⠒] Compiling 1 files with Solc 0.8.27
[⠑] Solc 0.8.27 finished in 476.53ms
Compiler run successful!
Deployer: 0xF79102F12fC0ddDFbDDF459F3b2C3caB341F27C1
Deployed to: 0xF9E58DA7B14B0fabcBb7D9FB5c37A5aB92E4cF4E
Transaction hash: 0x6effdefe753139b8cdbdfd13a300554d3d071b7e043a7b92caa1f0d7c8ccfcaf

You may confirm that your contract has been deployed to the CrossFi testnet by searching for its address using the test XFI Scan

Step 8: Interacting with the contract

In the final step of this guide, we will interact with our contract by calling the public functions. We can do this by using Foundry and the following commands:

- Set your contract address

After deployment, note down your contract’s address and set it in an environment variable:

export CONTRACT_ADDRESS=0xYourContractAddressHere

- Read data from the contract

Run the following command to check the contract balance:

cast balance $CONTRACT_ADDRESS --rpc-url https://rpc.testnet.ms

Conclusion

In this tutorial, we explored how to build and deploy a Simple Escrow Smart Contract on the CrossFi blockchain using Foundry. Along the way, we covered key steps such as setting up Keplr and MetaMask wallets, integrating CrossFi Testnet, obtaining test tokens, and deploying our contract successfully.

By following these steps, you now have a solid understanding of CrossFi’s smart contract capabilities, how to interact with its ecosystem, and how to leverage Foundry for efficient smart contract development. Additionally, verifying your contract on XFI-Scan Explorer ensures transparency and trust in blockchain applications.

This foundational knowledge can be extended to develop more advanced decentralized applications on CrossFi. Whether you're building DeFi solutions, NFT marketplaces, or secure payment systems, this tutorial serves as a stepping stone toward mastering smart contract development on CrossFi.

Keep experimenting, testing, and pushing the boundaries of what's possible with blockchain technology! 🚀🔥

How to Create Decentralized IPFS Hash Storage on Morph Blockchain

Azeez Abidoye — Wed, 27 Nov 2024 08:24:38 +0000

What is IPFS? 🤔

According to Wikipedia, the InterPlanetary File System (IPFS) is a decentralized protocol, hypermedia, and peer-to-peer network for distributed file storage and sharing. By using content-addressing, IPFS uniquely identifies files in a global namespace that interlinks IPFS hosts, creating a hypermedia system that enables efficient and reliable data distribution.
Interoperability with decentralized applications is an important feature of IPFS, providing a strong foundation for Web3 and blockchain ecosystems.
In this article, we will develop a decentralized application on the Morph Holesky testnet that uses Pinata as the storage system to generate and store IPFS Hash onchain.

Prerequisites 📚

NodeJs (Version 18 or later)
NPM (Version 7 or later)
Metamask wallet
Testnet ethers
Pinata API Key

Dev Tool 🛠️

Yarn

npm install -g yarn

Step 1: Create a new React application

Let's begin by creating a new React app named ipfs-hash-storage

npm create vite@latest ipfs-hash-storage --template react

✍️ Follow through with the prompt by selecting React and JavaScript

Navigate into the new React app

cd ipfs-hash-storage

Step 2: Install Hardhat package as a dependency

yarn add hardhat

Step 3: Initialize Hardhat as the Ethereum Development Environment

npx hardhat init

✍️ Follow through with the prompt by selecting Create a JavaScript project

Delete the files in the contracts and test directories to have a clean slate

Bonus: 💚 How to create Pinata API Key

Sign up/Login on pinata.cloud
Select API Keys in the side bar
Select New Key at the top right corner
Check Admin to access all endpoints and account settings
Give your key a name and select Generate Key

✍️ This will open a modal containing all the API Key information

Copy the JWT token and store safely

Select Gateways in the sidebar
Copy the Domain link and store safely

✍️ This will be used to interact with IPFS node by Pinata

Step 4: Setup the environment information

Install the plugin to configure the environment variables

yarn add --dev dotenv

Create a new file named .env in the root directory and populate it with the following variables:

RPC_URL="https://rpc-quicknode-holesky.morphl2.io"
DEV_PRIVATE_KEY="insert-your-private-key-here"
VITE_PINATA_JWT="insert-your-jwt-token-here"
VITE_PINATA_GATEWAY="insert-your-gateway-domain-link-here"

Step 5: Configure Hardhat for DApp Development

Open the hardhat.config.cjs file and configure it as follows:

require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

const { RPC_URL, DEV_PRIVATE_KEY } = process.env;

module.exports = {
  solidity: "0.8.25",
  paths: {
    artifacts: "./src/artifacts",
  },
  networks: {
    morphTestnet: {
      chainId: 2810,
      url: RPC_URL,
      accounts: [DEV_PRIVATE_KEY],
      gasPrice: 2000000000,
    },
  },
};

Step 6: Configure Pinata for storage purpose

Install Pinata plugin for configuration

yarn add pinata

Navigate to the src directory and create a new file named config.js
Populate src/config.js file with the following code for Pinata configuration:

import { PinataSDK } from "pinata";

const pinataJwt = import.meta.env.VITE_PINATA_JWT;
const pinataGateway = import.meta.env.VITE_PINATA_GATEWAY;

export const pinata = new PinataSDK({
  pinataJwt,
  pinataGateway,
});

Step 7: Write the Solidity code for smart contract

Open the contracts directory and create a new file named IpfsHashStorage.sol
Here is the smart contract code:

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

contract IpfsHashStorage {
    string private ipfsHash;

    // Hash Setter Function
    function setIPFSHash (string memory _ipfsHash) public view {
        _ipfsHash = ipfsHash;
    }

    // Hash Getter Function
    function getIPFSHash() public view returns(string memory) {
        return ipfsHash;
    }
}

Step 8: Compile smart contract

Execute the following command to compile the smart contract code

yarn hardhat compile

The compilation result should look like this

Compiled 1 Solidity file successfully (evm target: paris).
✨ Done in 3.70s.

✍️ The Application Binary Interface (ABI) is saved in the artifacts directory, which is automatically generated in the src directory, according to the initial Hardhat configurations

Step 9: Deploy DApp on Morph testnet

Install Hardhat deployment package

yarn add --dev hardhat-deploy

Import hardhat-deploy package into the Hardhat config file

require("hardhat-deploy");

Install another Hardhat plugin to override @nomiclabs/hardhat-ethers

yarn add --dev @nomiclabs/hardhat-ethers@npm:hardhat-deploy-ethers

Open the Hardhat config file and set up a deployer account

networks: {
     // Network config here...
},
namedAccounts: {
     deployer: {
        default: 0,
     }
}

Create a new directory named deploy in the root directory

mkdir deploy

Create a new file named deploy.cjs in the deploy folder
Populate the deploy.cjs file with the following code

module.exports = async ({ getNamedAccounts, deployments }) => {
  const { deploy, log } = deployments;
  const { deployer } = await getNamedAccounts();
  const args = [];
  await deploy("IpfsHashStorage", {
    contract: "IpfsHashStorage",
    args: args,
    from: deployer,
    log: true,
  });
};
module.exports.tags = ["IpfsHashStorage"];

To deploy the contract on Morph Holesky testnet, execute the following command

yarn hardhat deploy --network morphTestnet

The result of the deployment should look similar to this:

Nothing to compile
deploying "IpfsHashStorage" (tx: 0x8ac1f3d2fa46bf2f925505cfd3aeadaaf4622692c6dbaf9d7ec3d2d197098a5a)...: deployed at 0x99aFF0cbBb2561d1898b6B14C46b2cb994F9eDEC with 298063 gas
✨ Done in 7.79s.

Frontend Integration

Open src/App.jsx file and populate it with the following code:
The imports, ABI and the contract address

import React, { useState } from "react";
import { ethers } from "ethers";
import { pinata } from "./config";
import "./App.css";

// Contract ABI
import { abi } from "./artifacts/contracts/IpfsHashStorage.sol/IpfsHashStorage.json";

// Contract Address
const contractAddress = "Paste-your-contract-address-here";

The state variables

function App() {
    const [selectedFile, setSelectedFile] = useState(null);
    const [ipfsHash, setIpfsHash] = useState("");
    const [storedHash, setStoredHash] = useState("");
  return (
    // Code here
  )
}

export default App;

The handler function

function App() {
    // State variables...

    // Handler Function
    const changeHandler = (event) => {
    setSelectedFile(event.target.files[0]);
    };
  return (
    // Code here
  )
}

export default App;

Add the function for storing IPFS Hash on-chain

function App() {
    // State variables...

    // Handler Function...

    // Function to Store IPFS on the Blockchain
    const storeHashOnBlockchain = async (hash) => {
        // Check if Metamask is installed
        if (typeof window.ethereum !== "undefined") {
            // Connect to Ethereum provider (Metamask)
            const provider = new ethers.providers.Web3Provider(window.ethereum);
            const signer = provider.getSigner();

            // Create a contract instance
            const contract = new ethers.Contract(contractAddress, abi, signer);
            try {
            // Send transaction to store IPFS Hash on the blockchain
            const txResponse = await contract.setIPFSHash(hash);
            await txResponse.wait();
            } catch (error) {
            console.log("Failed to store IPFS Hash on blockchain", error);
            }
        }
    };

  return (
    // Code here
  )
}

export default App;

Add the function for retrieving the IPFS Hash

function App() {
    // State variables...

    // Handler Function...

    // Function to Store IPFS on the Blockchain...

    // Function to Retrieve Hash from the Blockchain
    const retrieveHashFromBlockchain = async () => {
        // Check if Metamask is installed
        if (typeof window.ethereum !== "undefined") {
            // Connect to Ethereum provider (Metamask)
            const provider = new ethers.providers.Web3Provider(window.ethereum);
            const signer = provider.getSigner();

            // Create a contract instance
            const contract = new ethers.Contract(contractAddress, abi, signer);
            try {
            // Send transaction to retrieve IPFS Hash from the blockchain
            const storedHash = await contract.getIPFSHash();
            setStoredHash(storedHash);
            } catch (error) {
            console.log("Failed to retrieve IPFS Hash from blockchain", error);
            }
        }
    };

  return (
    // Code here
  )
}

export default App;

Lastly, add the function to upload files to Pinata cloud

function App() {
    // State variables...

    // Handler Function...

    // Function to Store IPFS on the Blockchain...

    // Function to Retrieve Hash from the Blockchain...

    // Upload Function
    const handleUpload = async () => {
        const response = await pinata.upload.file(selectedFile);
        const ipfsHash = response.cid;
        setIpfsHash(ipfsHash);
        await storeHashOnBlockchain(ipfsHash);
        setIpfsHash(" ");
    };

  return (
    // Code here
  )
}

export default App;

Update the JSX component

function App() {

  return (
        <>
        <div className="app-container">
        <h1>Store IPFS On-chain</h1>
        <div className="upload-section">
            <label className="form-label">Choose File</label>
            <input
            type="file"
            onChange={changeHandler}
            className="file-input"
            ></input>
            <button className="upload-button" onClick={handleUpload}>
            Upload
            </button>
        </div>
        {ipfsHash && (
            <div className="result-section">
            <p>IPFS Hash: {ipfsHash}</p>
            </div>
        )}
        <div className="retrieve-section">
            <button
            className="retrieve-button"
            onClick={retrieveHashFromBlockchain}
            >
            Retrieve Hash
            </button>
        </div>
        {storedHash && (
            <div>
            <p>Retrieved Hash: {storedHash}</p>
            </div>
        )}
        </div>
    </>
    );
}

export default App;

Update the App.css file with the following code:

/* App.css */
.app-container {
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  height: 100vh;
  background-color: #f4f4f9;
  font-family: Arial, sans-serif;
}

.upload-section {
  background-color: #fff;
  padding: 20px;
  border-radius: 10px;
  box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.1);
  text-align: center;
}

.form-label {
  display: block;
  margin-bottom: 10px;
  font-size: 18px;
  font-weight: bold;
  color: #333;
}

.file-input {
  margin-bottom: 15px;
}

.upload-button {
  background-color: #4caf50;
  color: white;
  padding: 10px 20px;
  border: none;
  border-radius: 5px;
  cursor: pointer;
  font-size: 16px;
  transition: background-color 0.3s ease;
}

.upload-button:hover {
  background-color: #45a049;
}

.result-section {
  margin-top: 20px;
  padding: 10px 20px;
  background-color: #e0f7fa;
  border-radius: 5px;
  box-shadow: 0px 0px 5px rgba(0, 0, 0, 0.1);
}

.result-section p {
  margin: 0;
  font-size: 16px;
  color: #333;
}

Execute the following command to run the React App

yarn run dev

To view the uploaded file in your storage, select Files in the sidebar

✍️ This will provide a list of all uploaded files in your storage.

Choose a file to preview in a new tab

Conclusion

Creating and retrieving an IPFS hash on the blockchain with the Pinata platform as storage is covered in this tutorial. Nevertheless, the InterPlanetary File System and its potential for decentralized systems are not limited to that. Hopefully, I will create a more advanced decentralized app with a similar storage in the near future.

Step-by-step Guide to Building a Morph App with Pyth Oracle and WalletConnect

Azeez Abidoye — Wed, 13 Nov 2024 12:23:59 +0000

The blockchain oracle network is a system that enables blockchain to interact with external data sources, allowing smart contracts to access real-world data. Because blockchain exists in its own reality, it is purposefully deterministic. A decentralized blockchain oracle computes the off-chain data in order to be able to work with the on-chain logics provided by the blockchain.
To recap, decentralized oracles bridge the gap between blockchain and the outside world, providing data that is crucial for many decentralized applications and smart contract functionalities.

About Morph

Morph is a global consumer layer for value creation on the blockchain. At the core of Morph is a revolutionary approach to Ethereum Layer 2 scalability, harnessing the power of rollup technology.
Morph is committed to enhancing the blockchain experience by providing scalable, secure, and user-friendly Layer 2 solutions that make consumer blockchain applications accessible and valuable to developers, projects, and everyday users.

Why Pyth Oracle?

Pyth is a protocol that allows market participants to publish pricing information on-chain for others to use. Pyth Network price feeds provide real-time financial market data to smart contract applications offering over 450 price feeds covering a number of different asset classes, including US equities, commodities, and cryptocurrencies.

What is WalletConnect Integration?

WalletConnect, which is currently Reown, is a platform that provides technological tools that allow wallets to communicate with various blockchain applications and make it easy to authorize transactions with just one click, as well as get vital information and notifications. However, all of this happens without you carrying out any extra work.

Morph Application Starter Kit 🎁

Interestingly, Morph have built a package that allows developers to set up a new Morph application with Pyth Oracle and WalletConnect integration. The goal of this tutorial is to show you how to create, deploy, and test a fullstack decentralized application using this package, so you don't have to start from scratch.

Prerequisites 📚

Metamask
Node Js (v16 or later)
NPM (v6 or later)
Testnet ethers
WalletConnect Project ID

Dev Tools 🛠️

Forge

curl -L https://foundry.paradigm.xyz | bash

Yarn

npm install -g yarn

Checkout this tutorial to learn more about Morph SDK

Getting Started with Morph SDK and Metamask Integration

Azeez Abidoye
Azeez Abidoye

Azeez Abidoye

Follow

Oct 24 '24

Getting Started with Morph SDK and Metamask Integration

27 reactions
Comments Add Comment

5 min read

Bonus: Generate WalletConnect Project ID 💚

Sign up/Sign in on reown.com
Select Projects on the side bar
Click on Create Project to create a new project

Add project information by providing a name for your application e.g my-pyth-app

Select a product and continue

✍️ In our case we will select AppKit which is suitable for web applications

Select a platform

✍️ Choose a frontend framework, select NextJs for the purpose of this tutorial

Boom 💥 You have successfully generated a Project ID for your application.

Now, let's start hacking... 👨‍💻

Step 1: Create a new project with Morph Application Starter Kit

npx @morphl2/create-pyth-app@latest

✍️ Give your application a name e.g my-morph-pyth-app. Wait for the execution to install all the packages and as well create a new directory for your project.

Nagivate into your new project and launch it on your desired code editor

cd my-morph-pyth-app && code .

Morph Pyth App File Tree: 📚

Contracts: This directory contains all of the code for developing smart contracts using either the Foundry or Hardhat frameworks. Both frameworks have been structured to allow for rapid and easy DApp development. For this tutorial, we will focus on the Foundry framework.
Frontend: The client-side development code exists in this directory. The frontend has been implemented with NextJs, a React framework. You can customize this by integrating other frontend frameworks.

Step 2: Configure the environment information for contract deployment

Open the contracts/foundry directory
Rename the .env-example to .env
Populate the PRIVATE_KEY and RPC_URL information

✍️ Ensure to prefix your Private Key with an 0x to avoid errors

PRIVATE_KEY="0x2fa341ffado560fdf78cfd317cYu3ae67591d16308db8"
RPC_URL="https://rpc-quicknode-holesky.morphl2.io"

Step 3: Compile smart contract

Navigate to contracts/foundry directory and execute the following command:

forge build

After a successful compilation, the outcome will look like this:

[⠊] Compiling...
[⠘] Compiling 24 files with Solc 0.8.27
[⠊] Solc 0.8.27 finished in 4.83s
Compiler run successful!

✍️ The ABI is in the out directory and is automatically included to the project after compiling the smart contract

Step 4: Deploying contract on Morph Holesky testnet

Import the configured .env information into the CLI

source .env

Simulate the contract

forge script script/Deployer.s.sol:DeployerScript --rpc-url $RPC_URL

The completed simulation result will look like this

[⠒] Compiling...
[⠢] Compiling 2 files with Solc 0.8.27
[⠆] Solc 0.8.27 finished in 5.16s
Compiler run successful!
Script ran successfully.

== Return ==
0: contract EthBettingDapp 0x90193C961A926261B756D1E5bb255e67ff9498A1

## Setting up 1 EVM.

==========================

Chain 2810

Estimated gas price: 0.202 gwei

Estimated total gas used for script: 1648006

Estimated amount required: 0.000332897212 ETH

==========================

SIMULATION COMPLETE. To broadcast these transactions, add --broadcast and wallet configuration(s) to the previous command. See forge script --help for more.

Execute the following command to deploy contract on Morph Holesky testnet

forge script script/Deployer.s.sol:DeployerScript --rpc-url $RPC_URL  --broadcast --private-key $PRIVATE_KEY --legacy

The result of a successful deployment will look like this:

[⠒] Compiling...
No files changed, compilation skipped
Script ran successfully.

== Return ==
0: contract EthBettingDapp 0x47e3FE94CE4649123034C289217C937b59d1d301

## Setting up 1 EVM.

==========================

Chain 2810

Estimated gas price: 0.201 gwei

Estimated total gas used for script: 1648006

Estimated amount required: 0.000331249206 ETH

==========================

##### 2810
✅  [Success]Hash: 0xf97efe66f05e31d04974c6001e55e7e89b37efc0c7a374109b01f0ebffac9aed
Contract Address: 0x47e3FE94CE4649123034C289217C937b59d1d301
Block: 13183360
Paid: 0.000254876643 ETH (1268043 gas * 0.201 gwei)

✅ Sequence #1 on 2810 | Total Paid: 0.000254876643 ETH (1268043 gas * avg 0.201 gwei)


==========================

ONCHAIN EXECUTION COMPLETE & SUCCESSFUL.

Verify the contract deployment with Morph explorer frontend

Interacting with the DApp frontend

Navigate to the frontend directory and install the plugins

yarn install

Rename the .env-example file to .env
Populate the environment variable with the Project ID generated initially

NEXT_PUBLIC_PROJECT_ID="9efcb454adf22f37015a63b56b2388a7"

Launch your project in the browser

yarn run dev

Conclusion

In this tutorial, we explored the fundamentals of building a full-stack decentralized application using the Morph App starter kit, featuring Pyth Oracle and WalletConnect integration. This lesson aims to provide developers working on Morph with a streamlined, user-friendly approach to application development and deployment, eliminating the need to build the app structure from scratch.

Getting Started with Morph SDK and Metamask Integration

Azeez Abidoye — Thu, 24 Oct 2024 14:05:59 +0000

About Morph 🤔

Morph is the first optimistic zkEVM Ethereum Layer 2 solution that is perfectly compatible with Ethereum Virtual Machine (EVM). Morph platform is uniquely designed to enhance the blockchain experience, making it more accessible, efficient, and user-friendly for both developers and consumers.

What is Morph SDK? 🤷‍♂️

Assisting developers in creating DApps on Morph Layer 2 platform, Morph offers a collection of resources, frameworks, and documentation known as the Morph SDK (Software Development Kit). Developers can implement Morph's exclusive Layer 2 capabilities, such scalability, effective transaction processing, and security, into their apps by using it to make interacting with the Morph blockchain straightforward.

Main Takeaways 🎁

Download and configure Metamask wallet
Integrate Morph Holesky network into Metamask
Get Morph Testnet ethers
Initialize a new DApp project with Morph SDK
Deploy contract on a Local network
Deploy on Morph Holesky Testnet using Forge

Dev Tools 🛠️

Yarn

npm install -g yarn

Forge

curl -L https://foundry.paradigm.xyz | bash

Step 1: Metamask download and configuration

Visit metamask.io and select Get MetaMask

Select Add to Browser to download extension

On Metamask homepage, Agree to Terms of use
Select Create a new wallet to create a new wallet

Agree and continue
Create password for your wallet

✍️ Consent to the conditions to continue configuring.
Select Create new wallet
Secure your wallet

✍️ It is highly recommended that you secure your wallet to avoid loss of funds and/or assets.

Step 2: Adding network to Metamask

Click the Network dropdown at the top-left corner of Metamask page
Turn on Show test networks button

Visit chainlist.org
Check the Include Testnets to load test networks
Search for Morph Holesky in the search field
Select Connect Wallet on the search result

Follow through with the prompts and Approve network integration

Select Switch network to switch to Morph Holesky network

Step 3: Getting testnet ethers

Go to Morph Faucet
Input your wallet address into the field
Click Send ETH button to receive testnet ethers

Step 4: Retrieving your Private Key

Click the three-stacked-dots at the top-right corner of Metamask page
Select Account details

Select Show private key button

Insert your password to grant access

Click and hold Hold to reveal Private Key

Copy your Private Key

Step 5: Create a new DApp project

To initialize a new DApp project using Morph SDK, run:

npx @morphl2/create-morph-app@latest

✍️ Give your app a name e.g. my-morph-app and wait for the execution to create a new directory for your project with all the packages installed.

Morph App File Tree: 📚

Contracts: This directory contains all of the code for developing smart contracts using either the Foundry or Hardhat frameworks. Both frameworks have been structured to allow for rapid and easy DApp development. For this tutorial, we will focus on the Foundry framework.
Frontend: The client-side development code exists in this directory. The frontend has been implemented with NextJs, a React framework. You can customize this by integrating other frontend frameworks.

Step 6: Configure DApp for deployment

Open contracts/foundry directory
Rename the .env-example to .env
Populate the PRIVATE_KEY and RPC_URL information

✍️ Ensure to prefix your Private Key with an 0x to avoid errors

PRIVATE_KEY="0x2fa341ffadoNotCopyf78cfd317cYu3aediot91d16308db8"
RPC_URL="https://rpc-quicknode-holesky.morphl2.io"

Step 7: Compile the contract

Navigate to contracts/foundry directory and run:

forge build

Result of your compilation should look like this:

[⠊] Compiling...
[⠊] Compiling 25 files with Solc 0.8.27
[⠒] Solc 0.8.27 finished in 933.05ms
Compiler run successful!

Step 8: Deploying contract on a Local network

Open a new terminal window to activate the local network

anvil

✍️ This opens a list of ten (10) accounts and their private keys for deployment. Leave the terminal running...

Navigate to contracts/foundry directory to continue
Before deployment, there is need to simulate the contract

forge script script/Deployer.s.sol:DeployerScript --rpc-url http://127.0.0.1:8545 [private_key]

✍️ You can copy one of the Private Keys provided in the Anvil terminal window for use.

Bonus: 💚 Store environment information using Keystore Encryption

Run this command to encrypt your private key:

cast wallet import testAccount --interactive

✍️ Follow the prompt and encrypt your private key with a simple password for reusability.

Finally, run the following command to deploy on local network

forge script script/Deployer.s.sol:DeployerScript --rpc-url http://127.0.0.1:8545 --broadcast --sender [account_address] --account testAccount

⚠️ For this command to execute, it will request for the password you created to encrypt your private key.

✍️ Remember, your encrypted private key has been linked with the right account. Copy the account that tallies with your private key from the Anvil terminal window.

Step 9: Deploying contract on Morph Holesky testnet

Import the configured .env information into the CLI

source .env

Simulate the smart contract

forge script script/Deployer.s.sol:DeployerScript --rpc-url $RPC_URL

Simulation result should look like this:

[⠊] Compiling...
No files changed, compilation skipped
Script ran successfully.

== Return ==
0: contract MyToken 0x90193C961A926261B756D1E5bb255e67ff9498A1

## Setting up 1 EVM.

==========================

Chain 2810

Estimated gas price: 0.202 gwei

Estimated total gas used for script: 747926

Estimated amount required: 0.000151081052 ETH

==========================

SIMULATION COMPLETE. To broadcast these transactions, add --broadcast and wallet configuration(s) to the previous command. See forge script --help for more.

Run the following command to deploy on Morph Holesky testnet:

forge script script/Deployer.s.sol:DeployerScript --rpc-url $RPC_URL  --broadcast --private-key $PRIVATE_KEY --legacy

Here is what your deployment result would look like:

[⠊] Compiling...
No files changed, compilation skipped
Script ran successfully.

== Return ==
0: contract MyToken 0x7afC2B995741dCb2e6606f577c99737612763127

## Setting up 1 EVM.

==========================

Chain 2810

Estimated gas price: 0.201 gwei

Estimated total gas used for script: 747926

Estimated amount required: 0.000150333126 ETH

==========================

##### 2810
✅  [Success]Hash: 0x1b10883e5da2f07548c5fc4c57f9f257be44b1157bf161f9c1650a73698445e4
Contract Address: 0x7afC2B995741dCb2e6606f577c99737612763127
Block: 11677316
Paid: 0.00011567751 ETH (575510 gas * 0.201 gwei)

✅ Sequence #1 on 2810 | Total Paid: 0.00011567751 ETH (575510 gas * avg 0.201 gwei)


==========================

ONCHAIN EXECUTION COMPLETE & SUCCESSFUL.

Take note of your balance on Metamask

Verify with Morph block explorer

What we have covered: 🎉

✅ Download and configure Metamask wallet
✅ Integrate Morph Holesky network into Metamask
✅ Get Morph Testnet ethers
✅ Initialize a new DApp project with Morph SDK
✅ Store information using Keystore Encryption
✅ Deploy contract on a Local network
✅ Deploy on Morph Holesky Testnet using Forge
✅ Verify contract with Morph explorer

Conclusion

In this tutorial, we covered the fundamental concepts required to quickly and effortlessly build on the Morph blockchain. The process of developing a full stack decentralized application utilizing one of the Ethereum development frameworks begins with the installation and configuration of Metamask. A straightforward and instructive deployment to test and local networks was demonstrated. This article provides comprehensive guidelines for creating a seamless DApp on the Morph blockchain.

Build a Multi-Payment DApp on Morph with Foundry

Azeez Abidoye — Sat, 19 Oct 2024 13:32:15 +0000

Hello Devs 👋

This tutorial provides a hands-on approach, guiding developers through building a decentralized application (DApp) capable of handling multiple payment types or currencies, while using Foundry—a popular smart contract development framework.

Prerequisites 📚

Node JS (v16 or later)
NPM (v6 or later)
Solidity
Metamask
Testnet ethers
JavaScript

Dev Tools 🛠️

Foundry

curl -L https://foundry.paradigm.xyz | bash

Let's start hacking... 👨‍💻

Step 1: Create a new project directory

mkdir batchsender-dapp

Navigate into the new project directory

cd batchsender-dapp

Step 2: Initialize Foundry framework for smart contract development

✍️ Foundry creates a new git repository; we may prevent this by flagging the command.

forge init --no-git

Foundry file tree:

script
src
test

✍️ Each of these folders contains a file. Delete them one by one to create a clean slate.

Step 3: Create the smart contract code

Navigate to the src directory
Create a new file named Batchsender.sol
Update Batchsender.sol with the following code:

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

contract Batchsender {
    // Custom Error for mismatched recipients and amounts
    error MismatchedArrayLengths(
        uint256 recipientsLength,
        uint256 amountsLength
    );

    // Custom error for insufficient ethers
    error NotEnoughEth();

    // Custom Error for failed transfer
    error TransferFailed(address recipients, uint256 amounts);

    // Event to log each successful transfer
    event TokenSent(address indexed recipients, uint256 amounts);

    // Payable function for Ether transfer
    function sendToken(
        address payable[] calldata recipients,
        uint[] calldata amounts
    ) external payable {
        // Check if recipient length and amount length are the same
        if (recipients.length != amounts.length) {
            revert MismatchedArrayLengths(recipients.length, amounts.length);
        }

        // Calculate the total amount to be sent
        uint totalAmount = 0;
        for (uint i = 0; i < amounts.length; i++) {
            totalAmount += amounts[i];
        }

        // Ensure the sent amount is equal or greater than the total amount
        if (msg.value < totalAmount) {
            revert NotEnoughEth();
        }

        // Loop through recipients array to match recipients to amounts
        for (uint i = 0; i < recipients.length; i++) {
            (bool sendSuccess, ) = recipients[i].call{value: amounts[i]}("");
            if (!sendSuccess) {
                revert TransferFailed(recipients[i], amounts[i]);
            }

            // Emit event for each successful transfer
            emit TokenSent(recipients[i], amounts[i]);
        }
    }
}

Step 4: Compile the smart contract code

forge build

Compilation result:

[⠊] Compiling...
[⠢] Compiling 1 files with Solc 0.8.27
[⠆] Solc 0.8.27 finished in 139.58ms
Compiler run successful!

Step 5: Write solidity code for unit tests

Navigate to the test directory
Create a new file named Batchsender.t.sol
Update Batchsender.t.sol with the following code:

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

import {Test, console} from "forge-std/Test.sol";
import {Batchsender} from "../src/Batchsender.sol";

contract BatchsenderTest is Test {
    Batchsender public batchsender;

    function setUp() public {
        // Deploy the contract before each test
        batchsender = new Batchsender();
    }

    function test_sendToken() public {
        address payable[] memory recipients = new address payable[](2);
        uint[] memory amounts = new uint[](2);
        recipients[0] = payable(0x6c5fa1b41990f4ee402984Bcc8Bf6F4CB769fE74);
        recipients[1] = payable(0x55829bC84132E1449b62607B1c7bbC012f0326Ac);
        amounts[0] = 100; //wei
        amounts[1] = 200; //wei
        batchsender.sendToken{value: 300}(recipients, amounts);
        assertEq(address(recipients[0]).balance, amounts[0]);
        assertEq(address(recipients[1]).balance, amounts[1]);
    }
}

✍️ You can visit vanity-eth.tk to generate new wallet addresses for your test.

Step 6: Running the test

forge test --match-path test/Batchsender.t.sol

Test result should look like this:

[⠊] Compiling...
[⠘] Compiling 24 files with Solc 0.8.27
[⠃] Solc 0.8.27 finished in 733.97ms
Compiler run successful!

Ran 1 test for test/Batchsender.t.sol:BatchsenderTest
[PASS] test_sendToken() (gas: 90741)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 8.33ms (1.46ms CPU time)

Ran 1 test suite in 151.38ms (8.33ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Step 7: Deploying smart contract to Morph Holesky testnet

Create a .env file in the project directory and add three (3) environment variables.

MORPH_RPC_URL="https://rpc-quicknode-holesky.morphl2.io"
DEV_PRIVATE_KEY="0x-insert-your-private-key"    // Prefix with 0x
CONTRACT_ADDRESS=""

✍️ The CONTRACT_ADDRESS information will be added after deployment.

Navigate to the script directory and create a new file named Batchsender.s.sol
Add the following code for smart contract deployment

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

import {Script, console} from "forge-std/Script.sol";
import {Batchsender} from "../src/Batchsender.sol";

contract BatchsenderScript is Script {
    Batchsender public batchsender;

    function setUp() public {}

    function run() public {
        // Save Private key as variable for reusability
        uint privateKey = vm.envUint("DEV_PRIVATE_KEY");

        // start deployment...with Private Key
        vm.startBroadcast(privateKey);

        // Log Account to the console
        address account = vm.addr(privateKey);
        console.log("Deployer Account address: ", account);

        batchsender = new Batchsender();

        vm.stopBroadcast();
    }
}

Step 8: Running the deployment script

Load the environment information into the CLI

source .env

Confirm the deployer's account address

forge script script/Batchsender.s.sol:BatchsenderScript

This execution will return the wallet address associated with the deployer's private key.

[⠊] Compiling...
[⠑] Compiling 2 files with Solc 0.8.27
[⠘] Solc 0.8.27 finished in 650.26ms
Compiler run successful!
Script ran successfully.
Gas used: 259115

== Logs ==
  Deployer Account address:  0x4E1856E40D53e2893803f1da919F5daB713B215c

Simulate the smart contract

forge script script/Batchsender.s.sol:BatchsenderScript --rpc-url $MORPH_RPC_URL

Successful simulation result:

[⠊] Compiling...
No files changed, compilation skipped
Script ran successfully.

== Logs ==
  Deployer Account address:  0x4E1856E40D53e2893803f1da919F5daB713B215c

## Setting up 1 EVM.

==========================

Chain 2810

Estimated gas price: 0.15063575 gwei

Estimated total gas used for script: 340061

Estimated amount required: 0.00005122534378075 ETH

==========================

SIMULATION COMPLETE. To broadcast these transactions, add --broadcast and wallet configuration(s) to the previous command. See forge script --help for more.

✍️ This execution automatically creates a new directory named broadcast in the project for seamless smart contract deployment.

Final execution for smart contract deployment

forge script script/Batchsender.s.sol:BatchsenderScript --rpc-url $MORPH_RPC_URL --broadcast --private-key $DEV_PRIVATE_KEY --legacy

The deployment result should look like this:

[⠊] Compiling...
No files changed, compilation skipped
Script ran successfully.

== Logs ==
  Deployer Account address:  0x4E1856E40D53e2893803f1da919F5daB713B215c

## Setting up 1 EVM.

==========================

Chain 2810

Estimated gas price: 0.14963575 gwei

Estimated total gas used for script: 340061

Estimated amount required: 0.00005088528278075 ETH

==========================

##### 2810
✅  [Success]Hash: 0xe65413c0b8ff406c18c33b77c385bc3d46bcd9305030dd49aa2277d3c90bf69a
Contract Address: 0x8D69CCBf55ce078d9c9838a8861e0c827Dd4f2ff
Block: 11252084
Paid: 0.0000391521939875 ETH (261650 gas * 0.14963575 gwei)

✅ Sequence #1 on 2810 | Total Paid: 0.0000391521939875 ETH (261650 gas * avg 0.14963575 gwei)


==========================

ONCHAIN EXECUTION COMPLETE & SUCCESSFUL.

✍️ Copy the contract address to populate the CONTRACT_ADDRESS environment variable.

Step 9: Integrating the frontend with NextJs

npx create-next-app@latest

✍️ Name your app frontend and select the default configuration for the rest of the prompt.

Step 10: Install plugins for development

Install the three (3) dependencies needed for the development of the client-side of the application.

npm install ethers bootstrap react-csv-importer

Step 11: Creating the frontend component

Open the src directory
The frontend component is structured in the app/page.js file
To start afresh, replace the default code with the following:

"use client"

export default function Home() {
  return ();
}

Update the imports:

"use client"

import { useState } from "react";
import { Importer, ImporterField } from "react-csv-importer";
import { ethers, Contract } from "ethers";

export default function Home() {
  return ();
}

Import the contract ABI:

// Import contract ABI
import {abi as contractABI} from '../../../out/Batchsender.sol/Batchsender.json';

Store the contract address in a variable:

// Contract address
const contractAddress = "0x8D69CCBf55ce078d9c9838a8861e0c827Dd4f2ff";

Create an object variable for the blockchain explorer:

// Blockchain Explorer object
const blockchainExplorerUrl = {
  2810: "https://rpc-quicknode-holesky.morphl2.io",
};

Update the state variables:

// Some code...

export default function Home() {

  // State variables
  const [payments, setPayments] = useState(undefined);
  const [sending, setSending] = useState(false);
  const [blockchainExplorer, setBlockchainExplorer] = useState();
  const [error, setError] = useState(false);
  const [transaction, setTransaction] = useState(false);

  return ();
}

Create the function for sending payments

export default function Home() {
  // Some state variable codes...

    // Function for sending payments
    const sendPayments = async () => {
        // Connect to Metamask
        const provider = new ethers.BrowserProvider(window.ethereum);
        const signer = await provider.getSigner();

        const chainIdBigInt = (await provider.getNetwork()).chainId;
        const chainId = Number(chainIdBigInt); // convert to interger;

        setBlockchainExplorer(blockchainExplorerUrl[chainId.toString()]);

        // Show feedback to users
        setSending(true);

        // Format arguements for smart contract => Convert CSV row to column
        const { recipient, amount, total } = payments.reduce(
          (acc, val) => {
            acc.recipient.push(val.recipient);
            acc.amount.push(val.amount);
            acc.total += Number(val.amount);
            return acc;
          },
          {
            recipient: [],
            amount: [],
            total: 0,
          }
        );

        // Send transaction
        const batchsenderContract = new Contract(
          contractAddress,
          contractABI,
          signer
        );

        try {
          const transaction = await batchsenderContract.sendToken(
            recipient,
            amount,
            {
              value: total,
            }
          );
          const transactionReceipt = await transaction.wait();
          setTransaction(transactionReceipt.hash);
        } catch (error) {
          console.log(error);
          setError(true);
        }
      };

  return ( );
}

Update the JSX component structure:

export default function Home() {

    // Some state variable and function codes...

    return (
        <>
        <div className="container-fluid mt-5 d-flex justify-content-center">
          <div id="content" className="row">
            <div id="content-inner" className="col">
              <div className="text-center">
                <h1 id="title" className="fw-bold">
                  BATCHSENDER
                </h1>
                <p id="sub-title" className="mt-4 fw-bold">
                  Send multiple payments <br />{" "}
                  <span>in just one transaction</span>
                </p>
              </div>
              <Importer
                dataHandler={(rows) => setPayments(rows)}
                defaultNoHeader={false} // optional, keeps "data has headers" checkbox off by default
                restartable={false} // optional, lets user choose to upload another file when import is complete
              >
                <ImporterField name="recipient" label="recipient" />
                <ImporterField name="amount" label="amount" />
                <ImporterField name="asset" label="asset" />
              </Importer>
              <div className="text-center">
                <button
                  className="btn btn-primary mt-5"
                  onClick={sendPayments}
                  disabled={sending || typeof payments === "undefined"}
                >
                  Send transactions
                </button>
              </div>
              {sending && (
                <div className="alert alert-info mt-4 mb-0">
                  Please wait while your transaction is being processed...
                </div>
              )}
              {transaction && (
                <div className="alert alert-success mt-4 mb-0">
                  Congrats! Transaction processed successfully. <br />
                  <a
                    href={`${blockchainExplorer}/${transaction}`}
                    target="_blank"
                  >{`${transaction.substr(0, 20)}...`}</a>
                </div>
              )}
              {error && (
                <div className="alert alert-danger mt-4 mb-0">
                  Oops...there was an error. Please try again later!
                </div>
              )}
            </div>
          </div>
        </div>
      </>
    );
  }

Step 12: Adding styles to the component

Navigate to the src/app directory
Create a new file named style.css
Update style.css with the following code:

#content {
    width: 700px;
  }

  #content-inner {
    background-color: rgba(240, 240, 240);
    border-radius: 10px;
    padding: 1em;
  }

  #title {
    font-family: "Permanent Marker", cursive;
    font-size: 2em;
    font-style: normal;
    font-weight: 400;
  }

  #sub-title {
    font-size: 1.5em;
  }

  #sub-title span {
    border-bottom: 5px solid #085ed6;
  }

  #CSVImporter_Importer {
    margin-top: 3em;
  }

Step 13: Configure the layout structure

Open the layout.js file
Replace the code with the following:

import "bootstrap/dist/css/bootstrap.min.css";
import "react-csv-importer/dist/index.css";
import "./style.css";

export const metadata = {
  title: "Batchsender",
  description: "Make multiple crypto payments in one click",
};

export default function RootLayout({ children }) {
  return (
    <html lang="en">
      <head>
        <link rel="preconnect" href="https://fonts.googleapis.com" />
        <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
        <link
          href="https://fonts.googleapis.com/css2?family=Permanent+Marker&display=swap"
          rel="stylesheet"
        />
      </head>

      <body>{children}</body>
    </html>
  );
}

Step 14: Interacting with the DApp

To start interacting with the DApp, launch project in the browser

npm run dev

Create an Excel spreadsheet containing the information of your transaction in this format:

Recipient	Amount	Asset
Wallet Addr1	50	ETH
Wallet Addr2	100	ETH
Wallet Addr3	200	ETH

Export this file to a Comma Separated Values .csv file
Drag and drop your .csv file on the marked area or click to select one from your files

Select Choose columns to load-up the information
Click the Import button to import the information to the DApp for processing

Select Send transactions to make payments in one click

Conclusion

In this complete guide, we have successfully used the most recent blockchain development tools to build and deploy a dynamic decentralized application on the Morph blockchain, which is a Layer 2 solution that combines the benefits of both zK and Optimistic rollups for secure and rapid transactions.
Happy hacking... 🎉

DEV Community: Azeez Abidoye

5 Important Logics to Understand About Liquidity Book Pair

Introduction: Trader Joe

1. Architectural Overview

Code Walkthrough

Contract Declaration & Modifiers

State Variables (The Storage)

Core Functions

Imports and Dependencies

OpenZeppelin Contracts

Custom Interfaces

Custom Libraries (Math & Logic)

2. LBToken & ILBToken Integration

Roles & Interaction

3. Core Logic and Use Cases

4. Security Review

5. Real-World Context

Conclusion

Build Your First FHE Smart Contract with Fhenix: A Hands-On Beginner's Guide

What is FHE (Fully Homomorphic Encryption)?

Prerequisites 🛠️

Let the hacking begin... 👨‍💻

Step 1: Initialize the FHE project & navigate into the new project directory

Step 2: Install dependencies

Folder Structure 📚

Code Walkthrough: Line by Line 🔍

Comparison: FHE vs. Standard Boilerplate 📝

Step 3: Compile the contract

Step 4: Test with Mock Environment

Step 5: Configure test network

Step 6: Setup environment variables

Step 7: Deploying the contract

Interacting with the contract

Conclusion

The Complete Guide to Solidity Inheritance

What is solidity?

What Does Inheritance Mean?

How Inheritance Works in Solidity

Understanding Function Overriding.

Practical Real-World Use Cases

Common Mistakes and How to Avoid them

Best Practices for Using Inheritance

Conclusion

[Boost]

Optimize Gas Usage and Build Efficient Smart Contracts on CrossFi

Optimize Gas Usage and Build Efficient Smart Contracts on CrossFi

What is Gas Optimization? 🤷‍♂️

What It’s Like to Optimize Gas ⚙️

Why CrossFi? 🤔

Prerequisites 📚

Dev Tools ⚒️

Step 1: Create & open project directory

Step 2: Initialize a new project

Step 3: Install Hardhat package

Step 4: Initialize new Hardhat framework

Step 5: Set up ENV

Step 6: [Optional] Delete old files

Step 7: Configure framework

Step 8: Create Solidity smart contract

Step 9: Compile Contract

Step 10: Setup Contract for deployment

Step 11: Deploy Contract on CrossFi Testnet

Bonus: 🎁 Gas Optimization Tools

APPROACH ♻️

Efficiency Techniques 📊

TL;DR: 🧠

Conclusion

Writing Unit Tests for CrossFi DApp with Mocha & Chai

Overview

Developing a Rental DApp on CrossFi Using Hardhat

Dev Tool 🛠️

Writing unit tests with Mocha and Chai

First, make sure you have the required dependencies installed.

Create a new file for the Test Script

Understanding the Test Script

Test Cases Explained

Updating the Test Script

Conclusion

Developing a Rental DApp on CrossFi Using Hardhat

What's CrossFi?

2. `LBToken` & `ILBToken` Integration