Jagveer Singh (Backend-Sr. Lead Development)

In the rapidly evolving landscape of blockchain technology, interoperability has become a key focus for businesses and developers alike. One area experiencing explosive growth is the world of NFT development services. As NFTs (non-fungible tokens) extend their reach across multiple blockchain networks, the need for secure and efficient mechanisms to transfer these assets between chains is more urgent than ever. In this comprehensive guide, we provide a step-by-step tutorial on building a cross-chain NFT bridge. This tutorial is designed for B2B professionals and developers seeking to enhance their technical capabilities while leveraging cutting-edge blockchain interoperability.

In this tutorial, we cover the underlying concepts, necessary architecture, coding examples, and best practices for deploying a robust cross-chain NFT bridge. By the end, you will understand the entire process—from setting up your development environment to deploying smart contracts and building off-chain relayers—allowing you to implement a solution tailored to your business needs.

Understanding Cross-Chain NFT Bridges

What Is a Cross-Chain NFT Bridge?

A cross-chain NFT bridge is a mechanism that allows NFTs to move seamlessly between two or more blockchain networks. With NFTs primarily built on blockchains such as Ethereum, Binance Smart Chain, or Solana, cross-chain bridges enable asset liquidity and wider market participation. The process generally involves locking an NFT on the source blockchain and minting a corresponding representation on the destination blockchain.

Why Cross-Chain Bridges Are Essential

• Interoperability: Businesses often operate across multiple blockchain networks. A cross-chain NFT bridge helps in integrating assets and liquidity across these diverse environments.
• Market Expansion: By allowing NFTs to exist on multiple chains, projects can access broader markets and communities, enhancing overall value.
• Cost Efficiency: Some blockchains offer lower transaction fees or faster confirmations, making cross-chain transfers attractive for cost-sensitive operations.
• Resilience and Redundancy: Diversifying assets across chains can enhance security and mitigate risks associated with a single-chain failure.

Also, Read | Building a Solana NFT Rarity Ranking Tool

Architecture and Key Components

Core Components of a Cross-Chain NFT Bridge

Smart Contracts on Source and Destination Chains:

• Locking Contract: Responsible for locking the NFT on the source chain.
• Minting Contract: Handles the minting or releasing of the NFT on the destination chain.

Relayer or Oracle System:

• A trusted intermediary (or set of nodes) that listens for events (e.g., NFT locked) on the source chain and triggers corresponding actions on the destination chain.

User Interface (UI):

• A frontend portal that allows users to initiate NFT transfers, view statuses, and receive notifications.

Off-Chain Orchestration Layer:

• A backend service that manages communication between the source and destination chains, ensuring data integrity and security.

Also, Check | Building a Cross-Chain NFT Bridge using Solana Wormhole

How It Works

Locking Phase:

The NFT owner initiates a transfer by locking their NFT in the source chain's smart contract. This action triggers an event that is detected by the relayer.

Verification Phase:

The relayer verifies the locking transaction and prepares to mint a representation on the destination chain.

Minting Phase:

Once verified, the relayer calls the minting contract on the destination chain to create a new NFT that corresponds to the locked asset.

Reversal Process:

The process can be reversed to move the NFT back to the original chain by burning the minted NFT and unlocking the original asset.

Also, Discover | How to Create an NFT Rental Marketplace using ERC 4907

Tools and Technologies

To build a robust cross-chain NFT bridge, you'll need to leverage several tools and technologies:

• Solidity: For writing smart contracts on Ethereum-compatible networks.
• Hardhat or Truffle: Development environments for compiling, testing, and deploying smart contracts.
• Web3.js or Ethers.js: JavaScript libraries for interacting with the blockchain.
• Node.js: For building off-chain relayer services.
• React or Vue.js: For building the frontend interface.
• IPFS (Optional): For decentralized file storage if metadata needs to be preserved off-chain.

• Oracle Services (Optional): For enhanced trust and verification.

   

Step 1: Setting Up the Development Environment

Before you begin coding, ensure that your development environment is correctly set up.

Prerequisites

• Node.js and npm: Install from nodejs.org.

• Hardhat:

   

  npm install --save-dev hardhat
  

   

• MetaMask: For testing transactions on public testnets.

• Ganache (Optional): For local blockchain simulation.

   

Initializing Your Hardhat Project

Create a new project directory and initialize Hardhat:

mkdir cross-chain-nft-bridge
cd cross-chain-nft-bridge
npx hardhat init

Follow the interactive prompts to set up your basic project structure. Your project should now have folders for contracts, scripts, and tests.

Step 2: Writing the NFT Bridge Smart Contracts

Now, we will create two essential smart contracts: one for locking NFTs and another for minting them on the destination chain.

Example: NFT Bridge Contract

Below is a simplified Solidity contract that demonstrates the locking and unlocking mechanism for an NFT. In practice, you may need additional functions for signature verification and multi-signature approvals, especially in a B2B environment.

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract NFTBridge is ERC721 {
    address public admin;
    mapping(uint256 => bool) public lockedTokens;

    event NFTLocked(address indexed owner, uint256 tokenId);
    event NFTUnlocked(address indexed owner, uint256 tokenId);

    constructor() ERC721("MyNFT", "MNFT") {
         admin = msg.sender;
    }

    // Lock the NFT on the source chain
    function lockNFT(uint256 tokenId) external {
         require(ownerOf(tokenId) == msg.sender, "Not the owner");
         require(!lockedTokens[tokenId], "Token already locked");

         lockedTokens[tokenId] = true;
         // Transfer the NFT to the contract to lock it
         transferFrom(msg.sender, address(this), tokenId);
         emit NFTLocked(msg.sender, tokenId);
    }

    // Unlock the NFT on the source chain (typically triggered by a relayer)
    function unlockNFT(address recipient, uint256 tokenId) external {
         require(msg.sender == admin, "Only admin can unlock");
         require(lockedTokens[tokenId], "Token is not locked");

         lockedTokens[tokenId] = false;
         // Transfer NFT back to the recipient
         _transfer(address(this), recipient, tokenId);
         emit NFTUnlocked(recipient, tokenId);
    }
}

Explanation

Locking Functionality:

The lockNFT function verifies ownership, locks the token by updating a mapping, and then transfers the NFT to the contract address, ensuring it cannot be transferred until unlocked.

Unlocking Functionality:

The unlockNFT function allows the admin (or a designated relayer) to unlock and transfer the NFT back to a recipient on the same chain.

This contract forms the backbone of your cross-chain NFT bridge. In a production environment, additional security measures, such as multi-signature approvals and oracle-based verification, should be incorporated.

Also, Explore | How to Implement an On-Chain NFT Allowlist

Step 3: Bridging Process Explained

The Bridging Workflow

Initiate Transfer:

The NFT owner initiates the transfer by calling the lockNFT function on the source chain's contract. The NFT is then held by the smart contract, and an event is emitted.

Event Monitoring:

An off-chain relayer service listens for the NFTLocked event. This service is critical as it acts as the bridge between the two blockchain networks.

Validation and Verification:

The relayer verifies that the NFT has been successfully locked on the source chain. It may also perform additional checks like verifying a digital signature.

Minting on Destination Chain:

Once validated, the relayer triggers a transaction on the destination chain. Here, a corresponding mint function is executed to create an NFT that represents the original asset.

Reverse Process:

To move the NFT back, the relayer listens for a burn event on the destination chain and then calls the unlockNFT function on the source chain contract, returning the original NFT to the owner.

Off-Chain Relayer Code Sample

Below is a Node.js code snippet using ethers.js to monitor events and call the unlocking function:

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

// Connect to the source chain
const providerSource = new ethers.providers.JsonRpcProvider("https://source-chain-node.example.com");
const providerDest = new ethers.providers.JsonRpcProvider("https://destination-chain-node.example.com");

const sourceBridgeAddress = "0xYourSourceBridgeAddress";
const destBridgeAddress = "0xYourDestBridgeAddress";

// ABI for NFTBridge contract
const nftBridgeABI = [
  "event NFTLocked(address indexed owner, uint256 tokenId)",
  "function unlockNFT(address recipient, uint256 tokenId) external"
];

const sourceBridgeContract = new ethers.Contract(sourceBridgeAddress, nftBridgeABI, providerSource);
const adminPrivateKey = "0xYourAdminPrivateKey";
const wallet = new ethers.Wallet(adminPrivateKey, providerDest);
const destBridgeContract = new ethers.Contract(destBridgeAddress, nftBridgeABI, wallet);

// Listen for NFTLocked events on the source chain
sourceBridgeContract.on("NFTLocked", async (owner, tokenId) => {
  console.log(`Detected locked NFT - Owner: ${owner}, TokenID: ${tokenId}`);
  
  // Validate event details and prepare to unlock NFT on destination chain
  try {
    const tx = await destBridgeContract.unlockNFT(owner, tokenId);
    await tx.wait();
    console.log(`Unlocked NFT on destination chain for ${owner}`);
  } catch (error) {
    console.error("Error unlocking NFT:", error);
  }
});

Explanation

Event Listener:

The relayer listens for NFTLocked events from the source bridge contract. Once an event is detected, the relayer verifies the event and prepares a transaction to unlock the NFT on the destination chain.

Transaction Execution:

Using ethers.js, the code creates and sends a transaction from the admin wallet to the destination bridge contract's unlockNFT function. This automated process is vital for ensuring a smooth, near-real-time bridging experience.

You may also like | A Guide to Implementing NFT Royalties on ERC-721 & ERC-1155

Step 4: Deploying the Smart Contracts

Deploying your smart contracts to both source and destination blockchains is a critical step. Using Hardhat, you can deploy contracts with a simple deployment script.

Example Deployment Script (deploy.js)

async function main() {
  const [deployer] = await ethers.getSigners();
  console.log("Deploying contracts with the account:", deployer.address);

  const NFTBridge = await ethers.getContractFactory("NFTBridge");
  const nftBridge = await NFTBridge.deploy();
  
  await nftBridge.deployed();
  console.log("NFTBridge deployed to:", nftBridge.address);
}

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

Deployment Steps

Compile Contracts:

npx hardhat compile

Deploy to Testnet or Local Network:

npx hardhat run scripts/deploy.js --network rinkeby

Verify Deployment:

Use blockchain explorers such as Etherscan to verify that your contracts are live and properly functioning.

Step 5: Building the Off-Chain Relayer and Orchestration Layer

A robust off-chain system is critical to monitor events and orchestrate bridging actions between chains.

Key Components of the Off-Chain Layer

• Event Listeners:
  Scripts or services that continuously listen for specific blockchain events.
• Transaction Processors:
  Modules that validate and process bridging transactions.
• Logging and Monitoring:
  Integrate tools like Prometheus and Grafana for real-time performance monitoring.
• Security and Error Handling:
  Ensure proper error handling, retry mechanisms, and secure key management.

You may also like to explore | How to Mint an NFT on Polygon using Ethers.js

Best Practices

• Decentralization:
  Use multiple relayer nodes to avoid single points of failure.
• Redundancy:
  Implement fallback strategies in case one node goes offline.
• Security Audits:
  Regularly audit your codebase and relayer infrastructure for vulnerabilities.

Step 6: Developing a User-Friendly Frontend Interface

A professional frontend interface is essential for user adoption and overall success. The UI should enable users to:

• Initiate NFT transfers with clear instructions.
• Monitor the status of their bridging transactions.
• Access support and FAQs.

Technology Stack

• React:
  Build dynamic and responsive UIs.
• Web3.js/Ethers.js:
  Integrate blockchain interactions directly into the frontend.
• Tailwind CSS/Material-UI:
  For professional, modern design.

Sample React Component

Below is a simplified React component that allows users to lock an NFT:

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

const LockNFT = ({ bridgeContractAddress, provider }) => {
  const [tokenId, setTokenId] = useState('');

  const lockNFT = async () => {
    const signer = provider.getSigner();
    const contract = new ethers.Contract(bridgeContractAddress, [
      "function lockNFT(uint256 tokenId) external"
    ], signer);

    try {
      const tx = await contract.lockNFT(tokenId);
      await tx.wait();
      alert("NFT locked successfully!");
    } catch (error) {
      console.error("Lock NFT error:", error);
      alert("Error locking NFT.");
    }
  };

  return (
    <div>
      <h2>Lock Your NFT</h2>
      <input
        type="number"
        placeholder="Enter Token ID"
        value={tokenId}
        onChange={(e) => setTokenId(e.target.value)}
      />
      <button onClick={lockNFT}>Lock NFT</button>
    </div>
  );
};

export default LockNFT;

Explanation

• User Input:
  The component captures the token ID from the user.
• Blockchain Interaction:
  It interacts with the smart contract via ethers.js, invoking the lockNFT function.
• User Feedback:
  Basic error handling and alerts ensure users are informed of success or failure.

Security Considerations

Security is paramount in any cross-chain bridging solution. Key areas to focus on include:

• Smart Contract Audits:
  Regularly audit your smart contracts to identify vulnerabilities such as reentrancy, integer overflows, and access control issues.
• Oracle Trust:
  If using an off-chain relayer or oracle, ensure that the system is decentralized and that trust is not placed on a single entity.
• Key Management:
  Secure the private keys used in off-chain services and relayers using hardware security modules (HSMs) or equivalent solutions.
• Rate Limiting and Throttling:
  Prevent abuse by implementing rate limiting on API endpoints and transaction submissions.
• Fallback and Redundancy:
  Design your system to gracefully handle failures, including retry mechanisms and alternative paths for transaction execution.

Also, Check | How to Get the Transaction History of an NFT

Testing and Deployment

Testing Strategies

• Unit Testing: Write comprehensive unit tests for your smart contracts using Hardhat or Truffle. Use frameworks like Mocha and Chai for assertions.
• Integration Testing: Test the interaction between smart contracts, relayer services, and the frontend. Simulate cross-chain transfers on local networks.
• Security Testing: Employ static analysis tools such as MythX, Slither, or Oyente to scan for vulnerabilities in your smart contracts.
• User Acceptance Testing (UAT): Engage with a select group of users or internal teams to validate the user experience and system reliability.

Deployment Best Practices

• Staged Rollouts: Deploy your solution on a testnet first, then gradually roll out to the mainnet while monitoring performance.
• Continuous Monitoring: Use monitoring tools to track transaction success rates, relayer uptime, and system performance.
• Post-Deployment Audits: Conduct a final audit after deployment to ensure that no vulnerabilities have been introduced during the deployment process.

Conclusion

Building a cross-chain NFT bridge is a multifaceted project that requires a deep understanding of both blockchain technology and system architecture. In this tutorial, we have walked through the entire process—from conceptualizing the solution and setting up your development environment to writing smart contracts, building an off-chain relayer, and developing a user-friendly interface.

As NFTs continue to redefine digital ownership and as blockchain ecosystems become increasingly interconnected, cross-chain bridges will play an essential role in facilitating liquidity, enhancing security, and driving interoperability across networks. By leveraging the strategies and code examples provided in this guide, B2B developers and enterprises can deploy a secure, efficient, and scalable solution that meets the growing demand for cross-chain NFT transfers.

Continuous innovation, rigorous testing, and a focus on security will ensure your cross-chain NFT bridge remains robust and adaptable in an ever-evolving market. Embrace these best practices and technical insights to create a seamless user experience and a competitive edge in the dynamic world of blockchain interoperability.

You might also be interested in | How to Create a Compressed NFT on Solana

FAQ

Q1: What is a cross-chain NFT bridge?

A: A cross-chain NFT bridge is a mechanism that allows NFTs to be transferred securely between different blockchain networks. The process typically involves locking the NFT on the source chain and minting a corresponding token on the destination chain.

Q2: Why do businesses need cross-chain NFT bridges?

A: Cross-chain bridges enable interoperability, allowing businesses to tap into multiple blockchain ecosystems, reduce transaction costs, enhance liquidity, and reach a broader audience. This capability is especially crucial for enterprises looking to expand their digital asset strategies across diverse networks.

Q3: What are the main components of a cross-chain NFT bridge?

A: The key components include smart contracts on both source and destination chains, an off-chain relayer or oracle to monitor events and trigger actions, a user-friendly frontend interface, and a backend orchestration layer for robust security and performance.

Q4: How is security ensured in a cross-chain NFT bridge?

A: Security is maintained through rigorous smart contract audits, decentralized relayer systems, secure key management practices, and robust error handling mechanisms. Implementing fallback strategies and continuous monitoring further enhances the overall security of the system.

Q5: Can this solution be integrated into existing NFT platforms?

A: Yes, the cross-chain NFT bridge solution can be integrated into existing NFT platforms. The modular architecture allows developers to adapt and extend the smart contracts, off-chain relayers, and frontend interfaces to match the specific needs of different NFT ecosystems.

Q6: What tools and technologies are essential for developing a cross-chain NFT bridge?

A: Essential tools include Solidity for smart contract development, Hardhat or Truffle for deployment, ethers.js or web3.js for blockchain interactions, Node.js for off-chain relayer services, and React or Vue.js for the frontend interface.

This tutorial has provided you with a detailed roadmap to build your own cross-chain NFT bridge. From understanding the core concepts to implementing code and deploying a secure solution, you now have a comprehensive guide to unlock the potential of blockchain interoperability in the NFT space. Embrace these techniques and best practices to drive innovation and create a competitive edge in the evolving digital asset landscape. However, if you are lookin for trusted NFT development, connect with our NFT developers to get started. 

 

Polkadot is a decentralized protocol used to enable interoperability in a blockchain. Generally is a layer-0 protocol so the developer is willing to develop or build Kusama, parachain on Polkadot. By running a node on its ecosystem, it eliminates all the risks of third-party infrastructure across the decentralized world. In this article, we explore the Polkadot blockchain application development architecture and the steps to run and set up a full node. 

Overview of Polkadot’s Architecture

Polkadot uses proof of stake, proof of work, and combined consensus to make the Polkadot network more scalable and efficient. Polkadot contains a multichain architecture with shared security and true interoperability.

Components of Polkadot’s Architecture

Shared Security - Provide security to all the parachains and units then for communication. 

Relay chain - Used to unite all the parachain on the polkadot.

Parathread and Parachain Slots - Used to manage the chain and responsible for the security and easy upgradability.

Interoperability of Polkadot’s Architecture

• XCM
• Bridges

Types of Polkadot Nodes

• Full Node
• Archive Node
• Light Node

Suggested Read | Why Develop a DApp (Decentralized Application) on Polkadot

Steps to Run and Setup a Full Node on Polkadot in Linux

Step 1: Run this command to download polkadot.

sudo chmod +x polkadot

Step 2: Run the command and search node on telemetry.

./target/release/Polkadot --name "Node's Name"

Step 3: Get Substrate and Follow all these commands step-by-step to add substrate doc regarding the installation.

git clone https://github.com/paritytech/polkadot Polkadot
cd Polkadot
./scripts/init.sh
cargo build --release

Step 4: Build and Clone

git clone http://github.com/paritytech/polkadot Polkadot
cd Polkadot
./scripts/init.sh
cargo build --release

Step 5: Run 

The Binary will reflect in the target/release folder, Now the given command and use -the the-help flag to check which flag we can use to run the node. and if you want to connect your node remotely then you need to use -rpc-cors.  

./target/release/Polkadot --name "Node's Name"

Note: The syncing process will take time based on the bandwidth of your system, RAM, disk space, and disk speed.

Step 5: Run and archive node

./target/release/Polkadot --name "node's name" --pruning archive

Note: If we run a simple sync node then we will keep only past blocks record and we can use the –wasm-execution Compiled flag to quadruple synchronization speed.

Check It Out | A Compact Guide to Understanding Polkadot Blockchain

Conclusion

In this article, we have learned how to setup and run a full node on Polkadot and need to run given commands step-by-step to set up a node smoothly on your system. If you are interested in integrating blockchain technology into your applications, then connect with our blockchain developers. 

Uniswap is a decentralized finance exchange that is used to trade cryptocurrencies and provide liquidity. It automate transaction between ERC20 or cryptocurrencies tokens on ethereum blockchain through the use of solidity smart contracts. Currently, There are three version of Uniswap Protocol. V1 and V2 are open source with GPL licensed and V3 is also open source with slight modifications.


Uniswap V2 Oracle TWAP Contract:-

In Uniswap V2 Oracle, We use cumulative price variable in the core contract weighted by the amout of time price existed, this variable represents the sum of uniswap price of every seconds in the entire history of the contract. Where these variables can we used by any external contracts to get or track accurate TWAP(time-weighted average prices) across any time interval.

The TWAP reads the cumulative price from an uniswap pair contract from the beginning to end of the desired interval. The difference of cumulative price and divided by the length of the interval to create a TWAP of that period can be the result of TWAP price.

Formula to get token price from uniswap v2 Oracle TWAP Contract:-
TWAP = (Price Cumulative2 - Price Cumulative1)/(Timestamp2 - Timestamp1)


Uniswap V3 Oracle:-

In Uniswap V3, Pool contract can serve as oracle contract, it offers to get history price and liqudity data. In Uniswap V3 Tick accumulator stores the cumulative sum of tick and the tick value increase monotonically. When any pool is created, each token is assigned either token1 or token0 based on contract address of ERC20 token.

In Uniswap V3, We use this formula to get Token price:-
 P(i) = 1.0001^(i)      Where i -> Tick value


Example:-
Suppose, if we want to get ETH price in USDT by using Uniswap WETH/USDT pair.

Where Tick value is -194643 then,
price = 1.0001^(-194643) = 3525.206397

Tick -194643 gives us a price of WETH as 3525.206397 in term of USDT.
     

Run the command:-

        truffle compile

var testMintable = artifacts.require('TestMintable');

contract('TestMintable', function(accounts) {

  let instance;

  before(async () => {

    instance = await testMintable.deployed(accounts[0], 1000);

  });

  it('Token Name should be TestMintable',async () => {

    let tokenName = await instance.name.call({from: accounts[0]});          

    assert.equal(tokenName, "TestMintable","Incorrect name.");

  });

  it('Token Symbol should be Test',async () => {

    let tokenSymbol = await instance.symbol.call({from: accounts[0]});          

    assert.equal(tokenSymbol, "Test","Incorrect symbol.");

  });

  it('Total Supply should be 1000',async () => {

    let supply = await instance.totalSupply.call({from: accounts[0]});         

    assert.equal(supply.toString(), "1000","Incorrect Supply.");       

  });

  it('Mint New Tokens',async () => {

    let result = await instance.mint.sendTransaction(accounts[1], 1000, {from: accounts[0]}); 
    let balance = await instance.balanceOf.call(accounts[1], {from: accounts[1]});           
    assert.equal(balance, 1000, "Incorrect balance.");  

  });

  it('Should throw error when minter caller is not owner',async () => {

    try{

      let result = await instance.mint.sendTransaction(accounts[1], 1000, {from: accounts[1]});

      assert.fail(true,false,"Ownable: caller is not the owner"); 

    }

    catch(err){

        assert.include(String(err),'revert','throws different error');

    }

  });

});

Run the command:-

        truffle test

pragma solidity >=0.5.0 <=0.7.0

contract BuyOrder {

}

contract BuyOrder {

uint256 quantity;

}

constructor() public {

quantity = 50;

}

function getQuantity() public view returns(uint256) {

return quantity;

}

function setQuantity(uint256 _newQuanity) public {

quantity = _newQuanity;

}

pragma solidity >=0.5.0 <=0.7.0;

contract BuyOrder {

uint256 quantity;

constructor() public {

         quantity = 50;

}

function getQuantity() public view returns(uint256) {

          return quantity;

}

function setQuantity(uint256 _newQuanity) public {

          quantity = _newQuanity;

}

}

A Smart Contract is a transaction protocol that is self-executing as per the terms of an agreement between seller and buyer, existing on a blockchain platform. Most smart contracts are stored on the Ethereum blockchain. The smart contract codes control all the transactions on a blockchain, and execution is trackable and irreversible. All smart contracts written in smart contract-specific programming languages are compiled in bytecode.

Solidity is a language that we can use to code smart contracts code. Smart contract syntax is very similar to Javascript, and EVM (Ethereum Virtual Machine) is used to read and execute the Smart Contract. We can execute the solidity programs by using an online IDE (integrated development environment) called Remix or local machines.

Prerequisites

• JavaScript Library Web3.js
• MetaMask Wallet

Steps to Interact with a Smart Contract through Web3.js:-

Step 1:- First we need to add/install the Metamask extension in any browser like Google Chrome, Firefox, etc. 

Step 2:- Web3.js is the official Ethereum JavaScript API and it is used to interact with Ethereum smart contract.

 Step 4:- In this step, we are creating a contract object with the help of a web3 object and we will use this contract object to call Ethereum smart contract methods.

Step 5:- In this step, we are calling the balanceOf() method of smart contract to get user balance.

You may also like to read | How to use Blockchain in the Metaverse | Oodles Blockchain

Step 6:- In this step, we are calling the add() method of smart contract to add two numbers and after successful transaction creation, it will return you a transaction hash value. You can use this transaction hash value to check the transaction status on etherscan.io.

Conclusion

This is a simple example to interact with an Ethereum smart contract by using the Web3.js library and this can only be checked in a local environment.

For more information about Ethereum smart contracts development, you may connect with our skilled smart contract developers.