DEV Community: Neeraj Choubisa

Building a Fungible Token in Compact (Midnight)

Neeraj Choubisa — Fri, 03 Apr 2026 20:35:07 +0000

The rise of privacy-focused blockchains like Midnight is introducing developers to a new paradigm of smart contract development using Compact language.

If you are coming from Solidity, things may feel unfamiliar at first, especially concepts like inheritance, storage, and function definitions.

In this article, you will learn how fungible tokens work in Compact, why inheritance does not exist, how to build your own token step by step, and how to fix common errors.

Understanding Compact

Compact does not support inheritance like Solidity.

Instead of writing:
contract MyToken is ERC20

Compact uses modules and composition. This means you import functionality and explicitly use it. There is no hidden behavior.

Understanding the FungibleToken Module

The FungibleToken module provides core token functionality such as balances tracking, allowances, transfers, minting and burning, and metadata like name, symbol, and decimals.

There are a few differences compared to ERC20:
It uses Uint<128> instead of uint256
There are no events
Contract to contract transfers are not supported yet

Step 1: Import the Module

import "./token/FungibleToken.compact" prefix FT_;

Step 2: Create Your Token Contract

pragma language_version >= 0.21.0;

import "./token/FungibleToken.compact" prefix FT_;

contract CustomFungibleToken {

  circuit init(): [] {
    FT_.initialize("Nikku Token", "NIK", 18);

    const owner = left<ZswapCoinPublicKey, ContractAddress>(ownPublicKey());
    FT_._mint(owner, 1000000);
  }

  circuit transfer(
    to: Either<ZswapCoinPublicKey, ContractAddress>,
    amount: Uint<128>
  ): Boolean {
    return FT_.transfer(to, amount);
  }

  circuit balanceOf(
    account: Either<ZswapCoinPublicKey, ContractAddress>
  ): Uint<128> {
    return FT_.balanceOf(account);
  }
}

Step 3: Compile the Contract

Run the following command:

npm run compile

Key Concepts to Remember

Compact does not support inheritance.
You must use circuit instead of function definitions.
Modules manage their own storage.
Initialization is required and must not be skipped.

Current Limitations

Contract to contract calls are not supported.
Events are not available.
Only 128 bit integers are supported.

Mental Model

Instead of thinking that your contract extends ERC20, think of it as using a token module and calling its functions.

What You Can Build Next

You can extend this basic token to add mint restrictions, implement fees, or build more advanced applications on Midnight.

Final Thoughts

Compact encourages explicit and predictable contract design. While it may take some time to adjust, it leads to better security and modularity.

Once you understand this pattern, building on Midnight becomes much easier.

About Author ?

Hi, I’m Nikku.Dev, a Full Stack Blockchain Developer and builder. I work on smart contracts, DeFi systems, and Web3 applications, focusing on building real, scalable products.

Portfolio: https://nikkudotdev.vercel.app/

GitHub: https://github.com/Kali-Decoder

DUST vs NIGHT: Rethinking How Blockchains Handle Value and Fees

Neeraj Choubisa — Tue, 31 Mar 2026 12:34:28 +0000

In most blockchains, one token does everything it stores value and pays for transactions. For example, on Ethereum you use ETH for both holding value and paying gas fees, and on Bitcoin BTC serves a similar dual purpose.

But Midnight takes a radically different approach.

Instead of one token doing everything, Midnight splits responsibilities between NIGHT and DUST and that small design decision unlocks huge advantages for developers, users, and businesses.

What is NIGHT?

NIGHT is the main token of Midnight the one that holds value and powers the ecosystem.
Key Characteristics:

Fixed supply (24 billion)
Public (unshielded)

Used for:

Governance & voting
Staking & consensus
Block rewards
Exchange trading

👉 Think of NIGHT as your asset layer — the token you own, hold, and invest in.

What is DUST?

DUST is not a traditional token — it’s a resource generated by NIGHT.

You don’t buy it.
You don’t trade it.
You earn it automatically by holding NIGHT.

How it works:

You register NIGHT to a DUST address
Over time, it generates DUST
You use DUST to pay transaction fees

👉 Think of NIGHT as solar panels and DUST as electricity.

Key Properties of DUST

Shielded (Private)

DUST transactions are hidden — meaning:

- No public fee tracking
- No visible activity graph

Non-transferable

You can’t send DUST to others It’s only used to pay fees
Leftover DUST returns to you .

Decaying Mechanism

If you stop backing DUST with NIGHT, it decays to zero
Prevents hoarding and speculation

Dynamic Balance

Unlike normal tokens: Your DUST increases over time
Depends on how much NIGHT you hold .

Shielded vs Unshielded Tokens

Midnight goes further by letting developers choose:

Token Privacy:

Unshielded → public (like ETH)
Shielded → private via ZK proofs

Token Location:

Ledger-based → high performance
Contract-based → programmable

👉 This flexibility is unique in blockchain design.

Viewing Keys: Selective Transparency

Need compliance or auditing?

Share a viewing key
Others can see your private transactions
But nothing becomes publicly visible

⚠️ Important: Viewing keys are irreversible once shared.

Final Thoughts

The **DUST vs NIGHT **model is more than a token split it’s a fundamental redesign of blockchain economics.

What Midnight achieves:

Stable and predictable fees
Strong privacy guarantees
Protection from MEV attacks
Better onboarding experience
Flexible identity and token systems

About Author ?

Hi, I’m Nikku.Dev, a Full Stack Blockchain Developer and builder. I work on smart contracts, DeFi systems, and Web3 applications, focusing on building real, scalable products.

Portfolio: https://nikkudotdev.vercel.app/

GitHub: https://github.com/Kali-Decoder

Running a Validator on Push Chain: A Builder’s Guide

Neeraj Choubisa — Fri, 27 Mar 2026 01:33:14 +0000

The future of decentralized infrastructure isn’t just about building apps it’s about running the network itself.

If you’ve ever wanted to go deeper than smart contracts and actually participate in consensus, running a validator on Push Chain is one of the easiest ways to get started.

In this guide, we’ll break down what a validator is, why it matters, and how you can spin one up in minutes.

What is a Validator?

A validator is a node that:

Verifies transactions
Produces new blocks
Secures the blockchain

Push Chain uses a Proof-of-Stake (PoS) model, meaning validators stake tokens to participate in the network and earn rewards.

Think of it like this:

Instead of just building on the blockchain, you’re helping run it.

Why Run a Validator on Push Chain?

Push Chain makes validator setup extremely developer friendly. Here’s why it stands out:

Simple CLI-based setup — no complex configs
Fast sync using snapshots — no need to download full history
Auto-upgrades with Cosmovisor
Built-in dashboard for monitoring
Earn rewards + participate in governance

Whether you're a builder, DevRel, or infra enthusiast this is a great way to level up.

Prerequisites

Before you begin, make sure you have:

A Linux/macOS machine (or VPS)
Basic terminal knowledge
Testnet tokens (PC tokens)
Stable internet connection

Step 1: Install & Start the Node

Run the following command:

curl -fsSL https://get.push.network/node/install.sh | bash

This script does everything for you:

Installs dependencies
Sets up the node
Starts syncing using snapshots

⏱️ You’ll be up and running in about 5–20 minutes.

Step 2: Check Sync Status

To check if your node is fully synced:

push-validator status

You’re good to go when you see:

Catching Up: false

Step 3: Register as a Validator

Now comes the important part:

push-validator register-validator

You’ll be prompted to configure:

Wallet (create/import)
Validator name (moniker)
Commission rate
Stake amount (~1.5 PC minimum)

Once done 🎉 you’re officially a validator!

Step 4: Monitor Your Node

Run:

push-validator dashboard

This opens a real-time CLI dashboard showing:

Node health
Sync status
Validator performance
Logs and peers

It’s like having a lightweight DevOps panel in your terminal.

Useful Commands

Here are some commands you’ll frequently use:

push-validator start
push-validator stop
push-validator logs
push-validator withdraw-rewards
push-validator restake-rewards
push-validator unjail

These help you manage, debug, and optimize your validator.

💸 How Do You Earn?

Validators earn rewards by:

Validating blocks
Receiving delegations from others
Charging commission

The more stake you have (self + delegated), the higher your rewards.

Important Tips

Keep your seed phrase safe
Ensure uptime (avoid downtime penalties)
Set a reasonable commission
Monitor performance regularly

Final Thoughts

Running a validator isn’t just about earning rewards it’s about:

Supporting decentralization
Gaining deeper infra knowledge
Becoming a core part of the ecosystem

Push Chain removes the usual complexity and makes validator operations accessible to every builder.

If you’re already building in Web3, running a validator is your next power move.

What’s Next?

Try running a validator on testnet
Experiment with staking strategies
Explore Push Chain’s universal apps

And most importantly don’t just build on the network, help run it.

About Author ?

Hi, I’m NikkuDotDev, a Full Stack Blockchain Developer and builder. I work on smart contracts, DeFi systems, and Web3 applications, focusing on building real, scalable products.

Portfolio: https://nikkudotdev.vercel.app/

GitHub: https://github.com/Kali-Decoder

Midnight Blockchain Architecture ( Layman Explanation )

Neeraj Choubisa — Tue, 24 Mar 2026 20:22:33 +0000

Midnight is a special type of blockchain that focuses on privacy and trust together. Most blockchains are fully transparent, but Midnight allows you to keep important data private while still proving that everything is correct.

To understand Midnight, think of it as three main parts working together:

Partner Chain (network and security)
Kachina (private smart contracts)
Compact (developer layer)

Let’s break this down in a simple way.

1. The Main Problem Midnight Solves

In normal blockchains:

Everyone can see all data Smart contracts run publicly No privacy for users

This creates a problem called private shared state.

Example
A company wants to store employee salaries on blockchain
But salaries should be private

So how do you:
Keep data private Still trust the system

Midnight solves this by separating:
Verification from Visibility
This means the network checks if something is correct without seeing the actual data .

2. Partner Chain Architecture (Security Layer)

Midnight is connected to Cardano using something called a Partner Chain.

Simple meaning: Midnight runs its own network But uses Cardano’s ecosystem for security .
How it works
Validators (block producers) can be Cardano stake pool operators
The system uses:
AURA for block production GRANDPA for finality

Midnight nodes also track data from Cardano using tools like database sync systems .

Real Life Example
Think of Midnight like a startup company
And Cardano like a trusted parent company
Midnight builds new features (privacy apps)
Cardano provides trust and reliability

3. Kachina Model (Privacy Layer)

Kachina is the core idea that makes privacy possible.
It splits data into two parts:

Public State
Stored on blockchain
Visible to everyone
Private State
Stored on user device
Never shared publicly

These two are connected using zero knowledge proofs
Meaning:
You can prove something is correct without showing the data

Real Life Example
Imagine online voting:
Your vote stays on your device (private)
The system proves you voted correctly
Blockchain only stores final count
No one knows your vote
But everyone trusts the result

4. Compact (Developer Layer)

Compact is the language used to write smart contracts on Midnight.

But unlike normal blockchains:
You are not writing code that runs directly on chain

Instead, you are writing:

A circuit
That generates a proof
Then the blockchain verifies that proof
Three Parts of a Contract
Public part (on blockchain)
Private logic (runs locally)
Proof generation

This design ensures:

Private data never goes to blockchain
Only proofs are shared

5. How a Transaction Works (Simple Flow)

Here is what happens step by step:

User runs contract locally
Private data is used (not shared)
A proof is generated
Proof is sent to blockchain
Blockchain verifies proof
Public state updates

If proof is wrong → transaction fails !!!!

6. Real Life End to End Example

Example: Loan Approval System

A user wants a loan but does not want to share full financial data.

Traditional system:
Upload salary, bank details
Data is exposed

Midnight system:
User keeps data locally

Contract checks:
income > required limit
Generates proof
Blockchain verifies proof
Loan approved

Result:

Bank trusts the decision
User data stays private

About Author :

I'm builder and founder focused on Web3 infrastructure, smart contracts, and developer tools. I specialize in turning complex blockchain ideas into scalable, real-world products across DeFi, cross-chain systems, and AI-integrated applications.

I’ve worked across multiple ecosystems building production-grade dApps, while also contributing to developer communities through hackathons, content, and open-source. My focus is on building products that are not just technically sound, but actually usable and impactful.

Portfolio: https://nikkudotdev.vercel.app/
GitHub: https://github.com/Kali-Decoder
Contribution : https://github.com/Kali-Decoder/midnight-dapps

The Builder’s Guide to Tokens : on the Midnight Network

Neeraj Choubisa — Tue, 24 Mar 2026 09:14:47 +0000

Blockchain is powerful because it is open and transparent. But that also creates a problem. Everyone can see everything, which is not always good when dealing with sensitive data. This is called the transparency paradox.

Midnight Network solves this problem by bringing privacy into blockchain while still keeping trust and compliance. It is built as a Cardano sidechain and focuses on something called rational privacy. This means users can keep important data private while still proving things when needed.

As Midnight moves toward its mainnet phase called Kūkolu in 2026, this guide explains how developers can build and manage tokens on the network.

The Token Economy with NIGHT and DUST

Midnight uses two tokens instead of one. Each has a clear role.

NIGHT is the main token. It is visible on the network and is used for staking, governance, and security. The total supply is fixed at 24 billion.

DUST is very different. It is private and cannot be transferred between users. It is used to pay for transactions and smart contract execution.

The interesting part is how DUST is created. When you hold NIGHT, you automatically generate DUST over time. This is often called the battery model.

This system gives developers a big advantage. Costs become predictable because you are not dependent on changing gas fees like in other blockchains.

Developer Stack Made Simple

Midnight is designed so developers do not need deep knowledge of cryptography.

Smart contracts are written in a language called Compact. It is similar to TypeScript, so it feels familiar if you have done web development.

There is also a full SDK called Midnight.js. It helps you interact with contracts, manage wallets, and build applications easily.

For privacy, Midnight uses a Local Proof Server. This runs on the user’s machine and creates zero knowledge proofs. This means private data never leaves the device.

Step by Step Guide to Build a Token

Here is a simple flow to create and deploy a token on Midnight.

First, set up your environment. Install the Compact compiler, Midnight CLI, and Docker for running a local network.
Next, set up your wallet. Use Lace Wallet and switch to the Midnight Preview Network. You can get test tokens called tDUST from the faucet.
Then write your smart contract. Create a Compact file where you define how your token works. This includes minting, burning, and transfers.
After that, test locally. Use the Local Proof Server to generate proofs and check everything before sending transactions.
Finally, deploy your contract. Compile it and deploy using the Midnight CLI to the test network. Later you can deploy to mainnet.

Security for Real World Applications

For production use, security is very important.

Midnight supports OpenZeppelin Compact Libraries. These are tested and secure building blocks that help you create safe smart contracts.

You can use them to build tokens, NFTs, identity systems, and more.

Why Midnight is Important ?

Midnight brings a new approach to blockchain.

It gives privacy without removing trust. It makes costs predictable. It provides simple tools for developers. It also helps in building applications that follow regulations.

This makes it useful for finance, identity, enterprise apps, and many other use cases.

Final Thoughts

Midnight solves one of the biggest problems in blockchain. It allows developers to build applications that are both private and trustworthy.

With its dual token system, zero knowledge technology, and easy development tools, it is a strong platform for the future of Web3.

About Author :

Portfolio: https://nikkudotdev.vercel.app/
GitHub: https://github.com/Kali-Decoder
Contribution : https://github.com/Kali-Decoder/midnight-dapps

Somnia On-Chain Reactivity

Neeraj Choubisa — Mon, 16 Feb 2026 14:06:10 +0000

Building Reactive Smart Contracts on Somnia
A Developer Guide with Real Solidity Examples

1. Introduction

As Web3 developers, we often build systems that require automatic reactions.

Examples from real projects like onchain games, PotWar pools, prediction markets:

Last player wins when timer ends
Auto reward after chest open
Pool auto payout
NFT level up after XP
DAO proposal auto execute

With traditional smart contracts, this requires:

• Backend server
• Event indexer
• Cron jobs
• Extra user transactions

This increases complexity, cost, and centralization.

Somnia On-Chain Reactivity solves this by allowing smart contracts to automatically react to events fully on-chain.

2. What is Somnia On-Chain Reactivity?

Somnia lets smart contracts execute logic automatically when subscribed events occur.

Traditional Flow :

User Action → Event → Backend Listener → New Tx → State Update
Somnia Reactive Flow :

User Action → Event → Validator Detect → _onEvent() → State Update

No backend.
No extra user gas.
Fully decentralized.

3. Why This Matters for Web3 Devs

For builders working on gaming, DeFi, or automation:

No server infra
Less latency
Cleaner architecture
Better UX
Faster hackathon builds

For example, in Last Player Standing, we don’t need a backend timer contract logic can react automatically.

4. Example: Magic Chest Reactive Game

Let’s build a small game.

Game Rules

Common chest → +10 coins
Rare chest → +50 coins
Legendary chest → NFT sword

Player opens chest → reward auto given.

5. Solidity Contract Example

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

import { SomniaEventHandler }
from "@somnia-chain/reactivity-contracts/contracts/SomniaEventHandler.sol";

contract MagicChestReactiveGame is SomniaEventHandler {

    event ChestOpened(address indexed player, uint256 chestType);

    mapping(address => uint256) public coins;
    mapping(address => bool) public hasSword;

    bytes32 constant CHEST_SIG =
        keccak256("ChestOpened(address,uint256)");

    uint256 constant COMMON = 1;
    uint256 constant RARE = 2;
    uint256 constant LEGENDARY = 3;

    function openChest(uint256 chestType) external {
        emit ChestOpened(msg.sender, chestType);
    }

    function _onEvent(
        address,
        bytes32[] calldata topics,
        bytes calldata data
    ) internal override {

        require(topics[0] == CHEST_SIG, "Wrong event");

        address player =
            address(uint160(uint256(topics[1])));
        uint256 chestType =
            abi.decode(data, (uint256));

        if (chestType == COMMON)
            coins[player] += 10;
        else if (chestType == RARE)
            coins[player] += 50;
        else if (chestType == LEGENDARY)
            hasSword[player] = true;
    }
}

6. How Reactivity Works Internally

Player calls openChest()
Event emitted
Somnia validators detect subscription
_onEvent() executes automatically
State updated
No extra transaction required.

Reactive tx is executed by validator address:

0x0000000000000000000000000000000000000100

7. Creating a Subscription for the event :

import { SDK } from "@somnia-chain/reactivity";
import { privateKeyToAccount } from "viem/accounts";
import { createPublicClient, createWalletClient, http } from "viem";
import { somniaTestnet } from "viem/chains";
import { keccak256, toBytes } from "viem";

const CONTRACT = "0xYourContractAddress";

async function main() {

  const account = privateKeyToAccount(
    process.env.PRIVATE_KEY as `0x${string}`
  );

  const publicClient = createPublicClient({
    chain: somniaTestnet,
    transport: http(),
  });

  const walletClient = createWalletClient({
    account,
    chain: somniaTestnet,
    transport: http(),
  });

  const sdk = new SDK({
    public: publicClient,
    wallet: walletClient
  });

  const EVENT_SIG = keccak256(
    toBytes("ChestOpened(address,uint256)")
  );

  const txHash = await sdk.createSoliditySubscription({
    handlerContractAddress: CONTRACT,
    emitter: CONTRACT,
    eventTopics: [EVENT_SIG],
    gasLimit: 3_000_000n,
  });

  const receipt = await publicClient.waitForTransactionReceipt({
    hash: txHash,
  });

  // 👉 Extract subscriptionId
  const log = receipt.logs[0];
  const subscriptionId = BigInt(log.topics[2]);

  console.log("Subscription ID:", subscriptionId.toString());
}

main();

Important Notes

Need 32 STT balance
Save subscription ID
Event signature must match exactly

Now after subscribing event that we have to trigger from reactivity we need to test this ,

Testing Reactivity

After subscription, test contract.

import { ethers } from "hardhat";

const CONTRACT = "0xYourContractAddress";

async function main() {

  const [user] = await ethers.getSigners();

  const game = await ethers.getContractAt(
    "MagicChestReactiveGame",
    CONTRACT
  );

  const before = await game.coins(user.address);
  console.log("Coins before:", before.toString());

  const tx = await game.openChest(1);
  await tx.wait();

  console.log("Waiting for Somnia reactivity...");
  await new Promise(r => setTimeout(r,15000));

  const after = await game.coins(user.address);
  console.log("Coins after:", after.toString());

  if(after > before)
    console.log("✅ Reactivity Working");
  else
    console.log("❌ No Reactivity");
}

main();

Real Use Cases

Gaming
- Last Player Standing
- PotWar auto payout
- Loot rewards
- NFT upgrades
Prediction Markets
- Prediction auto reward
- Score updates
DeFi
- Liquidations
- Yield distribution
DAO
- Proposal auto execute

Conclusion

Somnia On-Chain Reactivity removes backend dependency and enables fully autonomous smart contracts.

For developers building automated gaming logic, prediction markets, or DeFi automation, this unlocks a new level of scalability and simplicity.

The future of Web3 apps is reactive.

Neeraj Choubisa (Nikku.Dev) is a Full-Stack Blockchain Engineer specializing in smart contract development, Web3 integrations, and consumer-focused decentralized applications.

🔗 Twitter

🔗 Github
🔗 LinkedIn

<>Building a Cross-Chain Swap with LayerZero on Monad

Neeraj Choubisa — Mon, 16 Jun 2025 07:20:21 +0000

We will build a DApp with LayerZero that allows users to bridge and swap MON tokens from Monad testnet to ETH tokens on Sepolia testnet.

How Does Layer Zero Works ?

Any cross-chain communication protocol requires an off-chain entity to send messages to and from. However, this creates a centralization risk.

Here's how LayerZero organizes its' infrastructure:

LayerZero deployed a smart contract as an endpoint on each supported blockchain. This endpoint serves as a point of assembly for all cross-chain messages. Endpoints are to LayerZero what airports are to air travel.
An off-chain relayer listens to these endpoints and picks up messages as they arrive. LayerZero lets us run our own relayer, lowering the risk of centralization.
However, LayerZero only partially relies on a relayer to deliver these messages. In practice, a relayer works with an oracle that confirms or denies the validity of a transaction.
The messages are delivered to their destination only if both independent entities agree on the validity of a transaction.
A relayer is usually paired with decentralized oracle networks like Chainlink to ensure reliability, although, in theory, we can also develop our own.

Creating a New Hardhat Project

npx hardhat init

This LayerZero example repository contains all the interfaces and abstract contracts we need to talk to the on-chain LayerZero endpoints. We also need the Openzeppelin-contracts library to work with access control in our smart contracts.

To download these repos into our Hardhat project, we run the following:

npm install LayerZero-Labs/solidity-examples

We will work with version 0.8.19 of the Solidity compiler. To ensure hardhat uses this exact version to compile all of the Solidity code, we add this line to the hardhat.config.ts file in our project directory:

const config: HardhatUserConfig = { solidity: "0.8.18", };

Inside the contract directory, delete Lock.sol and create two files new files instead.

- Monad_Swap.sol
- Sepolia_Swap.sol

The first will become the endpoint on the Monad testnet and the other on Sepolia.

Creating the Base Contract

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import "@layerzero-contracts/lzApp/NonblockingLzApp.sol";

contract Monad_Swap is NonblockingLzApp {
  // the implementation will go here
}

NonblockingLzApp is an abstract contract built on underlying LayerZero contracts. The purpose of this contract is to make it easier for devs to interact with the on-chain contracts.

Adding the Variables

    // State variables for the contract    
    uint16 public destChainId;
    bytes payload;
    address payable deployer;
    address payable contractAddress = payable(address(this));

    // Instance of the LayerZero endpoint
    ILayerZeroEndpoint public immutable endpoint;

The destChainId variable represents the destination chain's address, not the chain we deploy this contract to. While sending a cross-chain message using LayerZero, we need to specify the address of the intended destination.

Note: These aren't the Chain IDs you might know. To quote the LayerZero docs: "chainId values are not related to EVM IDs. Since LayerZero will span EVM & non-EVM chains the chainId are proprietary to our Endpoints." Meaning, LayerZero maintains its own set of Chain IDs to identify blockchains that differ from the normally used numbers. We can find the full reference in their docs.

Payload holds the message we send as bytes. This variable is an ABI-encoded amalgamation of everything we want to send across the chain.

We initialize the deployer variable in the constructor to the contract owner.

The contractAddress represents the contract address we know after deployment. We also initialize it in the constructor.

The endpoint variable is an instance of ILayerZeroEndpoint interface; we use it to interact with the on-chain endpoints. For an example, check out their Monad endpoint on Monad Explorer.

Implementing the Constructor

  constructor(address _lzEndpoint) NonblockingLzApp(_lzEndpoint) {
    deployer = payable(msg.sender);
    endpoint = ILayerZeroEndpoint(_lzEndpoint);

    // If Source == Sepolia, then Destination Chain = Monad
    if (_lzEndpoint == 0x6EDCE65403992e310A62460808c4b910D972f10f)
    destChainId = 40204;

    // If Source == Monad, then Destination Chain = Sepolia
    if (_lzEndpoint == 0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff)
    destChainId = 40161;
  }

We must pass the address of the on-chain endpoint to the NonblockingLzApp contract for a successful initialization.

In this example, we have written two if-statements that automatically assign the Chain ID based on the address of the endpoint contract. If we deployed the contract on Monad, the destChainId variable will point to Sepolia, and vice-versa.

Interlude: How do Smart Contracts Interact with the LayerZero Protocol?
We are now ready to write the two main functions we need to use the LayerZero protocol. But before that, let us take a conceptual detour.

For any smart contract, interacting with the on-chain LayerZero endpoint is a two-part process:

First, we call the send() function on the endpoint to send a message. To be clear, this is a function we call on an already deployed contract, not something we define.

Second, we define the _nonblockingLzReceive function in your contract. Any contract that wants to receive cross-chain messages must have this function defined in their contract. The LayerZero endpoint calls this function on our contract to deliver an incoming message. To be clear: We do not call this function; we just define it!

Implementing the swapTo_ETH Function
Let us now define the main swap function. We create a new function named swapTo_ETH and define it as follows:

function swapTo_ETH(address Receiver) public payable {
    require(msg.value >= 1 ether, "Please send at least 1 Monad");
    uint value = msg.value;

    bytes memory trustedRemote = trustedRemoteLookup[destChainId];
    require(trustedRemote.length != 0, "LzApp: destination chain is not a trusted source");
    _checkPayloadSize(destChainId, payload.length);

    // The message is encoded as bytes and stored in the "payload" variable.
    payload = abi.encode(Receiver, value);

    endpoint.send{value: 15 ether}(destChainId, trustedRemote, payload, contractAddress, address(0x0), bytes(""));
}

First, we ensure the user has sent at least 1 ETH in value while calling the function.

A function named setTrustedRemoteAddress inside the contract we inherit allows us to designate trusted contracts. This way, we can ensure our contract only interacts with trusted code. trustedRemoteLookup[destChainId] returns the endpoint address from the other chain we trust. The _checkPayloadSize function ensures our payload size is within acceptable limits.

Next, we pack the data we want to send into a single variable of type bytes using abi.encode(). In our case, we ask the user to tell us the destination address on the other side.

Finally, we call the send() and transfer 15 ETH from our own smart contract to pay for the gas.

Note: I can already hear you shouting: "15 ETH! What the hell is going on here?"
We need to pay some gas fees to the endpoint for the execution of our transaction. The actual fee isn't 15 ETH. However, in my experience, transactions that were accompanied by less gas didn't execute.
While we set 15 ETH in this swap implementation, we get back all unused ETH. 15 ETH is just a buffer to ensure the transaction goes through.
LayerZero does have functions like estimateGasFees() that allow us to estimate the amount of gas that needs to be sent, but I found it to be inaccurate.

Implementing the _nonblockingLzReceive Function
Well, this is how we send a message to the Sepolia testnet, but what if we receive a message from there?

To make sure our contract is ready to handle incoming messages, we need to implement a function named _nonblockingLzReceive:

function _nonblockingLzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) internal override {

    (address Receiver , uint Value) = abi.decode(_payload, (address, uint));
    address payable recipient = payable(Receiver);        
    recipient.transfer(Value);
}

This is the function that LayerZero calls upon our contract to deliver a message. We know what we encoded on the other end. So, we can decode it into a recipient's address and an integer value representing the amount in Wei that we locked into the contract on the other end.

Next, we transfer that value to the recipient by calling the transfer() function. Monad and ETH are two very different assets with wildly different values. In any practical implementation of a cross-chain swap, we would use an oracle to coordinate real-time price mediation between the two assets. For this example, we will assume an exchange rate of 1:1.

Lastly, we will wrap up the contract code with two simple functions:

    // Fallback function to receive ether
    receive() external payable {}

    /**
     * @dev Allows the owner to withdraw all funds from the contract.
     */
    function withdrawAll() external onlyOwner {
        deployer.transfer(address(this).balance);
    }
}

The Complete Contract for Monad
After adding a few comments, this is what the finished Monad_Swap.sol should look like:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import "@layerzero-contracts/lzApp/NonblockingLzApp.sol";

/**
 * @title Monad_Swap
 * @dev This contract sends a cross-chain message from Mumbai to Sepolia to transfer ETH in return for deposited Monad.
 */
contract Monad_Swap is NonblockingLzApp {
    // State variables for the contract
    uint16 public destChainId;
    bytes payload;
    address payable deployer;
    address payable contractAddress = payable(address(this));

    // Instance of the LayerZero endpoint
    ILayerZeroEndpoint public immutable endpoint;

    /**
     * @dev Constructor that initializes the contract with the LayerZero endpoint.
     * @param _lzEndpoint Address of the LayerZero endpoint.
     */
    constructor(address _lzEndpoint) NonblockingLzApp(_lzEndpoint) {
        deployer = payable(msg.sender);
        endpoint = ILayerZeroEndpoint(_lzEndpoint);

        // If Source == Sepolia, then Destination Chain = Monad
        if (_lzEndpoint == 0x6EDCE65403992e310A62460808c4b910D972f10f)
            destChainId = 40204;

        // If Source == Monad, then Destination Chain = Sepolia
        if (_lzEndpoint == 0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff)
            destChainId = 40161;
    }

    /**
     * @dev Allows users to swap to ETH.
     * @param Receiver Address of the receiver.
     */
  function swapTo_ETH(address Receiver) public payable {
    require(msg.value >= 1 ether, "Please send at least 1 Monad");
    uint value = msg.value;

    bytes memory trustedRemote = trustedRemoteLookup[destChainId];
    require(trustedRemote.length != 0, "LzApp: destination chain is not a trusted source");
    _checkPayloadSize(destChainId, payload.length);

    // The message is encoded as bytes and stored in the "payload" variable.
    payload = abi.encode(Receiver, value);

    endpoint.send{value: 15 ether}(destChainId, trustedRemote, payload, contractAddress, address(0x0), bytes(""));
}

    /**
     * @dev Internal function to handle incoming LayerZero messages.
     */
    function _nonblockingLzReceive(
        uint16 _srcChainId,
        bytes memory _srcAddress,
        uint64 _nonce,
        bytes memory _payload
    ) internal override {
        (address Receiver, uint Value) = abi.decode(_payload, (address, uint));
        address payable recipient = payable(Receiver);
        recipient.transfer(Value);
    }

    // Fallback function to receive ether
    receive() external payable {}

    /**
     * @dev Allows the owner to withdraw all funds from the contract.
     */
    function withdrawAll() external onlyOwner {
        deployer.transfer(address(this).balance);
    }
}

The Complete Sepolia Contract
The Sepolia counterpart of this contract is almost the same, just the other way around.

Now, inside Sepolia_Swap.sol, paste the following code:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import "@layerzero-contracts/lzApp/NonblockingLzApp.sol";

/**
 * @title Sepolia_Swap
 * @dev This contract sends a cross-chain message from Sepolia to Monad to transfer Monad in return for deposited ETH.
 */
contract Sepolia_Swap is NonblockingLzApp {

    // State variables for the contract
    address payable deployer;    
    uint16 public destChainId;
    bytes payload;    
    address payable contractAddress = payable(address(this));

    // Instance of the LayerZero endpoint
    ILayerZeroEndpoint public immutable endpoint;

    /**
     * @dev Constructor that initializes the contract with the LayerZero endpoint.
     * @param _lzEndpoint Address of the LayerZero endpoint.
     */
    constructor(address _lzEndpoint) NonblockingLzApp(_lzEndpoint) {
        deployer = payable(msg.sender);
        endpoint = ILayerZeroEndpoint(_lzEndpoint);

         // If Source == Sepolia, then Destination Chain = Monad
        if (_lzEndpoint == 0x6EDCE65403992e310A62460808c4b910D972f10f)
            destChainId = 40204;

        // If Source == Monad, then Destination Chain = Sepolia
        if (_lzEndpoint == 0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff)
            destChainId = 40161;
    }

    /**
     * @dev Allows users to swap to Monad.
     * @param Receiver Address of the receiver.
     */
    function swapTo_Monad(address Receiver) public payable {
        require(msg.value >= 1 ether, "Please send at least 1 ETH");
        uint value = msg.value;

        bytes memory trustedRemote = trustedRemoteLookup[destChainId];
        require(trustedRemote.length != 0, "LzApp: destination chain is not a trusted source");
        _checkPayloadSize(destChainId, payload.length);

        // The message is encoded as bytes and stored in the "payload" variable.
        payload = abi.encode(Receiver, value);

        endpoint.send{value: 15 ether}(destChainId, trustedRemote, payload, contractAddress, address(0x0), bytes(""));
    }

    /**
     * @dev Internal function to handle incoming LayerZero messages.
     */
    function _nonblockingLzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) internal override {
        (address Receiver , uint Value) = abi.decode(_payload, (address, uint));
        address payable recipient = payable(Receiver);        
        recipient.transfer(Value);
    }

    // Fallback function to receive ether
    receive() external payable {}

    /**
     * @dev Allows the owner to withdraw all funds from the contract.
     */
    function withdrawAll() external onlyOwner {
        deployer.transfer(address(this).balance);
    }
}

Compile the Contracts
npx hardhat compile

This command might print some warnings, but we can ignore them.

Creating the .env File
We need to add our sensitive information in a .env file to store it securely. So, we create one at the root of our project and fill it with this:

BASE_SEPOLIA_RPC_URL=
MONAD_RPC_URL=
DEPLOYER_ACCOUNT_PRIV_KEY=

Let's Go For Scripts

import { ethers } from "hardhat";

async function deployMonadSwap() {
  const CONTRACT_NAME = "Monad_Swap";
  const lzAddressMonad = "0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff";
  const monadSwap = await ethers.deployContract(CONTRACT_NAME, [
    lzAddressMonad,
  ]);
  await monadSwap.waitForDeployment();
  console.log(
    "Deployed Monad Swap Contract Address:",
    await monadSwap.getAddress()
  );
}

async function main() {
  await deployMonadSwap();
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

Run : 
nikku.jr.dev@Neerajs-MacBook-Air swap-layerzero % npx hardhat run scripts/deploy_monad_swap.ts --network monad
Deployed Monad Swap Contract Address: 0xf9Ccd4509d3049ceFe62F800a44b3d66943D0308

Similar for Base Sepolia :

nikku.jr.dev@Neerajs-MacBook-Air swap-layerzero % npx hardhat run scripts/deploy_sepolia_swap.ts --network baseSepolia 

Deployed Sepolia Swap Contract Address: 0xd0eBE4D0E7C6a7786942c3dcD1390a0C8EE84040

Connecting the Two Contracts
Remember how we can use the setTrustedRemoteAddress() to designate trusted contracts? We need to tell each endpoint of its counterparts so they can call each other.

On Base Sepolia, we call the function with the following params:

_remoteChainId = 40204 (LayerZero Chain ID for Monad)
_remoteAddress = Address of our Monad Swap contract


On Monad, call the function with the following params:

_remoteChainId = 40245 (LayerZero Chain ID for Base Sepolia)
_remoteAddress = Address of the Base Sepolia contract


Lastly, we ensure to send MON and ETH to each contract. Remember, the contracts are the ones paying for gas, so we have to send 30 each to both of the contracts. (I know very hectic because of faucets not available right now ) 😂

Conclusion
With the robust capabilities of LayerZero, our solution stands ready to facilitate a seamless 1:1 swap between MON and ETH.

Should any queries or thoughts arise, don't hesitate to get in touch with me on Twitter. I'm always eager to engage and assist.

Here's to the boundless possibilities of cross-chain innovations!

Twitter
Linkedin

<>Building a Cross-Chain Swap with LayerZero on Monad

Neeraj Choubisa — Mon, 17 Mar 2025 16:06:34 +0000

We will build a DApp with LayerZero that allows users to bridge and swap MON tokens from Monad testnet to ETH tokens on Sepolia testnet.

How Does Layer Zero Works ?

Any cross-chain communication protocol requires an off-chain entity to send messages to and from. However, this creates a centralization risk.

Here's how LayerZero organizes its' infrastructure:

LayerZero deployed a smart contract as an endpoint on each supported blockchain. This endpoint serves as a point of assembly for all cross-chain messages. Endpoints are to LayerZero what airports are to air travel.
An off-chain relayer listens to these endpoints and picks up messages as they arrive. LayerZero lets us run our own relayer, lowering the risk of centralization.
However, LayerZero only partially relies on a relayer to deliver these messages. In practice, a relayer works with an oracle that confirms or denies the validity of a transaction.
The messages are delivered to their destination only if both independent entities agree on the validity of a transaction.
A relayer is usually paired with decentralized oracle networks like Chainlink to ensure reliability, although, in theory, we can also develop our own.

Creating a New Hardhat Project

npx hardhat init

To download these repos into our Hardhat project, we run the following:

npm install LayerZero-Labs/solidity-examples

const config: HardhatUserConfig = {
  solidity: "0.8.18",
};

Inside the contract directory, delete Lock.sol and create two files new files instead.

- Monad_Swap.sol
- Sepolia_Swap.sol

The first will become the endpoint on the Monad testnet and the other on Sepolia.

Creating the Base Contract

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import "@layerzero-contracts/lzApp/NonblockingLzApp.sol";

contract Monad_Swap is NonblockingLzApp {
  // the implementation will go here
}

NonblockingLzApp is an abstract contract built on underlying LayerZero contracts. The purpose of this contract is to make it easier for devs to interact with the on-chain contracts.

Adding the Variables

    // State variables for the contract    
    uint16 public destChainId;
    bytes payload;
    address payable deployer;
    address payable contractAddress = payable(address(this));

    // Instance of the LayerZero endpoint
    ILayerZeroEndpoint public immutable endpoint;

Note: These aren't the Chain IDs you might know. To quote the LayerZero docs: "chainId values are not related to EVM IDs. Since LayerZero will span EVM & non-EVM chains the chainId are proprietary to our Endpoints." Meaning, LayerZero maintains its own set of Chain IDs to identify blockchains that differ from the normally used numbers. We can find the full reference in their docs.

Payload holds the message we send as bytes. This variable is an ABI-encoded amalgamation of everything we want to send across the chain.

We initialize the deployer variable in the constructor to the contract owner.

The contractAddress represents the contract address we know after deployment. We also initialize it in the constructor.

The endpoint variable is an instance of ILayerZeroEndpoint interface; we use it to interact with the on-chain endpoints. For an example, check out their Monad endpoint on Monad Explorer.

Implementing the Constructor

  constructor(address _lzEndpoint) NonblockingLzApp(_lzEndpoint) {
    deployer = payable(msg.sender);
    endpoint = ILayerZeroEndpoint(_lzEndpoint);

    // If Source == Sepolia, then Destination Chain = Monad
    if (_lzEndpoint == 0x6EDCE65403992e310A62460808c4b910D972f10f)
    destChainId = 40204;

    // If Source == Monad, then Destination Chain = Sepolia
    if (_lzEndpoint == 0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff)
    destChainId = 40161;
  }

We must pass the address of the on-chain endpoint to the NonblockingLzApp contract for a successful initialization.

For any smart contract, interacting with the on-chain LayerZero endpoint is a two-part process:

First, we call the send() function on the endpoint to send a message. To be clear, this is a function we call on an already deployed contract, not something we define.

Implementing the swapTo_ETH Function
Let us now define the main swap function. We create a new function named swapTo_ETH and define it as follows:

function swapTo_ETH(address Receiver) public payable {
    require(msg.value >= 1 ether, "Please send at least 1 Monad");
    uint value = msg.value;

    bytes memory trustedRemote = trustedRemoteLookup[destChainId];
    require(trustedRemote.length != 0, "LzApp: destination chain is not a trusted source");
    _checkPayloadSize(destChainId, payload.length);

    // The message is encoded as bytes and stored in the "payload" variable.
    payload = abi.encode(Receiver, value);

    endpoint.send{value: 15 ether}(destChainId, trustedRemote, payload, contractAddress, address(0x0), bytes(""));
}

First, we ensure the user has sent at least 1 ETH in value while calling the function.

Next, we pack the data we want to send into a single variable of type bytes using abi.encode(). In our case, we ask the user to tell us the destination address on the other side.

Finally, we call the send() and transfer 15 ETH from our own smart contract to pay for the gas.

Note: I can already hear you shouting: "15 ETH! What the hell is going on here?"
We need to pay some gas fees to the endpoint for the execution of our transaction. The actual fee isn't 15 ETH. However, in my experience, transactions that were accompanied by less gas didn't execute.
While we set 15 ETH in this swap implementation, we get back all unused ETH. 15 ETH is just a buffer to ensure the transaction goes through.
LayerZero does have functions like estimateGasFees() that allow us to estimate the amount of gas that needs to be sent, but I found it to be inaccurate.

Implementing the _nonblockingLzReceive Function
Well, this is how we send a message to the Sepolia testnet, but what if we receive a message from there?

To make sure our contract is ready to handle incoming messages, we need to implement a function named _nonblockingLzReceive:

function _nonblockingLzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) internal override {

    (address Receiver , uint Value) = abi.decode(_payload, (address, uint));
    address payable recipient = payable(Receiver);        
    recipient.transfer(Value);
}

Lastly, we will wrap up the contract code with two simple functions:

    // Fallback function to receive ether
    receive() external payable {}

    /**
     * @dev Allows the owner to withdraw all funds from the contract.
     */
    function withdrawAll() external onlyOwner {
        deployer.transfer(address(this).balance);
    }
}

The Complete Contract for Monad
After adding a few comments, this is what the finished Monad_Swap.sol should look like:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import "@layerzero-contracts/lzApp/NonblockingLzApp.sol";

/**
 * @title Monad_Swap
 * @dev This contract sends a cross-chain message from Mumbai to Sepolia to transfer ETH in return for deposited Monad.
 */
contract Monad_Swap is NonblockingLzApp {
    // State variables for the contract
    uint16 public destChainId;
    bytes payload;
    address payable deployer;
    address payable contractAddress = payable(address(this));

    // Instance of the LayerZero endpoint
    ILayerZeroEndpoint public immutable endpoint;

    /**
     * @dev Constructor that initializes the contract with the LayerZero endpoint.
     * @param _lzEndpoint Address of the LayerZero endpoint.
     */
    constructor(address _lzEndpoint) NonblockingLzApp(_lzEndpoint) {
        deployer = payable(msg.sender);
        endpoint = ILayerZeroEndpoint(_lzEndpoint);

        // If Source == Sepolia, then Destination Chain = Monad
        if (_lzEndpoint == 0x6EDCE65403992e310A62460808c4b910D972f10f)
            destChainId = 40204;

        // If Source == Monad, then Destination Chain = Sepolia
        if (_lzEndpoint == 0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff)
            destChainId = 40161;
    }

    /**
     * @dev Allows users to swap to ETH.
     * @param Receiver Address of the receiver.
     */
  function swapTo_ETH(address Receiver) public payable {
    require(msg.value >= 1 ether, "Please send at least 1 Monad");
    uint value = msg.value;

    bytes memory trustedRemote = trustedRemoteLookup[destChainId];
    require(trustedRemote.length != 0, "LzApp: destination chain is not a trusted source");
    _checkPayloadSize(destChainId, payload.length);

    // The message is encoded as bytes and stored in the "payload" variable.
    payload = abi.encode(Receiver, value);

    endpoint.send{value: 15 ether}(destChainId, trustedRemote, payload, contractAddress, address(0x0), bytes(""));
}

    /**
     * @dev Internal function to handle incoming LayerZero messages.
     */
    function _nonblockingLzReceive(
        uint16 _srcChainId,
        bytes memory _srcAddress,
        uint64 _nonce,
        bytes memory _payload
    ) internal override {
        (address Receiver, uint Value) = abi.decode(_payload, (address, uint));
        address payable recipient = payable(Receiver);
        recipient.transfer(Value);
    }

    // Fallback function to receive ether
    receive() external payable {}

    /**
     * @dev Allows the owner to withdraw all funds from the contract.
     */
    function withdrawAll() external onlyOwner {
        deployer.transfer(address(this).balance);
    }
}

The Complete Sepolia Contract
The Sepolia counterpart of this contract is almost the same, just the other way around.

Now, inside Sepolia_Swap.sol, paste the following code:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import "@layerzero-contracts/lzApp/NonblockingLzApp.sol";

/**
 * @title Sepolia_Swap
 * @dev This contract sends a cross-chain message from Sepolia to Monad to transfer Monad in return for deposited ETH.
 */
contract Sepolia_Swap is NonblockingLzApp {

    // State variables for the contract
    address payable deployer;    
    uint16 public destChainId;
    bytes payload;    
    address payable contractAddress = payable(address(this));

    // Instance of the LayerZero endpoint
    ILayerZeroEndpoint public immutable endpoint;

    /**
     * @dev Constructor that initializes the contract with the LayerZero endpoint.
     * @param _lzEndpoint Address of the LayerZero endpoint.
     */
    constructor(address _lzEndpoint) NonblockingLzApp(_lzEndpoint) {
        deployer = payable(msg.sender);
        endpoint = ILayerZeroEndpoint(_lzEndpoint);

         // If Source == Sepolia, then Destination Chain = Monad
        if (_lzEndpoint == 0x6EDCE65403992e310A62460808c4b910D972f10f)
            destChainId = 40204;

        // If Source == Monad, then Destination Chain = Sepolia
        if (_lzEndpoint == 0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff)
            destChainId = 40161;
    }

    /**
     * @dev Allows users to swap to Monad.
     * @param Receiver Address of the receiver.
     */
    function swapTo_Monad(address Receiver) public payable {
        require(msg.value >= 1 ether, "Please send at least 1 ETH");
        uint value = msg.value;

        bytes memory trustedRemote = trustedRemoteLookup[destChainId];
        require(trustedRemote.length != 0, "LzApp: destination chain is not a trusted source");
        _checkPayloadSize(destChainId, payload.length);

        // The message is encoded as bytes and stored in the "payload" variable.
        payload = abi.encode(Receiver, value);

        endpoint.send{value: 15 ether}(destChainId, trustedRemote, payload, contractAddress, address(0x0), bytes(""));
    }

    /**
     * @dev Internal function to handle incoming LayerZero messages.
     */
    function _nonblockingLzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) internal override {
        (address Receiver , uint Value) = abi.decode(_payload, (address, uint));
        address payable recipient = payable(Receiver);        
        recipient.transfer(Value);
    }

    // Fallback function to receive ether
    receive() external payable {}

    /**
     * @dev Allows the owner to withdraw all funds from the contract.
     */
    function withdrawAll() external onlyOwner {
        deployer.transfer(address(this).balance);
    }
}

Compile the Contracts
npx hardhat compile

This command might print some warnings, but we can ignore them.

Creating the .env File
We need to add our sensitive information in a .env file to store it securely. So, we create one at the root of our project and fill it with this:

BASE_SEPOLIA_RPC_URL=
MONAD_RPC_URL=
DEPLOYER_ACCOUNT_PRIV_KEY=

Let's Go For Scripts

import { ethers } from "hardhat";

async function deployMonadSwap() {
  const CONTRACT_NAME = "Monad_Swap";
  const lzAddressMonad = "0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff";
  const monadSwap = await ethers.deployContract(CONTRACT_NAME, [
    lzAddressMonad,
  ]);
  await monadSwap.waitForDeployment();
  console.log(
    "Deployed Monad Swap Contract Address:",
    await monadSwap.getAddress()
  );
}

async function main() {
  await deployMonadSwap();
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

Run : 
nikku.jr.dev@Neerajs-MacBook-Air swap-layerzero % npx hardhat run scripts/deploy_monad_swap.ts --network monad
Deployed Monad Swap Contract Address: 0xf9Ccd4509d3049ceFe62F800a44b3d66943D0308

Similar for Base Sepolia :

nikku.jr.dev@Neerajs-MacBook-Air swap-layerzero % npx hardhat run scripts/deploy_sepolia_swap.ts --network baseSepolia 

Deployed Sepolia Swap Contract Address: 0xd0eBE4D0E7C6a7786942c3dcD1390a0C8EE84040

Connecting the Two Contracts
Remember how we can use the setTrustedRemoteAddress() to designate trusted contracts? We need to tell each endpoint of its counterparts so they can call each other.

On Base Sepolia, we call the function with the following params:

_remoteChainId = 40204 (LayerZero Chain ID for Monad)
_remoteAddress = Address of our Monad Swap contract


On Monad, call the function with the following params:

_remoteChainId = 40245 (LayerZero Chain ID for Base Sepolia)
_remoteAddress = Address of the Base Sepolia contract


Lastly, we ensure to send MON and ETH to each contract. Remember, the contracts are the ones paying for gas, so we have to send 30 each to both of the contracts. (I know very hectic because of faucets not available right now ) 😂

Conclusion
With the robust capabilities of LayerZero, our solution stands ready to facilitate a seamless 1:1 swap between MON and ETH.

Should any queries or thoughts arise, don't hesitate to get in touch with me on Twitter. I'm always eager to engage and assist.

Here's to the boundless possibilities of cross-chain innovations!

Twitter
Linkedin

<>Building a Cross-Chain Swap with LayerZero on Monad

Neeraj Choubisa — Mon, 17 Mar 2025 16:06:34 +0000

We will build a DApp with LayerZero that allows users to bridge and swap MON tokens from Monad testnet to ETH tokens on Sepolia testnet.

How Does Layer Zero Works ?

Any cross-chain communication protocol requires an off-chain entity to send messages to and from. However, this creates a centralization risk.

Here's how LayerZero organizes its' infrastructure:

LayerZero deployed a smart contract as an endpoint on each supported blockchain. This endpoint serves as a point of assembly for all cross-chain messages. Endpoints are to LayerZero what airports are to air travel.
An off-chain relayer listens to these endpoints and picks up messages as they arrive. LayerZero lets us run our own relayer, lowering the risk of centralization.
However, LayerZero only partially relies on a relayer to deliver these messages. In practice, a relayer works with an oracle that confirms or denies the validity of a transaction.
The messages are delivered to their destination only if both independent entities agree on the validity of a transaction.
A relayer is usually paired with decentralized oracle networks like Chainlink to ensure reliability, although, in theory, we can also develop our own.

Creating a New Hardhat Project

npx hardhat init

To download these repos into our Hardhat project, we run the following:

npm install LayerZero-Labs/solidity-examples

const config: HardhatUserConfig = { solidity: "0.8.18", };

Inside the contract directory, delete Lock.sol and create two files new files instead.

- Monad_Swap.sol
- Sepolia_Swap.sol

The first will become the endpoint on the Monad testnet and the other on Sepolia.

Creating the Base Contract

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import "@layerzero-contracts/lzApp/NonblockingLzApp.sol";

contract Monad_Swap is NonblockingLzApp {
  // the implementation will go here
}

NonblockingLzApp is an abstract contract built on underlying LayerZero contracts. The purpose of this contract is to make it easier for devs to interact with the on-chain contracts.

Adding the Variables

    // State variables for the contract    
    uint16 public destChainId;
    bytes payload;
    address payable deployer;
    address payable contractAddress = payable(address(this));

    // Instance of the LayerZero endpoint
    ILayerZeroEndpoint public immutable endpoint;

Note: These aren't the Chain IDs you might know. To quote the LayerZero docs: "chainId values are not related to EVM IDs. Since LayerZero will span EVM & non-EVM chains the chainId are proprietary to our Endpoints." Meaning, LayerZero maintains its own set of Chain IDs to identify blockchains that differ from the normally used numbers. We can find the full reference in their docs.

Payload holds the message we send as bytes. This variable is an ABI-encoded amalgamation of everything we want to send across the chain.

We initialize the deployer variable in the constructor to the contract owner.

The contractAddress represents the contract address we know after deployment. We also initialize it in the constructor.

The endpoint variable is an instance of ILayerZeroEndpoint interface; we use it to interact with the on-chain endpoints. For an example, check out their Monad endpoint on Monad Explorer.

Implementing the Constructor

  constructor(address _lzEndpoint) NonblockingLzApp(_lzEndpoint) {
    deployer = payable(msg.sender);
    endpoint = ILayerZeroEndpoint(_lzEndpoint);

    // If Source == Sepolia, then Destination Chain = Monad
    if (_lzEndpoint == 0x6EDCE65403992e310A62460808c4b910D972f10f)
    destChainId = 40204;

    // If Source == Monad, then Destination Chain = Sepolia
    if (_lzEndpoint == 0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff)
    destChainId = 40161;
  }

We must pass the address of the on-chain endpoint to the NonblockingLzApp contract for a successful initialization.

For any smart contract, interacting with the on-chain LayerZero endpoint is a two-part process:

First, we call the send() function on the endpoint to send a message. To be clear, this is a function we call on an already deployed contract, not something we define.

Implementing the swapTo_ETH Function
Let us now define the main swap function. We create a new function named swapTo_ETH and define it as follows:

function swapTo_ETH(address Receiver) public payable {
    require(msg.value >= 1 ether, "Please send at least 1 Monad");
    uint value = msg.value;

    bytes memory trustedRemote = trustedRemoteLookup[destChainId];
    require(trustedRemote.length != 0, "LzApp: destination chain is not a trusted source");
    _checkPayloadSize(destChainId, payload.length);

    // The message is encoded as bytes and stored in the "payload" variable.
    payload = abi.encode(Receiver, value);

    endpoint.send{value: 15 ether}(destChainId, trustedRemote, payload, contractAddress, address(0x0), bytes(""));
}

First, we ensure the user has sent at least 1 ETH in value while calling the function.

Next, we pack the data we want to send into a single variable of type bytes using abi.encode(). In our case, we ask the user to tell us the destination address on the other side.

Finally, we call the send() and transfer 15 ETH from our own smart contract to pay for the gas.

Note: I can already hear you shouting: "15 ETH! What the hell is going on here?"
We need to pay some gas fees to the endpoint for the execution of our transaction. The actual fee isn't 15 ETH. However, in my experience, transactions that were accompanied by less gas didn't execute.
While we set 15 ETH in this swap implementation, we get back all unused ETH. 15 ETH is just a buffer to ensure the transaction goes through.
LayerZero does have functions like estimateGasFees() that allow us to estimate the amount of gas that needs to be sent, but I found it to be inaccurate.

Implementing the _nonblockingLzReceive Function
Well, this is how we send a message to the Sepolia testnet, but what if we receive a message from there?

To make sure our contract is ready to handle incoming messages, we need to implement a function named _nonblockingLzReceive:

function _nonblockingLzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) internal override {

    (address Receiver , uint Value) = abi.decode(_payload, (address, uint));
    address payable recipient = payable(Receiver);        
    recipient.transfer(Value);
}

Lastly, we will wrap up the contract code with two simple functions:

    // Fallback function to receive ether
    receive() external payable {}

    /**
     * @dev Allows the owner to withdraw all funds from the contract.
     */
    function withdrawAll() external onlyOwner {
        deployer.transfer(address(this).balance);
    }
}

The Complete Contract for Monad
After adding a few comments, this is what the finished Monad_Swap.sol should look like:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import "@layerzero-contracts/lzApp/NonblockingLzApp.sol";

/**
 * @title Monad_Swap
 * @dev This contract sends a cross-chain message from Mumbai to Sepolia to transfer ETH in return for deposited Monad.
 */
contract Monad_Swap is NonblockingLzApp {
    // State variables for the contract
    uint16 public destChainId;
    bytes payload;
    address payable deployer;
    address payable contractAddress = payable(address(this));

    // Instance of the LayerZero endpoint
    ILayerZeroEndpoint public immutable endpoint;

    /**
     * @dev Constructor that initializes the contract with the LayerZero endpoint.
     * @param _lzEndpoint Address of the LayerZero endpoint.
     */
    constructor(address _lzEndpoint) NonblockingLzApp(_lzEndpoint) {
        deployer = payable(msg.sender);
        endpoint = ILayerZeroEndpoint(_lzEndpoint);

        // If Source == Sepolia, then Destination Chain = Monad
        if (_lzEndpoint == 0x6EDCE65403992e310A62460808c4b910D972f10f)
            destChainId = 40204;

        // If Source == Monad, then Destination Chain = Sepolia
        if (_lzEndpoint == 0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff)
            destChainId = 40161;
    }

    /**
     * @dev Allows users to swap to ETH.
     * @param Receiver Address of the receiver.
     */
  function swapTo_ETH(address Receiver) public payable {
    require(msg.value >= 1 ether, "Please send at least 1 Monad");
    uint value = msg.value;

    bytes memory trustedRemote = trustedRemoteLookup[destChainId];
    require(trustedRemote.length != 0, "LzApp: destination chain is not a trusted source");
    _checkPayloadSize(destChainId, payload.length);

    // The message is encoded as bytes and stored in the "payload" variable.
    payload = abi.encode(Receiver, value);

    endpoint.send{value: 15 ether}(destChainId, trustedRemote, payload, contractAddress, address(0x0), bytes(""));
}

    /**
     * @dev Internal function to handle incoming LayerZero messages.
     */
    function _nonblockingLzReceive(
        uint16 _srcChainId,
        bytes memory _srcAddress,
        uint64 _nonce,
        bytes memory _payload
    ) internal override {
        (address Receiver, uint Value) = abi.decode(_payload, (address, uint));
        address payable recipient = payable(Receiver);
        recipient.transfer(Value);
    }

    // Fallback function to receive ether
    receive() external payable {}

    /**
     * @dev Allows the owner to withdraw all funds from the contract.
     */
    function withdrawAll() external onlyOwner {
        deployer.transfer(address(this).balance);
    }
}

The Complete Sepolia Contract
The Sepolia counterpart of this contract is almost the same, just the other way around.

Now, inside Sepolia_Swap.sol, paste the following code:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import "@layerzero-contracts/lzApp/NonblockingLzApp.sol";

/**
 * @title Sepolia_Swap
 * @dev This contract sends a cross-chain message from Sepolia to Monad to transfer Monad in return for deposited ETH.
 */
contract Sepolia_Swap is NonblockingLzApp {

    // State variables for the contract
    address payable deployer;    
    uint16 public destChainId;
    bytes payload;    
    address payable contractAddress = payable(address(this));

    // Instance of the LayerZero endpoint
    ILayerZeroEndpoint public immutable endpoint;

    /**
     * @dev Constructor that initializes the contract with the LayerZero endpoint.
     * @param _lzEndpoint Address of the LayerZero endpoint.
     */
    constructor(address _lzEndpoint) NonblockingLzApp(_lzEndpoint) {
        deployer = payable(msg.sender);
        endpoint = ILayerZeroEndpoint(_lzEndpoint);

         // If Source == Sepolia, then Destination Chain = Monad
        if (_lzEndpoint == 0x6EDCE65403992e310A62460808c4b910D972f10f)
            destChainId = 40204;

        // If Source == Monad, then Destination Chain = Sepolia
        if (_lzEndpoint == 0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff)
            destChainId = 40161;
    }

    /**
     * @dev Allows users to swap to Monad.
     * @param Receiver Address of the receiver.
     */
    function swapTo_Monad(address Receiver) public payable {
        require(msg.value >= 1 ether, "Please send at least 1 ETH");
        uint value = msg.value;

        bytes memory trustedRemote = trustedRemoteLookup[destChainId];
        require(trustedRemote.length != 0, "LzApp: destination chain is not a trusted source");
        _checkPayloadSize(destChainId, payload.length);

        // The message is encoded as bytes and stored in the "payload" variable.
        payload = abi.encode(Receiver, value);

        endpoint.send{value: 15 ether}(destChainId, trustedRemote, payload, contractAddress, address(0x0), bytes(""));
    }

    /**
     * @dev Internal function to handle incoming LayerZero messages.
     */
    function _nonblockingLzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) internal override {
        (address Receiver , uint Value) = abi.decode(_payload, (address, uint));
        address payable recipient = payable(Receiver);        
        recipient.transfer(Value);
    }

    // Fallback function to receive ether
    receive() external payable {}

    /**
     * @dev Allows the owner to withdraw all funds from the contract.
     */
    function withdrawAll() external onlyOwner {
        deployer.transfer(address(this).balance);
    }
}

Compile the Contracts
npx hardhat compile

This command might print some warnings, but we can ignore them.

Creating the .env File
We need to add our sensitive information in a .env file to store it securely. So, we create one at the root of our project and fill it with this:

BASE_SEPOLIA_RPC_URL=
MONAD_RPC_URL=
DEPLOYER_ACCOUNT_PRIV_KEY=

Let's Go For Scripts

import { ethers } from "hardhat";

async function deployMonadSwap() {
  const CONTRACT_NAME = "Monad_Swap";
  const lzAddressMonad = "0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff";
  const monadSwap = await ethers.deployContract(CONTRACT_NAME, [
    lzAddressMonad,
  ]);
  await monadSwap.waitForDeployment();
  console.log(
    "Deployed Monad Swap Contract Address:",
    await monadSwap.getAddress()
  );
}

async function main() {
  await deployMonadSwap();
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

Run : 
nikku.jr.dev@Neerajs-MacBook-Air swap-layerzero % npx hardhat run scripts/deploy_monad_swap.ts --network monad
Deployed Monad Swap Contract Address: 0xf9Ccd4509d3049ceFe62F800a44b3d66943D0308

Similar for Base Sepolia :

nikku.jr.dev@Neerajs-MacBook-Air swap-layerzero % npx hardhat run scripts/deploy_sepolia_swap.ts --network baseSepolia 

Deployed Sepolia Swap Contract Address: 0xd0eBE4D0E7C6a7786942c3dcD1390a0C8EE84040

Connecting the Two Contracts
Remember how we can use the setTrustedRemoteAddress() to designate trusted contracts? We need to tell each endpoint of its counterparts so they can call each other.

On Base Sepolia, we call the function with the following params:

_remoteChainId = 40204 (LayerZero Chain ID for Monad)
_remoteAddress = Address of our Monad Swap contract


On Monad, call the function with the following params:

_remoteChainId = 40245 (LayerZero Chain ID for Base Sepolia)
_remoteAddress = Address of the Base Sepolia contract


Lastly, we ensure to send MON and ETH to each contract. Remember, the contracts are the ones paying for gas, so we have to send 30 each to both of the contracts. (I know very hectic because of faucets not available right now ) 😂

Conclusion
With the robust capabilities of LayerZero, our solution stands ready to facilitate a seamless 1:1 swap between MON and ETH.

Should any queries or thoughts arise, don't hesitate to get in touch with me on Twitter. I'm always eager to engage and assist.

Here's to the boundless possibilities of cross-chain innovations!

Twitter
Linkedin

IEO: DComm Success

Neeraj Choubisa — Sat, 02 Dec 2023 07:44:03 +0000

Hello Everyone Welcome to another Blog where we learn and see how we can invest and subscribe to this event which is the IEO Initial Exchange Offering.

I'm @Dev3Role a full-stack Developer and Blogger. Without Any Wasting time let's start the blog.

What is IEO?

An IEO or initial exchange offering refers to an event where the sale of tokens is conducted through an established mode of exchanging crypto. It is a way start-up organizations raise capital by selling utility tokens that confer preferred status with the organization via a crypto exchange platform.

How is IEO Worked?

Firstly, a verification procedure takes place to prevent scams rampant with ICOs.
The exchange platforms carry out several checks before a sale’s commencement to ensure that the new digital currency is what it claims to be.Also, a white paper is necessary.
Here is the link of Paper :- White Paper.This is similar to an academic paper and serves to educate and inform investors about the project.

The paper includes Team Vision , Marketing Strategy , Why developers and Investors are interested in this and Tokonomics Defined very clearly.

Here is Coinstore where the $DCM exchange is happening.

These are some points that we have to look at in Project :

Unique selling points or claims of the currency
Demand and tokenomics for it in cryptocurrency
Background of the team which is behind the project
Examining the underlying technology

`Recently DComm launched their IEO which has some impressive results let's look at them and use them as an investing strategy like what we have to look while investing in crypto.

Spotlight the total amount oversold - $751,622.04 USD, which is an impressive 751.62% over our initial target.`

The company has additional upcoming projects, and it's advisable to explore these initiatives for potential investment or contributions. Projects with a focus on sustainability and community development are particularly appealing, given the expansive growth potential of this community and the recognized influence of the DComm chain. Conducting research on these future endeavors will allow for informed decisions, aligning investments or contributions with the company's commitment to fostering sustainability and community building, leveraging the strengths of the DComm chain.

Let's Discuss Some Advantages of IEO :

IEO platforms provide investors with an improved user experience in comparison to ICOs.
There is a lesser risk of fraud, as IEOs are regulated per the exchange’s set rules.
As IEOs are conducted via third-party exchanges, they run smoothly. Exchange platforms oversee the transactions and can also provide marketing and development support.
IEOs are not open to the public but only to the exchange platform’s existing members.
Investors are more confident when token sales occur via a trusted crypto exchange platform. This also offers the project more credibility and legitimacy, attracting further investments.

Go Ahead And invest in Dcomm IEO

@Dev3Role

Follow for more Updates :
Linkedin
Github

Crypto Investment Tips

Neeraj Choubisa — Mon, 27 Nov 2023 07:46:49 +0000

What is cryptocurrency?

A digital currency where the creation of units of currency and the verification of transactions for the transfer of funds is controlled by code that is based on encryption. A cryptocurrency is not supported by any nation's government or central bank. The accounting is handled in a dispersed fashion. Consider it like a distributed ledger where transactions cannot be changed in order.

What are the most important factors when deciding to invest in a cryptocurrency project?

Whitepaper Analysis
Review the project's whitepaper. It should provide comprehensive details about the technology, purpose, team, tokenomics, and roadmap.

Team and Development
Assess the experience and expertise of the development team. A skilled and transparent team is crucial for project success.

Community
A strong and engaged community can indicate a healthy project. Evaluate the project's presence on social media, forums, and community channels.

Token Performance and Liquidity
Analyze the historical performance of the project's token, considering factors like price volatility and liquidity.

One of the main factor : Tokenomics and Economics
Understand the tokenomics of the project, including the total supply, distribution, and any mechanisms for controlling inflation or deflation.

All the factors play an important role so go through each factor while investing in any crypto-related project. Once check their community how they are active and growing on socials.

@Dev3Role.

Happy Coding.

Impact of Real-World Asset Tokenization

Neeraj Choubisa — Thu, 23 Nov 2023 16:42:50 +0000

Hey, Welcome Again to @Dev.Three Blogs

Let's kick off our exploration by asking: What exactly is Asset Tokenization?

Asset tokenization is a process where real-world assets, like real estate or art, are converted into digital tokens on a blockchain. It can be any blockchain depending on the Speed we choose a particular blockchain.

These tokens represent ownership or a share in the underlying asset. It's like turning a physical asset into digital pieces that can be bought, sold, and traded more easily. Breaking assets into smaller pieces and selling them one by one. Let's take an example in Collectibles things :

Imagine you have a valuable painting. Through asset tokenization, you can convert ownership of that painting into digital tokens. Now, instead of selling the entire painting, you can sell or trade these tokens, allowing multiple people to own a portion of the artwork.

This makes it simpler to invest in and trade assets that might traditionally be less liquid or easily divisible.

What are the Advantages of Tokenization of Real World Assets?

Increased Liquidity
Accessibility
24/7 Market
Fractional Ownership
Reduced Costs

Dcomm is actively engaged in the process of

Tokenizing solar energy investments, highlighting the role of decentralized finance (DeFi) in facilitating renewable energy funding.
Additionally, the company is championing the tokenization of carbon credits as a crucial step toward advancing sustainability.
Furthermore, Dcomm envisions the future of energy grids to be decentralized, tokenized, and blockchain-powered, emphasizing the transformative potential of these technologies.

The commitment to sustainability, the pursuit of asset liquidity, and the desire for global market integration underscores the importance of asset tokenization in these initiatives.

Congratulations & Happy Coding !!! 🎊

Go Ahead And More Learn About Dcomm

@Dev.Three

Follow for more Updates :
Linkedin
Github
Portfolio