Developers Forum for XinFin XDC Network: OpenScan

Token Deployment Made Effortless with OpenScan

OpenScan — Thu, 15 Jan 2026 20:24:19 +0000

About OpenScan

OpenScan is a powerful and user-friendly blockchain explorer built for the XDC Network. It goes beyond just viewing blocks and transactions by offering tools that help users and developers interact with the network more easily.
Our mission is to simplify Web3 adoption by reducing technical barriers. With that goal in mind, we’ve introduced a new feature in OpenScan — Token Deployment directly from the explorer.

In this article, we’ll:

Briefly understand what tokens are
Look at common token types
Touch on traditional deployment tools
Explore how OpenScan makes token deployment simple for everyone.

What Are Tokens?

Tokens are digital assets created using smart contracts on a blockchain. They can represent value, ownership, access, or functionality within an application.

Common Token Types

- ERC-20 Tokens
Fungible tokens where each unit is identical. Commonly used for utility tokens, governance tokens, and payments.

- ERC-721 Tokens (NFTs)
Non-fungible tokens where each token is unique. Used for digital art, collectibles, certificates, and identity-based assets.

Both ERC-20 and ERC-721 tokens play a major role in the Web3 ecosystem and are widely adopted on the XDC Network.

Traditional Token Deployment

Traditionally, deploying tokens requires technical tooling and development knowledge. Popular frameworks include:

Hardhat
Truffle

These tools require setting up a development environment, writing smart contracts, configuring networks, and running deployment scripts. While powerful, they can be time-consuming and complex—especially for beginners or quick use cases.

Introducing Token Deployment via OpenScan Explorer ✨

To make token creation accessible to everyone, OpenScan now allows users to deploy tokens directly from the explorer UI—without writing or deploying contracts manually.

What You Can Deploy

✅ ERC-20 tokens
✅ ERC-721 tokens (NFTs)

All deployments use secure, standard smart contract implementations, ensuring reliability and compatibility across the ecosystem.

How Token Deployment Works on OpenScan

Deploying a token using OpenScan is designed to be simple, secure, and intuitive. Follow the steps below to launch your ERC-20 or ERC-721 token on the XDC Network in just a few minutes.

Step 1: Open the Token Deployer
Open the OpenScan Explorer and navigate to the Token Deployer using the top navigation bar.

Click on More in the navbar
Select Deploy ERC-20 or Deploy ERC-721
You’ll be redirected to the respective deployment pages:
ERC-20 Token Deployer: https://xdcscan.io/deploy-erc20
ERC-721 NFT Deployer: https://xdcscan.io/deploy-erc721

No external tools, local setup, or frameworks are required.

Step 2: Connect Wallet & Signature Verification

Click on Connect Wallet and choose a wallet that supports the XDC Network.

OpenScan will prompt you to sign a message
This signature is only for wallet verification
No transaction is sent
No funds are transferred

Once signed:

OpenScan verifies wallet ownership
Your address is authenticated
You are authorized to deploy token contracts

This ensures a secure and trusted deployment experience.

ERC-20 Token Deployment Steps

Step 3 (ERC-20): Enter Token Details
Fill in the ERC-20 token configuration form:

- Token Name
The full name of your token
(e.g., TestToken, OpenScanToken)

- Token Symbol
A short ticker for your token
(e.g., TEST, OST)

- Token Supply
The total initial supply to be minted
(All tokens will be minted to the deployer’s wallet)

Step 4 (ERC-20): Deploy Token

Review all entered details carefully
Click Deploy
Your wallet will prompt you to confirm the transaction
Approve the transaction to deploy your ERC-20 token on the XDC Network

ERC-721 NFT Collection Deployment Steps

Step 3 (ERC-721): Enter Collection Details
Fill in the NFT collection configuration form:

- Collection Name
The name of your NFT collection
(e.g., Test Collection)

- Collection Symbol
A short identifier for your collection
(e.g., TEST)

- Metadata Extension
Select the file extension used for metadata
(e.g., .json)

- Metadata URI
Base URI where NFT metadata is hosted
(e.g., ipfs:///)

- Collection Size
Total number of NFTs in the collection
Ensure metadata and URI details are correct, as they will be permanently stored on-chain.

Step 4 (ERC-721): Deploy Collection

Review all collection details
Click Deploy Collection
Confirm the transaction in your wallet
Approve to deploy your ERC-721 NFT collection on the XDC Network

Step 5: Track Your Deployment

Once the transaction is confirmed:

Your token or NFT contract is successfully deployed
The deployment transaction appears instantly on OpenScan
You can view:
- Contract address
- Token or collection details
- Transaction history
- On-chain activity in real time

That’s It — Your Token Is Live 🎉

With OpenScan, token deployment becomes a seamless experience:

No coding
No local environments
No complex tooling

Just connect, configure, and deploy.

Your token is deployed on-chain, and the transaction can be tracked instantly within OpenScan.
No local setup.
No complex tooling.
No command-line interaction.

Why Use OpenScan for Token Deployment?

🚀 No coding required
🔒 Uses trusted, standard implementations
⚡ Fast and beginner-friendly
🌐 Integrated directly into the explorer
🧩 Perfect for experiments, projects, and real-world use

Whether you’re a developer, creator, or someone new to Web3, OpenScan removes the friction from token creation.

Conclusion

Token deployment doesn’t need to be complicated.
While tools like Hardhat and Truffle remain important for advanced development workflows, OpenScan’s explorer-based deployment feature opens the door for faster, simpler, and more accessible token creation on the XDC Network.
With support for both ERC-20 and ERC-721 tokens, OpenScan continues to evolve beyond a traditional explorer—becoming a complete gateway to building on XDC.
Start deploying your tokens today and experience Web3 the easy way with OpenScan 🌍🚀

Token Standards on the EVM-Compatible XDC Network

OpenScan — Fri, 14 Nov 2025 09:15:05 +0000

In the world of blockchain technology, tokens play a fundamental role in representing value, assets, and rights on decentralized networks. From cryptocurrencies and stablecoins to NFTs and governance tokens, each serves a unique purpose. However, to ensure interoperability, security, and uniform behavior across applications, token standards were introduced. These standards define how tokens are created, managed, and transferred within a blockchain ecosystem.

The XDC Network is EVM-compatible, meaning it supports Ethereum-based token standards and follows the same rules used across the EVM ecosystem. Its native token standard, XRC-20, works similarly to ERC-20, allowing developers to create reliable, interoperable, and scalable tokens on the XDC blockchain. This ensures smooth integration with wallets, dApps, and smart contracts across the network.

What Are Token Standards?

A token standard is a set of rules and guidelines that dictate how tokens on a blockchain should function. These rules ensure that tokens behave consistently and are compatible with various wallets, exchanges, and decentralized applications (dApps).
Without token standards, every project might implement tokens differently—making integration difficult and reducing trust among users and developers. By adhering to standardized frameworks, tokens can easily interact with the broader blockchain ecosystem.

Why Token Standards Matter

Interoperability:
Standards ensure tokens can be recognized and used across multiple platforms and applications seamlessly.

Security:
Well-audited standards reduce vulnerabilities by providing a tested and reliable foundation for token creation.

Ease of Development:
Developers can build on proven templates instead of starting from scratch, saving time and reducing errors.

Ecosystem Growth:
Standardized tokens foster broader adoption by enabling tools, wallets, and exchanges to support them easily.

1) ERC-20

The ERC-20 token standard is a set of rules used to create fungible tokens on the Ethereum blockchain. These tokens follow a standard “recipe,” meaning every ERC-20 token behaves the same way and supports the same basic functions—like checking balances, sending tokens, and approving transfers. This consistency allows ERC-20 tokens to work smoothly across wallets, exchanges, and dApps, making it one of the most widely used standards for creating cryptocurrencies, stablecoins, and **DeFi **tokens.

Similarly, the XRC-20 token standard follows the same “recipe” as ERC-20 but is specifically designed for the XDC Network. Since XDC is EVM-compatible, XRC-20 tokens operate just like ERC-20 tokens while benefiting from XDC’s faster transactions, low fees, and energy-efficient blockchain. This makes XRC-20 an ideal standard for creating reliable and scalable digital assets within the XDC ecosystem.

See ERC-20 token here : https://etherscan.io/tokens
See XRC-20 token here : https://xdcscan.io/tokens

2) ERC 721

The ERC-721 token standard is a set of rules on the Ethereum blockchain used to create non-fungible tokens (NFTs). Unlike ERC-20 tokens, which are identical and interchangeable, ERC-721 tokens are unique, each with its own identity, value, or metadata. This makes them perfect for digital collectibles, artwork, in-game assets, real estate, and any item that is one of a kind. Each ERC-721 token has its own unique ID and can store details like names, descriptions, or links to digital files. With functions like ownerOf, transferFrom, and approve, the standard ensures wallets and marketplaces can easily recognize and manage NFTs. ERC-721 played a major role in the rise of NFTs, powering platforms like OpenSea and famous projects like CryptoKitties.

Likewise, the XRC-721 standard brings the same NFT functionality as ERC-721 but is tailored for the XDC Network. Thanks to XDC’s EVM compatibility, XRC-721 tokens operate just like traditional Ethereum NFTs, while gaining the advantages of faster transaction speeds, lower gas costs, and a more energy-efficient infrastructure. This makes XRC-721 a strong choice for building and managing unique digital assets across the XDC ecosystem.

See ERC-721 token here : https://etherscan.io/nft-top-contracts
See XRC-721 token here : https://xdcscan.io/nft-top-contracts

3) ERC 404

The ERC-404 token standard is an experimental hybrid on Ethereum that mixes features of both ERC-20 and ERC-721. It creates “semi-fungible tokens,” which means tokens can act like normal tradable coins while still being linked to unique NFTs. ERC-404 makes fractional NFT ownership possible — small token pieces can represent parts of an NFT, and collecting enough pieces can automatically form a full NFT again. This gives NFTs more liquidityand flexibility for gaming, DeFi, and digital assets. Although popularized by projects like Pandora, ERC-404 is still experimental and not an official Ethereum standard yet.

On the XDC Network, the XRC-404 standard brings the same hybrid concept as ERC-404 but adapts it for XDC’s efficient, EVM-compatible environment. It allows tokens to behave as both fungible and NFT-linked assets, enabling seamless fractional ownership and recombination into full NFTs. With XDC’s faster transactions, lower gas fees, and eco-friendly design, XRC-404 offers a powerful and scalable way to build advanced digital asset and fractionalized NFT systems within the XDC ecosystem.

See XRC-404 token here : https://xdcscan.io/tokentxns/xrc404

4) ERC-1155

The ERC-1155 token standard is a flexible system on the Ethereum blockchain that lets developers create many types of tokens—fungible, non-fungible, and even semi-fungible—within a single smart contract. Before ERC-1155, each token type required its own contract, which was slower and more costly. With ERC-1155, everything can be managed together, making transactions faster, reducing gas fees, and improving efficiency. This makes it perfect for use cases like gaming, where coins, unique items, and power-ups can all be handled in one place.

On the XDC Network, the XRC-1155 standard brings the same multi-token capabilities but takes advantage of XDC’s faster finality, low transaction costs, and energy-efficient design. Developers can create and manage fungible tokens, NFTs, and semi-fungible assets within a single contract while benefiting from the scalability of the XDC ecosystem. This makes XRC-1155 ideal for advanced applications such as gaming, asset tokenization, and digital collectibles on the XDC Network.

See ERC-1155 token here : https://etherscan.io/nft-top-contracts
See XRC-1155 token here : https://xdcscan.io/nft-top-contracts

Conclusion

Token standards are essential for keeping the blockchain ecosystem organized, secure, and interoperable. They give developers a reliable framework for creating assets that work smoothly across wallets, dApps, and exchanges. From ERC-20 to ERC-721, ERC-1155, and even the experimental ERC-404, each standard plays a unique role in shaping how digital assets are designed and used.
Because the XDC Network is fully EVM-compatible, it supports equivalent standards like XRC-20, XRC-721, XRC-1155, and XRC-404, allowing developers to enjoy the same functionality but with faster transactions, lower fees, and improved scalability. As blockchain technology continues to evolve, these standards—across Ethereum and XDC—will keep pushing the digital asset ecosystem toward greater efficiency, innovation, and global adoption.

BlocksPay Wallet 2.0 — Redefining Multi-Chain Freedom in Web3!

OpenScan — Mon, 29 Sep 2025 13:17:50 +0000

The Web3 landscape is evolving at lightning speed. From decentralized finance (DeFi) to NFTs and gaming dApps, the ecosystem is becoming increasingly diverse — and so are the blockchain networks that power it. In this multi-chain world, users need a wallet that is fast, flexible, and future-ready.

Enter BlocksPay Wallet 2.0: the next generation of the popular browser extension wallet that empowers users to truly experience multi-chain freedom in Web3.

What is BlocksPay Wallet?

BlocksPay Wallet is a secure and intuitive browser extension crypto wallet that allows users to:

Safely store, send, and receive digital assets.
Interact directly with decentralized applications (dApps).
Manage tokens across multiple blockchain networks.
Retain full ownership of their assets through private key control and encryption.

With BlocksPay 2.0, the wallet goes beyond basics and introduces a revamped user experience, enhanced security, and seamless multi-chain management — everything Web3 users need in one place.

Download the extension form here: https://chromewebstore.google.com/detail/blockspay-xdc-eth-btc-and/pogabilnghhbafaheaepaaeopjpleimd

What’s New in BlocksPay Wallet 2.0?

The upgrade isn’t just a facelift — it’s a complete redefinition of how a Web3 wallet should feel and function.

🔹 Modern & Intuitive UI
BlocksPay 2.0 introduces a clean, modern design that makes navigating networks, tokens, and dApps effortless.

🔹 Multi-Chain Dashboard
Get a consolidated view of your portfolio across supported networks. Instantly check balances, track tokens, and view USD valuations — all in one unified dashboard.

🔹 Advanced Network Management
Switching between chains has never been easier:

All Networks → View everything supported by BlocksPay.
Pinned Networks → Customize shortcuts for quick access.
New Networks → Instantly discover the latest additions.

🔹 Secure & Private
Your keys, your control. BlocksPay 2.0 continues to prioritize seed phrase protection and strong password security so that your assets remain safe.

🔹 Faster Transactions
With optimized performance, token transfers and dApp interactions are smoother than ever — a true boost for everyday Web3 users.

The Full Experience: BlocksPay 2.0 Walkthrough

Before diving into the features, check out the full video walkthrough here:

👉 Watch Full Video

This guide will take you step by step through everything BlocksPay Wallet 2.0 has to offer.

Quick Setup in Seconds

Getting started shouldn’t be complicated. With BlocksPay Wallet 2.0, your crypto journey begins in just a few clicks.

Quick steps to setup wallet

Step 1: Download the extension – BlocksPay Extension
Step 2: Choose an option – either import your wallet using a private key or create a new wallet.
Step 3: If creating a new wallet, securely save your seed phrase in a safe place.
Step 4: Re-confirm your seed phrase.
Step 5: Your new account is now successfully created on the BlocksPay extension.

🎬 Quick Setup Guide

No technical knowledge required. Just download, set up, and you’re ready to explore Web3.

Importing Accounts Made Easy

Moving from another wallet? No problem. Import your existing account and access your funds instantly.

Quick steps
Step 1: Unlock your wallet.
Step 2: Click on the account icon in the upper corner.
Step 3: Select “Import Account from Another Wallet.”
Step 4: Choose one of the options – Keystore file or Private Key.
Step 5: Paste your private key (you can also set a custom account name while importing).
Step 6: Confirm with your wallet password.
Step 7: Your account has been successfully imported.

🎬 How to Import Account
Your keys, your crypto, your control. Always.

Adding Custom Tokens

Why limit yourself? With BlocksPay, you can add ANY token — beyond the defaults.

Quick steps
Step 1: Unlock your wallet.
Step 2: Choose your preferred network by expanding the menu on the left.
Step 3: On the dashboard, click the “Add Custom Token” button in the center.
Step 4: Paste your contract address and click “Add.”
Step 5: Your token has been successfully added.

🎬 Add Custom Tokens

Seamlessly manage your favorite assets without restrictions.

Sending XDC with Ease

Whether you’re a trader, investor, or just getting started — sending $XDC has never been simpler.

Quick steps
Step 1: Unlock your wallet.
Step 2: Select your preferred account and network.
Step 3: On the dashboard, click “Send.”
Step 4: Paste the receiver’s address and enter the amount you want to send.
Step 5: Click “Send.”

🎬 Send XDC

One wallet. Instant transactions. Total freedom.

XRC20 & XRC721 Support

BlocksPay Wallet 2.0 fully supports XRC20 and XRC721 tokens, so you can send and receive assets without a hitch.

Quick steps

Step 1: Unlock your wallet.
Step 2: Select your preferred account and network.
Step 3: On the dashboard, click “Send.”
Step 4: Paste the receiver’s address, select the token you want to send from the dropdown, and enter the amount.
Step 5: Click “Send.”

🎬 Send XRC20/XRC721 Tokens

From utility tokens to NFTs — manage it all in one place.

Add Custom Networks — Unlock New Worlds

The decentralized world is expanding — and so is your access.
With BlocksPay 2.0, you can add ANY custom network in seconds.

Quick steps

Step 1: Unlock your wallet.
Step 2: Expand the menu from the upper-left corner.
Step 3: Click on the three-dot options and select “Other Networks.”
Step 4: Click on the plus (+) icon near the search bar and enter your network details:

RPC URL
Network Name
Chain ID
Currency Symbol
(Optional) Block Explorer URL

Step 5: Click “Add Network.” Your custom network is now added, and you can switch to it to start transactions.

🎬 Add Custom Network

Your wallet. Your network. Your rules.

Why Does BlocksPay Wallet 2.0 Change the Game?

True Multi-Chain Freedom — Explore every chain, not just the defaults.
Unmatched Simplicity — Designed for both beginners & experts.
Security First — Your keys, your assets, your control.
Scalable & Future-Ready — Add new tokens, networks, and features anytime.

BlocksPay 2.0 bridges this gap by combining usability, multi-chain connectivity, and advanced tools in one extension. It’s not just a wallet; it’s a gateway to Web3 freedom.

Upgrade today and experience multi-chain freedom redefined with BlocksPay Wallet 2.0.

Please Follow👇

BlocksPay Wallet – Enhanced Extension Update Walkthrough

OpenScan — Mon, 01 Sep 2025 05:09:58 +0000

Introduction to BlocksPay Wallet

BlocksPay Wallet is a secure and user-friendly crypto wallet browser extension that allows you to store, send, and receive cryptocurrencies while interacting seamlessly with decentralized applications (dApps). With built-in private key management and encryption, you retain complete control over your digital assets.
Supporting multiple blockchain networks, BlocksPay makes it easier to explore DeFi, trade tokens, and access the Web3 ecosystem directly from your browser.
The latest update introduces a modern, intuitive interface designed for improved accessibility, smoother navigation, and a better overall user experience. If you already have BlocksPay installed, simply click on the “Enable Now” button in the Chrome Web Store to upgrade to the newest version.

In this walkthrough, we’ll guide you through the essentials of the updated BlocksPay Wallet extension.

Getting Started with BlocksPay Extension

Step 1: Install the Wallet

Download BlocksPay Wallet from the Chrome Web Store.

⚠️ If you already have an older version installed and it shows as Inactive, click on “Enable Now” to upgrade instantly.

Step 2: Set Up a Secure Password

Create a strong password to protect your wallet.
This password will be required each time you log in to the extension.

Step 3: Choose an Option

Create a new account: Generate a fresh crypto wallet.
Import existing account: Use your Seed Phrase to import your wallet.

4. Secure Your Seed Phrase

Write down and store your seed phrase in a safe offline location.

Never share your seed phrase with anyone.
When prompted, confirm it by re-entering in the extension.

That’s it! Your BlocksPay Wallet account is successfully created.

Exploring the New Interface

The updated UI is designed for simplicity and control.

Sidebar Navigation
The left sidebar shows various network icons.

Clicking Expand opens a new window where you can add or switch networks.

Network Management:

All – Displays every supported network in BlocksPay.
Pinned – Shows networks you’ve pinned for quick access.
New – Highlights the latest networks added.

Settings Menu
Access the three-dot menu → Settings to:

Adjust general settings
Review your seed phrase
Reset your wallet if needed

Dashboard Overview
The Dashboard has been enhanced for clarity and accessibility.
Here’s what you’ll find:

Balance Overview – View your wallet’s balance across different networks.
USD Valuation – Instantly check the fiat value of your assets.
Token Management – Add new tokens, view details, and track performance.
Network-Specific Balances – Easily switch between networks to monitor funds.

Final Thoughts
The enhanced BlocksPay extension makes it even easier to manage digital assets, explore networks, and interact with dApps—all while ensuring your security. With its redesigned UI and improved accessibility, this update empowers users to take full advantage of Web3 directly from their browser.
Update your BlocksPay Wallet today via the Chrome Web Store and start exploring the new features.

Please Follow👇

A Beginner’s Guide to Web3: Understanding Blockchain, Wallets, and Explorers

OpenScan — Wed, 23 Jul 2025 16:17:50 +0000

Curious about Web3 but unsure what terms like blockchain, wallet, crypto, or explorer mean?

This beginner-friendly guide explains the core concepts of Web3 in clear, concise language. Whether you’re exploring the space or preparing to build in it, this video provides the foundation you need to understand how Web3 works.

Watch the Complete tutorial on YouTube: https://youtu.be/irrQiAd_GzM?si=MK3dLkd8eEIEnr7O

What is Blockchain?

Blockchain is the foundation of Web3. But what is it really?
Think of blockchain as a digital ledger — a secure, transparent, and unchangeable record book that stores every transaction. Each block contains data, a timestamp, and a reference to the previous block, forming a continuous, tamper-proof chain. This decentralized structure ensures that no single authority controls the data, making blockchain trustless, censorship-resistant, and verifiable by anyone.

How It Works:

Every transaction (like sending cryptocurrency) is grouped into a block.
When full, that block is added to a chain of previous blocks — forming the blockchain.
Each block is permanent and stored on thousands of computers across the world (called nodes).

Key Benefits of Blockchain:

Transparency — Anyone can verify the data.
Security — Data cannot be altered once it’s recorded.
Decentralization — No central authority controls it.

Blockchain powers cryptocurrencies, NFTs, decentralized apps (dApps), and even identity systems.

Relative shorts: https://youtube.com/shorts/kG5BcbU1XRk?si=FWpCQPfpRXz8Au9T

What is a Crypto Wallet?

A wallet is how you interact with the blockchain. It’s like your personal gateway to Web3.

More than just a tool to store digital assets, a wallet allows you to send and receive cryptocurrencies, interact with decentralized applications (dApps), sign transactions, and manage your digital identity. There are two main types: hot wallets (connected to the internet) and cold wallets (offline for enhanced security). Each wallet is secured by a private key — a cryptographic password that only you should control. With a wallet, you’re not just observing Web3 — you’re participating in it.

Popular wallets include:

MetaMask
Trust Wallet
XDCPay
BlocksPay

What Does a Wallet Do?

A wallet doesn’t store your crypto directly. It stores your keys:

Public Key — Your wallet address (you can share this)
Private Key — Your secret password (never share this)
Your private key proves ownership and signs transactions securely. If you lose it, you lose access — so keep it safe!

Relative shorts: https://youtube.com/shorts/ZjnLyx65Pk8?si=Bx02wO8wzFUrAM4l

What is Web3?

Web3 reimagines the internet as a user-owned network where value and ownership flow directly between individuals.

It introduces new possibilities through smart contracts, token economies, and censorship-resistant platforms.As this new era unfolds, it encourages more open, permissionless innovation across industries.

To understand Web3, let’s look at the evolution of the internet:

Era Description

Web1: Read-only (static websites)

Web2: Read & interact (social media, cloud apps)

Web3: Read, write & own (decentralized apps, assets, identity)

In Web3:

Your wallet is your login — no more usernames or passwords.
You own your data, your assets, and your digital identity.
Everything lives on the blockchain — not on someone else’s server.

Key Parts of Web3:

Cryptocurrencies
NFTs (Non-Fungible Tokens)
DAOs (Decentralized Autonomous Organizations)
Smart Contracts
dApps (Decentralized Applications)

Web3 isn’t just technology — it’s a movement toward a more open, user-owned internet.

Relative shorts: https://youtube.com/shorts/Za7hfIkEv20?si=1EWS1gAqdPS_BAz6

What is a Blockchain Explorer?

Ever wondered how you can verify a crypto transaction, check a wallet’s balance, or see what a smart contract does? That’s what a blockchain explorer does.

It’s a search engine for blockchain activity — giving you full visibility into what’s happening on-chain.

A Blockchain Explorer Lets You:

Search any wallet address and view its history
Enter a transaction hash to track crypto transfers
Explore block details, token transfers, and even smart contract code

Popular Blockchain Explorers:

Etherscan — for Ethereum
BSCScan — for Binance Smart Chain
XDCScan — for the XDC Network

Explorers are essential tools for anyone looking to learn, build, or track on-chain data.

Relative short: https://youtube.com/shorts/ARLme6fAf-8?si=384U-7h0oN8KqZ03

Final Thoughts: Your Web3 Starter Pack
Let’s recap the four pillars of Web3:

Blockchain — The foundation
Wallets — Your key to access
Web3 — A new internet era based on ownership
Explorers — The tools to navigate it

And if you’re thinking of creating content around Web3 — just start. The space needs more voices and creators. Build your projects and share them on xdc.dev to contribute to the growing Web3 ecosystem.

Related Topics You Might Like:

Please Follow👇

All you need to know about Smart Contracts

OpenScan — Sat, 07 Jun 2025 09:04:09 +0000

What is a Smart Contract? A Beginner’s Guide to Blockchain Code

In the world of blockchain, smart contracts are the backbone of automation. They're not smart like humans, and they’re not legal contracts either — but they do something powerful: automate transactions without needing a middleman.

A smart contract is a self-executing program that runs on the blockchain. Once deployed, it can’t be changed. It follows a set of rules written in code and runs exactly as programmed. Think of it like a vending machine — you put in money and select a snack, the machine automatically gives you what you paid for. No one needs to supervise it.

Programming Languages: Solidity & Vyper

To write smart contracts, developers use special blockchain programming languages. The two most popular ones for Ethereum and EVM-compatible chains are:

1. Solidity: The most widely used language. It’s similar to JavaScript and is the standard for Ethereum smart contract development.

2. Vyper: A Python-like language. It's more restrictive but focuses on simplicity and security, making it ideal for critical applications like DeFi protocols.

If you're just starting out, Solidity is your best bet due to its active community and wide support.

Tools: Hardhat, Truffle, Brownie & Remix

Smart contracts don’t live in isolation — developers use frameworks and tools to write, test, and deploy them. Here are some top choices:

1. Hardhat: A fast and flexible development environment for Solidity. Great for testing, debugging, and deploying contracts locally and to testnets.
2. Truffle: One of the oldest frameworks, with powerful tools for contract management and frontend integration.
3. Brownie: A Python-based framework that works beautifully with Vyper or Solidity contracts. It's developer-friendly for Python enthusiasts.
4. Remix: An in-browser IDE that requires no setup. Perfect for quick contract testing or learning the basics.

Methods for Deploying Smart Contracts

Want to start deploying your own smart contracts? Here are detailed guides for each major tool:
🔹 Using Hardhat
How to Deploy and Verify Smart Contracts on XDC Network Using Hardhat

🔹 Using Truffle
Deploy an XRC721 Contract on XDC Apothem Network Using Truffle

🔹 Using Brownie
A Step-by-Step Guide to Deploying Vyper Contracts on the XDC Network with Brownie

🔹 Using Remix
Setup Remix & Learn to Execute Solidity Smart Contracts on XDC

What Does a Contract Address Look Like?

Every smart contract deployed on a blockchain gets a unique address — just like your wallet. This address is where users can interact with the contract.

It typically looks like this:
0xAbC123...789DeF

A contract address is a 42-character string that starts with 0x, followed by 40 hexadecimal characters (numbers 0–9 and letters a–f).
This hexadecimal string identifies the contract on the blockchain. Anyone can send tokens, call functions, or read data from it — if they have permission.

Why Verify Your Contract (And How)

Once you deploy a smart contract, verification is crucial. It means uploading your contract's source code to a public blockchain explorer (like XDCScan, Etherscan, etc), allowing anyone to inspect and confirm that the contract's bytecode matches its source.

Why verify?

1. Transparency: Users can audit your contract’s behavior.
2. Trust: Developers, investors, and partners gain confidence in your code.
3. Interoperability: Verified contracts can be accessed and called by other projects more easily.

How to verify?

Tools like Hardhat, Truffle, and Brownie offer built-in plugins to verify contracts on explorers.
You usually provide:

Source code
Compiler version
Constructor arguments

Once verified, the contract’s UI will be fully interactive on explorers — a major plus for user experience.

OpenScan Supports Multiple Networks

If you're looking to explore verified smart contracts across different blockchains, OpenScan provides support for multiple EVM-compatible networks. Here are a few you can check out:

XDC Network

Checkout verified contracts here: https://xdcscan.io/contracts
Verify contract on XDC Network: https://xdcscan.io/contracts/verify

Velas Network

Checkout verified contracts here: https://velasblocks.com/contracts
Verify contract on Velas: https://velasblocks.com/contracts/verify

Refer guide: https://www.youtube.com/watch?v=93KrjbXPvc8&list=PLjYCiPsAxZS4GAWW_wjWIXOMrQsWe2nzH&index=3

Wanchain Network

Checkout verified contracts here: https://wanexplorer.io/contracts
How to verify a contract on Wanchain: https://wanexplorer.io/contracts/verify

Refer guide: https://www.youtube.com/watch?v=MQb72aLPha0&list=PLjYCiPsAxZS4GAWW_wjWIXOMrQsWe2nzH&index=2

These explorers show verified contract code, transaction history, and real-time interactions — making it easier for developers and users to trust and engage with smart contracts.
Smart contracts are reshaping how we think about code, money, and trust. With the right tools and knowledge, anyone can start building decentralized applications that live on-chain and run forever.
Whether you're tinkering with Remix, deploying with Hardhat, or coding in Vyper — you're stepping into a world where code is law, and your creativity has no middlemen.

Please Follow👇

Adding Your Token Logo and Details to XDCScan powered by OpenScan

OpenScan — Wed, 12 Feb 2025 10:02:47 +0000

OpenScan: A Next-Generation Blockchain Explorer

OpenScan is an advanced blockchain explorer that offers deep insights into blockchain transactions, smart contracts, and network activity. Acting as a search engine for blockchain networks, XDCScan powered by OpenScan enables users to track transactions, validate smart contracts, and analyze token transfers in real-time. Whether you’re a developer, trader, or blockchain enthusiast, OpenScan provides the transparency and tools needed to navigate blockchain ecosystems efficiently.

If you would like to add a logo and details for your token to OpenScan Explorer, please follow the guidelines below.

Image Requirements

File Extension: Only .png is accepted. Uppercase .PNG files will be considered invalid.
File Name: The file name should be your token symbol in lowercase. For example, tokens/img/usdt.png.
Size: The image should be 256px by 256px.
Background: Preferably transparent.
Optimization: Use a simple drag-and-drop online service like TinyPNG to optimize the image size.

Token Information Requirements

File Extension: Only .json is accepted. Uppercase .JSON files will be considered invalid.
File Name: The file name should be your token symbol in lowercase. For example, tokens/config/usdt.json.
Required Fields: symbol, name, website

Example

Below is an example of a JSON file containing the necessary token information:

{
  "id": "0xd12f7a98c0d740e7ec82e8caf94eb79c56d1b623",
  "symbol": "os",
  "name": "OpenScan",
  "description": "OpenScan's XRC20 token",
  "website": "https://openscan.ai/",
  "auditReport": {
    "SlowMist": ""
  },
  "communities": {
    "email": "support@blocksscan.io",
    "telegram": "https://t.me/OpenScanAi",
    "reddit": "https://www.reddit.com/r/",
    "medium": "https://medium.com/",
    "youtube": "https://www.youtube.com/@OpenScanAI",
    "twitter": "https://x.com/OpenScan_Ai",
    "facebook": "https://www.facebook.com/",
    "github": "https://github.com/OpenScanAi",
    "coinmarketcap": "https://coinmarketcap.com/currencies/",
    "coingecko": "https://www.coingecko.com/en/coins/"
  }
}

Adding a New Account Tag

To add a new account tag, follow these steps:

Locate the Configuration File: The configuration file is located at eaas/config/XDC/AccountName.json.
Open the File: Use a text editor to open AccountName.json.
Add the Account Tag: Add a new entry to the JSON file with the appropriate details.

Example

Below is an example of how to add a new account tag to the AccountName.json file:

{
  "0xYourAccountAddressHere": "YourAccountTagName"
}

Make sure to include the following fields for each new account tag:

0xYourAccountAddressHere: The blockchain address of the account.
YourAccountTagName: The name you want to associate with this account.

By following these guidelines, you can ensure that your token's logo, details, and account tags are correctly displayed on XDCScan - OpenScan Explorer.

For more insightful articles and guides, stay connected and follow us on various platforms.

Main Source: https://github.com/OpenScanAI/assets?tab=readme-ov-file#adding-your-token-logo-and-details-to-blocksscan-explorer

Please Follow👇

Deploy Your Token on XDC Network with XDCScan – Powered by OpenScan

OpenScan — Mon, 10 Feb 2025 10:42:07 +0000

In the world of blockchain, the creation of tokens is essential for launching decentralized projects, powering DApps, and facilitating transactions. While creating tokens can often be a technical challenge, the Token Deployer simplifies the process, making it accessible to both experienced developers and newcomers to the blockchain space. Whether you're looking to create XRC20 tokens or deploy an XRC721 NFT collection, the Token Deployer provides an easy-to-use platform that handles the complexity behind the scenes.

In this guide, we’ll walk you through the process of deploying both XRC20 tokens and XRC721 NFT collections on blockchain networks like XDC, helping you bring your digital assets to life.

XRC20 Token Deployer:

The XRC20 Token Deployer is an intuitive tool that allows anyone to create and launch their own XRC20 tokens on blockchain networks, such as XDC. The deployer streamlines the process, removing the need for technical expertise. Here’s how you can use it to deploy your XRC20 token.

Step 1: Connect Your Wallet

To begin, you’ll need to connect your cryptocurrency wallet. The deployer supports MetaMask, a popular browser-based wallet that offers secure and seamless access to blockchain networks. By connecting your wallet, you ensure that the token is deployed from your personal address, giving you full control over your newly created tokens.

Step 2: Fill Out the Token Details
Next, enter the following basic details about your token:

Name: The full name of your token (e.g., "Deployer Token").
Symbol: A short abbreviation that represents your token (e.g., "DPTKN").
Supply: The total number of tokens you wish to create (e.g., 1,000,00 tokens).

Step 3: Deploy the Token on the XDC Network

Once you've filled in the details, click the "Deploy" button. The backend process works as follows:

How things work in backend

The deployer automatically generates a smart contract tailored to your token specifications.

It sends a transaction to the blockchain, deploying your token’s smart contract.

After the transaction is confirmed on the blockchain, your XRC20 token built on XDC Network is officially live and ready to use.

Benefits of Using the XRC20 Token Deployer

Here’s why the XRC20 Token Deployer is a game-changer:

Ease of Use: The user-friendly interface eliminates the need for technical skills, making token creation accessible to everyone.

Security: By using a secure wallet like MetaMask, you maintain full control over your tokens and their deployment.

Speed: In just a few clicks, your token is live on the blockchain, saving time compared to manually developing smart contracts.

Customization: You can define key token details such as name, symbol, and supply, tailoring your token to your specific needs.

XRC721 NFT Collection Deployer:

The XRC721 NFT Collection Deployer is a tool designed to make it easy for you to create and deploy your own NFT (Non-Fungible Token) collection. Using this deployer, you can launch a unique NFT collection on XDC Network Blockchain, without needing to know how to write smart contracts.

Steps to Deploy Your NFT Collection

Step 1: Connect Your Wallet
Similar to the XRC20 Token Deployer, the first step is to connect your cryptocurrency wallet. The deployer integrates with MetaMask, which provides the ability to interact with the blockchain and manage your NFTs. Connecting your wallet ensures that the NFT collection is deployed from your address, giving you full control over it.

Step 2: Provide Collection Details
Fill in the following details for your NFT collection:

Name: The full name of your NFT collection (e.g., "Deployer NFT").
Symbol: A short abbreviation (e.g., "Deployer NFT").
Metadata Extension: The file extension for your metadata files (e.g., ".json").
Base URI: The location where the metadata for your NFTs is stored (e.g., an IPFS link).
Collection Size: The total number of NFTs you want in your collection.
These details define the core characteristics of your NFT collection, ensuring proper functionality.

Step 3: Deploy Your Collection on the XDC Network
After entering the collection details, click the "Deploy Collection" button. Here's how the backend works:

How things work in backend

The deployer automatically generates a smart contract for your NFT collection based on the information you provided.

It sends a transaction to the blockchain network to deploy the contract.

Once the transaction is confirmed, your NFT collection is live and ready for minting or distribution.

Why Use the XRC721 NFT Collection Deployer?

The XRC721 NFT Collection Deployer offers several key benefits:

Ease of Use: The interface is simple and intuitive, making it accessible to anyone, even those without coding expertise.

Control: By deploying from your wallet, you retain full ownership and control over your NFT collection.

Speed: You can deploy your NFT collection in just a few clicks with minimal setup.
Blockchain Standards: Your NFT collection adheres to the XRC721 standard, ensuring compatibility and reliability with other systems and marketplaces.

Contract Interactor

Simplifying Blockchain Smart Contract Testing. The Contract Interactor is a versatile tool designed to simplify the process of interacting with Solidity-based smart contracts, such as XRC20 tokens and XRC721 NFTs. This tool makes exploring and testing smart contract functionalities easy and accessible for developers, testers, and blockchain enthusiasts alike.

Follow these steps to access and interact with a deployed smart contract using XDCScan:

Step 1: Visit the Contract Interaction Page
Go to the Contract Interaction page on XDCScan:

Step 2: Enter Your Contract Address
In the provided input field, paste the contract address of the deployed smart contract you want to interact with.
Ensure that the contract is verified to enable interaction.

Step 3: Access Contract Functions

After entering the contract address, you’ll see available functions like:

owner() – View contract owner
name() – Get contract name
balanceOf(address) – Check token balance
totalSupply() – View total token supply

Key Features

Seamless Contract Connection: Simply input the contract’s address to connect. The Contract Interactor fetches the ABI dynamically, enabling easy access to all contract functions.

Dynamic Function Selection: Browse and select from available read and write functions, automatically listed based on the contract ABI. Inputs are dynamically generated for ease of use.

Real-Time Feedback and Results: View instant feedback on your interactions, including success responses and detailed error messages for efficient testing.

Error Handling Made Simple: The tool provides robust error detection, guiding users through successful interactions while helping identify potential issues clearly.

For more insightful articles and guides, stay connected and follow us on various platforms. Happy coding! 🚀

Please Follow👇

A Step-by-Step Guide to Deploying Vyper Contracts on the XDC Network with Brownie

OpenScan — Thu, 09 Jan 2025 06:13:21 +0000

In this article, we’ll explore how to deploy Vyper smart contracts using Brownie, a popular Python-based Ethereum development framework. Before diving into the deployment process, let’s first understand what Vyper is and why it has been gaining popularity among blockchain developers.

What is Vyper?

Vyper is a contract-oriented programming language specifically designed for writing smart contracts on the XDC - EVM Compatible blockchain. While it shares a syntax similar to Python, Vyper emphasizes simplicity, security, and auditability, setting it apart from other languages like Solidity.

Why is Vyper Gaining Popularity?

Vyper has been steadily gaining traction in the blockchain development community due to its unique approach to smart contract development. Here are some of the key advantages of Vyper:

1. Security-Focused Design
Vyper eliminates complex features like function overloading, modifiers, and inline assembly that can introduce vulnerabilities. This makes it easier to write secure and auditable smart contracts.

2. Simplicity
The minimalist nature of Vyper ensures fewer opportunities for coding errors. It encourages developers to write clear and concise code, reducing potential bugs.

3. Pythonic Syntax
With its Python-like syntax, Vyper is more accessible to developers who are already familiar with Python, lowering the learning curve.

4. Supports Formal Verification
Vyper is designed to allow formal verification, enabling developers to mathematically prove the correctness of their contracts, which is particularly important for high-stakes applications like DeFi.

5. Transparency and Clarity
The language enforces straightforward and transparent code, which not only improves trust but also simplifies the auditing process.

Use Cases for Vyper

Vyper is an excellent choice for projects that prioritize security and simplicity, such as decentralized finance (DeFi) protocols, token contracts, and voting systems. However, it may not be ideal for more complex contracts that require advanced features available in Solidity.

Step 1: Install Python
Brownie requires Python to work, so ensure that Python is installed on your system. You can check if Python is already installed by running the following command:

If Python is not installed, follow these steps:

Visit the official Python website and download the latest version of Python.
Run the installer and ensure that you check the box to add Python to your system PATH during installation.

After installation, verify it by running

python --version

Step 2: Install Brownie

Install brownie by hitting below command

pip install eth-brownie

Verify the installation

brownie --version

Step 3: Create a directory for your brownie project

Now run below command in the directory

brownie init

This will generate necessary files in it

Step 4: Now create contract file in “contracts” folder with “.vy extension”

Like SimpleStorage.vy

# @version ^0.3.9

stored_value: public(uint256)

@external
def __init__():
    # Initialize the stored value to 0
    self.stored_value = 0

@external
def set_value(new_value: uint256):
    """
    Set the stored value.
    """
    self.stored_value = new_value

@external
@view
def get_value() -> uint256:
    """
    Retrieve the stored value.
    """
    return self.stored_value

Step 5: Now, create a deploy.py file in the scripts folder and write the deployment script in it.

from brownie import SimpleStorage, accounts

def main():
    # Load the default account
    account = accounts.load('my_account')  # Replace with your account alias

    print(f"Deploying the contract from: {account}")

    # Define gas price
    gas_price = "20 gwei"

    # Deploy the contract
    simple_storage = SimpleStorage.deploy({"from": account,"gas_price": gas_price})

    print(f"Contract deployed at: {simple_storage.address}")

Step 6: Compile your code by running brownie compile.

Step 7: Now, we need to add our network to the Brownie network list.
To do this, run the following command with all your required parameters (RPC URL, chain ID, and network name):

brownie networks add <network_name> <testnet/mainnet> host=<RPC_URL> chainid=<chain_id>

For example:

brownie networks add XDC ApothemTestnet host=https://erpc.apothem.network chainid=51

Step 8: You can verify if your network has been successfully added to the list by running the following command:

brownie networks list

Step 9: Now you need to add the account from which you will be deploying your smart contract.

Run the following command to create a new account:

brownie accounts new <account_name>

For Example:

brownie accounts new my_account

You will be prompted to enter your private key and a password to unlock your account. Provide the required details and press enter to complete the process.

To check if your account has been added to the list, run the following command:

brownie accounts list

Step 10: Now we will deploy our contract.
Run the following command to deploy your contract:

brownie run scripts/deploy.py --network <your network name>

Replace <your network name> with the name of the network you configured earlier.

For Example

brownie run scripts/deploy.py --network ApothemTestnet

And here, your Vyper smart contract is deployed using Brownie on XDC Apothem Network

Some Common Issues:

1. Version Issues: You may encounter version compatibility issues. For reference, the following combination works:

Python Version:

Python 3.11.5
Brownie Version: Brownie v1.20.7 - Python development framework for Ethereum

2. Gas price issue
You may encounter an error related to the gas price. To solve
this, we need to define the gas price explicitly. As you can see in the code, we have defined the gas_price variable.

In conclusion, mastering tools like Brownie and Vyper simplifies smart contract development and deployment. Keep exploring, learning, and building!

For more insightful articles and guides, stay connected and follow us on various platforms. Happy coding! 🚀

Please Follow👇

How to Use Bytecode to Opcode Tool: A Complete Guide

OpenScan — Mon, 02 Dec 2024 19:10:18 +0000

Simplify Smart Contract Debugging with the Bytecode to Opcode Tool

Introduction

Smart contract developers and blockchain enthusiasts often need to decode the complexities of Ethereum’s Virtual Machine (EVM) to understand the behavior of deployed contracts. One essential tool for this is a Bytecode to Opcode Converter, which translates low-level compiled smart contract bytecode into more human-readable opcodes. This article will guide you on how to use the tool effectively.

What is Bytecode?

Bytecode is the compiled form of a smart contract. Once a smart contract is written in a high-level programming language like Solidity, it is compiled into bytecode — a series of hexadecimal characters. Bytecode is executed by the Ethereum Virtual Machine (EVM) or other compatible virtual machines like XDC’s.

What are Opcodes?

Opcodes are the low-level instructions executed by the EVM, derived from the compiled bytecode. These represent fundamental operations like arithmetic, data storage, and contract interaction. Opcodes provide deeper insights into how smart contracts execute on the blockchain.

Steps to Use the Bytecode to Opcode Tool

Step 1: Navigate to the Bytecode to Opcode Tool.

Step 2: Enter the compiled bytecode of your smart contract in the text area provided.

This is the hexadecimal representation of your contract code.
ByteCode Example:
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

Step 3: Submit the bytecode by clicking the “Submit” button.

Note: Review the results. The tool will decode the bytecode and display the corresponding opcodes, giving you a detailed breakdown of the low-level instructions.

This functionality is ideal for debugging smart contracts and analysing their behaviour before deployment.

Broadcasting Transactions | Submitting Signed Transactions with PushTx

Developers often need to broadcast signed transactions directly to the blockchain. XDCScan provides an easy-to-use PushTx feature for this purpose.

Step 1: Navigate to the PushTx Page.
Step 2: Enter the signed raw transaction hash in the text area provided.

Ensure the hash is correctly formatted and signed using a compatible tool or library.
Example of RAW transaction: 0xf86d3d850df847580082520894f3ca2132ca536f41606004b9d380f609af273ee2880853a0d2313c000080818aa0c78bcc0e972260d87f3d58baf3f6d71365e303b93d607259aa914e5d88bdb04ba065d70d71922acad744836ccc090b51e8f62abeab863c4ac9d4131f1c94dbad2d

Step 3: Click the “Broadcast Transaction” button.

Step 4: Once submitted, the transaction will be broadcasted to the blockchain, and the transaction hash will appear below as confirmation.

💡 Note: This feature currently supports the Apothem Network for testing and development purposes.

Why Use XDCScan’s Tools?

Developer-Friendly: Intuitive interfaces and quick results make debugging and deployment seamless.
Transparency: Gain deeper insights into smart contracts and transaction details.
Efficiency: Save time by using real-time tools for contract analysis and transaction submission.

Access these tools today and streamline your blockchain development experience:

Unleash the potential of your smart contracts and optimize your development workflow with XDCScan’s comprehensive suite of tools!

Start leveraging this tool today and streamline your smart contract workflows!

Stay connected for more updates on smart contract functionality and blockchain insights:

How to Verify Multi-Part Smart Contracts on XDCScan Explorer: A Complete Guide.

OpenScan — Mon, 28 Oct 2024 19:13:31 +0000

Verifying your smart contract on a blockchain explorer like XDCScan promotes transparency and helps build trust within the community. By publishing your contract’s source code, users can understand the contract’s logic, contributing to a more secure and open ecosystem. This article offers a comprehensive guide for verifying multipart smart contracts on the XDC Network using XDCScan, powered by BlocksScan (OpenScan).

What is Multipart Verification?

Multipart contract verification is a specialized process designed for complex smart contracts that involve multiple files or dependencies, including libraries or inherited contracts. Unlike single-file verification, multipart verification compiles each individual component, allowing the blockchain explorer to validate the complete contract structure. This ensures that every segment of a multi-file contract matches the deployed bytecode, strengthening trust in the contract’s reliability and functionality.

Prerequisites for Contract Verification

Before starting the verification process, make sure you have the following prerequisites:

Contract Source Code: Your Solidity (.sol) source code file.
Libraries Used: A list of libraries referenced in your contract, along with their deployed addresses.

Step-by-Step Guide to Verifying Your Smart Contract on XDCScan

Step 1: Access XDCScan’s Contract Verification Page

Open XDCScan, the official blockchain explorer for the XDC Network.
Enter your deployed contract address, select the “Contract” tab, and choose “Verify And Publish”. This option redirects you to the verification page.

Step 2: Enter the Contract Details

Contract License: Choose the appropriate license for your contract from the dropdown menu.
Verification Method: Select “Solidity (Multi-part files)” to indicate that your contract comprises multiple files.
Compiler: Select the compiler version used for the original deployment.
Optimization Settings: Enable optimization if it was used in your contract’s deployment.
Add Contract Library: Add each library’s name (with a “.sol” extension) and its deployed address. Up to 10 libraries can be added.

What are Libraries?
Libraries in Solidity are reusable pieces of code that extend a contract’s functionality, reducing duplicate code by allowing contracts to share reusable logic.

Step 3: Upload Your Solidity Contract Files
Upload all .sol files related to the contract, including main files and any dependencies. Ensure each file is organized and correctly named to avoid verification issues.

Step 4: Confirm and Verify
Review all details displayed, ensuring that the contract address, contract name, compiler settings, and library names match the information of the deployed contract. Click “Verify and Publish” to finalize the process.

Step 5: Verification Successful
If all details are correct, XDCScan will display a success message indicating that your contract has been verified.

Users can now access your contract’s source code, ABI, and additional details directly on XDCScan.

Troubleshooting Common Verification Issues

If verification fails, here are some common issues and their solutions:

Compiler Mismatch: Ensure the compiler version and optimization settings used during verification match those used in deployment.
Contract Name Mismatch: Verify that the contract name entered matches the name in the source code.
Incorrect Library Details: Double-check that the names and addresses of imported libraries are correct and match the information used in the main contract.

Stay connected for more updates on smart contract functionality and blockchain insights:

How to Verify Your Smart Contract Built on the XDC Network via Standard Input JSON on XDCScan Powered by BlocksScan(OpenScan)

OpenScan — Fri, 04 Oct 2024 15:45:31 +0000

Verifying your smart contract on a blockchain explorer is an important step to ensure transparency and trust. By verifying the source code of your smart contract, users can view the contract logic, fostering a more open and secure ecosystem. This guide will walk you through the process of verifying a smart contract deployed on the XDC Network using standard input JSON on XDCScan.

Why Verify Your Smart Contract?

Verifying your smart contract on XDCScan allows anyone to view the exact code you deployed on the XDC blockchain. This brings several benefits:

Transparency: Users and developers can inspect your contract's logic, improving trust.
Security: Verifying code enables users to ensure that there are no malicious or hidden features in the contract.
Ecosystem Participation: Verified contracts become part of the public ecosystem, enabling tools such as decentralized finance (DeFi) applications and wallets to interact with your contract more easily.

Prerequisites

Before you proceed with verifying your smart contract, make sure you have the following:

Contract Source Code: The original source code of your smart contract, usually written in Solidity.
ABI (Application Binary Interface): Automatically generated when you compile your smart contract.
Compiled Contract Code: The compiled bytecode of your smart contract.
Standard JSON Input File: Generated by Solidity during compilation.

Step-by-Step Guide to Verify Your Smart Contract on XDCScan

Step 1: Navigate to XDCScan’s Contract Verification Page

Open XDCScan, the XDC Network’s blockchain explorer.
Enter your deployed contract address on XDCScan explorer, select the “Contract” tab and click on the "Verify And Publish" option. This will redirect you to the contract verification page.

Step 2: Enter the Contract Details
On the contract verification page, you’ll be prompted to fill in the following details:

Contract Licence: Select the correct “Contract Licence” from the dropdwon.
Compiler Type: Select "Solidity (Standard JSON Input)" from the available options.
Contract Name: Specify the name of the contract as used during deployment.
Compiler: Select the Compiler version, used during deployment.
Try to fetch constructor arguments automatically: Select “Yes” or “No”.

Step 3: Create a standard input JSON file
Here first you need to create an empty JSON file, and then from there you need to go to the following file(in hardhat project) artifacts->build-info-> JSON file corresponding to your smart contract.

In Remix, We will use a COMPILERINPUT file generated by the compiler. You can find it in the “Compilation Details” tab (ensure that the correct contract is chosen).

Once you found the JSON file, copy the input value and paste into the empty JSON file you created.

Step 4: Upload the Standard JSON Input

Choose the option to upload your standard input JSON file.
Upload the JSON file generated during the contract compilation.

The JSON file contains all the necessary metadata, including the source code, ABI, and other details required for verification.

Step 4: Confirm and Verify
Once you’ve uploaded the file, review the information displayed on the page. Make sure the contract address, name, and compiler settings match the deployed contract.
Click the “Verify and Publish” button to complete the verification process.

Step 5: Verification Successful
If everything is correct, XDCScan will display a success message, and your contract will be verified on the platform.

Users can now view the source code, ABI, and other relevant details directly on XDCScan.

Troubleshooting Common Issues

If your contract fails to verify, here are a few common issues and their solutions:

Compiler Mismatch: Ensure that the compiler version and optimization settings used during verification are the same as those used during deployment.
Contract Name Mismatch: Double-check that the contract name entered during verification matches the one used in the source code.
Incorrect JSON File: Verify that you are using the correct standard input JSON file generated during the contract’s compilation.

Follow us to know more updates: