Developers Forum for XinFin XDC Network: Jay_Kulkarni

ETHDubai:XDC Hackathon Revolutionizing Global Supply Chains with XDC Network

Jay_Kulkarni — Fri, 23 May 2025 11:12:38 +0000

The Challenge

Modern supply chains are complex ecosystems involving manufacturers, warehouses, retailers, and customers. Yet, they often lack transparency, suffer from inefficiencies, and are vulnerable to fraud. Traditional systems fail to provide stakeholders with real-time visibility or proof of product authenticity.

Our Solution

At ETHDubai 2025 Hackathon, our team introduced a cutting-edge, decentralized supply chain platform powered by the XDC Network. The goal: to offer end-to-end visibility, build trust between stakeholders, and eliminate inefficiencies through smart contract automation and QR code traceability.

Tech Stack Highlights

Frontend: Built with React.js for a dynamic and responsive user experience.
Smart Contracts: Developed in Solidity and deployed on the XDC Network (EVM-compatible).
Data Presentation: Implemented using Material Table for a clean and user-friendly interface.
Payments & Permissions: Enabled using XDC tokens, ensuring seamless and secure transactions.

How It Works

Our platform supports key roles in a supply chain:
Manufacturers – Initiate the product's lifecycle

Warehouse Owners – Track inventory movement
Retailers– Validate handovers
Customers– Verify authenticity before purchase
Admin– Controls user roles and system access

Each product is assigned a unique QR code, which records its entire journey on-chain — from origin to delivery.

Smart Contract Automation

Smart contracts govern:

Role-based access controls
Secure and verifiable product transfers
Fair payment distribution upon product movement

QR Code Traceability

Consumers can scan QR codes to:

Authenticate products
Trace every touchpoint in the supply chain
View timestamped logs of all transfers

This level of transparency significantly reduces the risk of counterfeit goods and builds lasting consumer trust.

Key Advantages

Full Transparency: All stakeholders have real-time access to product data
Security & Trust: Tamper-proof blockchain ledger
Process Efficiency: Automated workflows reduce delays
Traceability: End-to-end tracking for every product
Accountability: Immutable record of every interaction

Live Demo

📺 Watch the full product walkthrough on YouTube

Deployed On

Network: XDC Apothem (Testnet)
Smart Contract: 0xc98659fF51045a7e78660FB68715faBC5637118B

Team Innovators

Built by a passionate team of developers:

Pratham Ingawale
Jay Kulkarni
Kshitij Patil
Chaitanya Varekar

Project Images

Winner - ETHDubai 2025 Hackathon
This recognition reflects the strength of our technical execution and the real-world impact of blockchain-powered solutions.

Wallet Address
xdc1e459ad230b7d47b80911161dbbf8368a5b7aedf

[Informative] A Guide to Migrating from Truffle to Hardhat on the XDC Network: EVM Smart Contract Development

Jay_Kulkarni — Fri, 19 Apr 2024 17:14:30 +0000

Truffle has long been a popular choice for EVM smart contract development, but as the ecosystem evolves, developers are increasingly turning to tools like Hardhat for their flexibility and advanced features. In this guide, we'll walk through the process of migrating your Truffle project to Hardhat, highlighting the benefits along the way.

Understanding the Need for Migration

Truffle has served us well, but Hardhat offers a more robust development environment with features like built-in support for TypeScript, a powerful task system, and extensive plugin support.

Preparing for Migration
Before we dive into migration, ensure you have Node.js installed on your machine. Then, install Hardhat globally using npm:

npm install -g hardhat

Setting Up Your Hardhat Project
Navigate to your project directory and initialize a new Hardhat project:

hardhat init

Migrating Contracts
Copy your contracts from the Truffle contracts/ directory to Hardhat's contracts/ directory. Hardhat fully supports Solidity contracts, so no changes are necessary here.

Migrating Tests
If you have migration written for your Truffle project, move them to the test/ directory in your Hardhat project. Hardhat supports both JavaScript and TypeScript for writing tests, providing flexibility and type safety.

Creating an Environment File
Hardhat supports the use of environment variables for sensitive information like API keys. Create a .env file in your project directory and add your variables in the format VARIABLE_NAME=VALUE. For example:

XDC_TESTNET_URL=https://apothem.xdcrpc.com
PRIVATE_KEY=your_private_key

Configuring Hardhat
Hardhat's configuration file, hardhat.config.js, where you'll define your network configurations, plugins, and other project settings. Customize this file according to your project's requirements.

Adding XDC Network in your hardhat.config.js file
Once you've set up your project and are ready to configure your Hardhat environment, you'll need to add the XDC Network configuration to your hardhat.config.js file. This step is crucial for interacting with the XDC Network and verifying contracts on BlocksScan.

Open your hardhat.config.js file and add the following code snippet:

require('dotenv').config();
require('@nomiclabs/hardhat-ethers');
require("@nomicfoundation/hardhat-verify");

module.exports = {
    solidity: "0.8.24",
    networks: {
        apothem: {
            url: process.env.XDC_TESTNET_URL,
            accounts: [process.env.PRIVATE_KEY]
        }
    },
    etherscan: {
        apiKey: {
            apothem: "abc",
            devnet: "abc",
            xdc: "abc",
        },
        customChains: [
            {
                network: "apothem",
                chainId: 51,
                urls: {
                    apiURL: "https://abapi.blocksscan.io/api",
                    browserURL: "https://apothembeta.blocksscan.io/",
                },
            }
        ],
    },
    sourcify: {
        enabled: false
    }
};

Installing Necessary Plugins
To enhance your Hardhat development experience, it's crucial to install necessary dependencies and enable the hardhat-plugin-verify.
Install the required dependencies using npm:

npm install dotenv
npm install --save-dev @nomiclabs/hardhat-ethers --force
npm install --save-dev @nomicfoundation/hardhat-verify --force
npm install --force @openzeppelin/contracts
npm install --save-dev ethers@^5.7.2

Testing and Debugging
With your project migrated, take advantage of Hardhat's advanced testing and debugging tools. Run your tests using npx hardhat test and leverage Hardhat's console for interactive debugging sessions.

Deploying Your Contracts
Once everything looks good, it's time to deploy your contracts. Hardhat supports deployment to various networks, including local development environments and public testnets.

To deploy your contracts using Hardhat, you can use the following command:

npx hardhat run test/1_initial_migration.js --network apothem

Verifying Contracts on BlocksScan
Similar to Truffle, Hardhat allows for easy contract verification on BlocksScan. Utilize plugins or built-in functionality to verify your contracts and increase transparency for users.

After successful deployment, verify the contract using the following command:

npx hardhat verify --network apothem DEPLOYED_CONTRACT_ADDRESS

Conclusion
Congratulations on successfully deploying your smart contracts on the XDC Network using Hardhat! This achievement marks a significant milestone in your blockchain journey. Armed with the skills to navigate Hardhat's robust toolset and harness the capabilities of the XDC Network efficiently, you're well-equipped to explore decentralized applications (DApps) and smart contract development further.

Keep your curiosity alive, continue learning, and embrace the endless possibilities offered by this groundbreaking technology. For queries or assistance, feel free to leave a comment below or connect with us on social media by tagging XDC Network.

Happy coding!

Follow us to know more updates:

[Informative] Deploying and Verifying a Pepe Token on the XDC Network using Hardhat

Jay_Kulkarni — Thu, 28 Mar 2024 18:48:18 +0000

In the fast-evolving world of blockchain technology, crafting and deploying personalized tokens has never been easier. This guide will take you on a journey through deploying and authenticating a Pepe token, inspired by the popular meme, on the XDC Network using Hardhat. By following these steps, you'll delve into the realm of smart contract development and deployment on a real-world blockchain platform.

Prerequisites:
Before initiating the deployment and validation process, ensure that you have the following prerequisites in place:

Node.js and npm:
Install Node.js and npm (Node Package Manager) on your machine to execute commands and manage dependencies efficiently.
Hardhat Installed:
Globally install Hardhat on your system using npm to leverage its robust features for smart contract development and deployment.

Follow these steps to compile, deploy, and verify your smart contract:

Step 1: Creating a Project Directory
Start by creating a directory for your blockchain project using the following command:

mkdir my-pepe-project

Replace my-pepe-project with your desired project directory name.

Step 2: Navigating into the Directory
Once the directory is created, navigate into it using the cd command:

cd my-pepe-project

Step 3: Initializing Hardhat
Initialize Hardhat within your project directory by running the following command:

npx hardhat init

Choose to create a JavaScript project when prompted.

C:\Users\admin\Desktop\hardhat>npx hardhat init
Need to install the following packages:
hardhat@2.22.2
Ok to proceed? (y)
888    888                      888 888               888
888    888                      888 888               888
888    888                      888 888               888
8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
888    888 .d888888 888    888  888 888  888 .d888888 888
888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888

Welcome to Hardhat v2.22.2

√ What do you want to do? · Create a JavaScript project
√ Hardhat project root: · C:\Users\admin\Desktop\hardhat
√ Do you want to add a .gitignore? (Y/n) · y
√ Help us improve Hardhat with anonymous crash reports & basic usage data? (Y/n) · y
√ Do you want to install this sample project's dependencies with npm (hardhat @nomicfoundation/hardhat-toolbox)? (Y/n) · y

The initialized project has the following structure:

contracts/
ignition/modules/
test/
hardhat.config.js

These are the default paths for a Hardhat project.

contracts/ is where the source files for your contracts should be.
ignition/modules/ is where the Ignition modules that handle contract deployments should be.
test/ is where your tests should go.

Step 4: Creating a .env File
Generate a .env file and define the following environment variables:

PRIVATE_KEY=your_private_key
XDC_TESTNET_URL=https://apothem.xdcrpc.com

Replace your_private_key with your private key.

Step 5: Pepe Token Contract Code
Rename the file contracts/lock.js to contracts/PepeToken.sol and insert the provided code.

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

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

contract PepeToken is ERC20 {
    constructor(uint256 initialSupply) ERC20("PepeToken", "PEPE") {
        _mint(msg.sender, initialSupply);
    }
}

Step 6: Adding XDC Network Configuration
In your hardhat.config.js file, append the provided configuration.

require('dotenv').config();
require('@nomiclabs/hardhat-ethers');
require("@nomicfoundation/hardhat-verify");

module.exports = {
    solidity: "0.8.24",
    networks: {
        apothem: {
            url: process.env.XDC_TESTNET_URL,
            accounts: [process.env.PRIVATE_KEY]
        }
    },
    etherscan: {
        apiKey: {
            apothem: "abc",
            devnet: "abc",
            xdc: "abc",
        },
        customChains: [
            {
                network: "apothem",
                chainId: 51,
                urls: {
                    apiURL: "https://abapi.blocksscan.io/api",
                    browserURL: "https://apothembeta.blocksscan.io/",
                },
            }
        ],
    },
    sourcify: {
        enabled: false
    }
};

Step 7: Installing Dependencies
Install the required dependencies by running the provided commands.

npm install dotenv
npm install --save-dev @nomiclabs/hardhat-ethers --force
npm install --save-dev @nomicfoundation/hardhat-verify --force
npm install --force @openzeppelin/contracts
npm install --save-dev ethers@^5.7.2

Step 8: Pepe Token Deployment Script
Create a deployment script test/deploy.js and include the provided code.

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

async function main() {
 const PepeToken = await ethers.getContractFactory("PepeToken");
 const pepeToken = await PepeToken.deploy(1000000); // Initial supply: 1,000,000 tokens

 await pepeToken.deployed();

 console.log("PepeToken deployed to:", pepeToken.address);
 console.log("PepeToken deployed to HASH:", pepeToken.deployTransaction.hash);
}

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

Step 9: Compiling Smart Contracts
Compile your smart contracts for deployment and testing using the following command:

npx hardhat compile

Upon successful execution, you'll witness an output similar to the one below:

PS C:\Users\admin\Desktop\hardhat> npx hardhat compile
Compiled 1 Solidity file successfully (evm target: paris).

Step 10: Deploying Smart Contracts
Deploy your compiled smart contract by executing the deployment script:

npx hardhat run test/deploy.js --network apothem

After it's done running successfully, you'll see output something like this:

PS C:\Users\admin\Desktop\hardhat> npx hardhat run test/deploy.js --network apothem
Compiled 6 Solidity files successfully (evm target: paris).
PepeToken deployed to: 0xB172ed448de08306d996E1C54cb38e08Fa94C79e
PepeToken deployed to HASH: 0x5e9655182018d7861b3b4ff4b1fb72d465d37ef558619a886f7a2c49e2112856

Upon deployment, you'll receive a transaction hash. To verify the contract deployment, scrutinize the BlocksScan explorer using this hash.

Step 11: Verifying Smart Contracts

Verify your deployed smart contract following the provided steps.

Open and scrutinize the deploy.js file situated inside the test folder.
Identify the parameter passed to the constructor of the PepeToken contract during deployment.
Include this parameter in the verification command:

npx hardhat verify --network apothem DEPLOYED_CONTRACT_ADDRESS 1000000

Once the verification is successful, you'll receive an output similar to the one below:

PS C:\Users\admin\Desktop\hardhat> npx hardhat verify --network apothem 0xB172ed448de08306d996E1C54cb38e08Fa94C79e 1000000
Successfully submitted source code for contract
contracts/PepeToken.sol:PepeToken at 0xB172ed448de08306d996E1C54cb38e08Fa94C79e
for verification on the block explorer. Waiting for verification result...

Successfully verified contract PepeToken on the block explorer.
https://apothembeta.blocksscan.io/address/0xB172ed448de08306d996E1C54cb38e08Fa94C79e#code

Congratulations on successfully deploying your smart contracts on the XDC Network using Hardhat! This achievement marks a significant milestone in your blockchain journey. Armed with the skills to navigate Hardhat's robust toolset and harness the capabilities of the XDC Network efficiently, you're well-equipped to explore decentralized applications (DApps) and smart contract development further. Keep your curiosity alive, continue learning, and embrace the endless possibilities offered by this groundbreaking technology. For queries or assistance, feel free to leave a comment below or connect with us on social media by tagging XDC Network. Happy coding!

[Informative] Deploying and Verifying a DogeCoin-inspired ERC20 Token on the XDC Network using Hardhat

Jay_Kulkarni — Thu, 28 Mar 2024 10:50:01 +0000

In the dynamic landscape of blockchain technology, creating and deploying custom tokens has become increasingly accessible. This guide will walk you through deploying and verifying a DogeCoin-inspired ERC20 token on the XDC Network using Hardhat. By following these steps, you'll gain practical insights into smart contract development and deployment on a real-world blockchain network.

Prerequisites:
Before diving into the deployment and verification process, ensure you have the following prerequisites in place:

Node.js and npm:
Install Node.js and npm (Node Package Manager) on your machine to execute commands and manage dependencies.
Hardhat Installed:
Install Hardhat globally on your system using npm to leverage its powerful features for smart contract development and deployment.

Follow the steps to Compile, Deploy and verify your smart contract:

Step 1: Creating a Directory
Create a directory for your blockchain development project using the following command:

mkdir my-hardhat-project

Replace "my-hardhat-project" with the desired name for your project directory.

Step 2: Navigating into the Directory
Once the directory is created, navigate into it using the cd command:

cd my-hardhat-project

Step 3: Initializing Hardhat
Initialize Hardhat within your project directory by running the following command:

npx hardhat init

Choose the option to create a JavaScript project when prompted.

The initialized project has the following structure:

contracts/
ignition/modules/
test/
hardhat.config.js

These are the default paths for a Hardhat project.

contracts/ is where the source files for your contracts should be.
ignition/modules/ is where the Ignition modules that handle contract deployments should be.
test/ is where your tests should go.

Step 4: Create .env File
create a .env file and set the following environment variables:

PRIVATE_KEY=your_private_key
XDC_TESTNET_URL=https://apothem.xdcrpc.com

Replace PRIVATE_KEY with your private key.

Step 5: DogeCoin Contract Code
Rename the file contracts/lock.js to contracts/DogeCoin.sol and add the following code:

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

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

contract DogeCoin is ERC20 {
    constructor(uint256 initialSupply) ERC20("DogeCoin", "DOGE") {
        _mint(msg.sender, initialSupply);
    }
}

Step 6: Adding XDC Network Configuration
In your hardhat.config.js file, add the following configuration:

require('dotenv').config(); //all the key value pairs are being made available due to this lib
require('@nomiclabs/hardhat-ethers');
require("@nomiclabs/hardhat-etherscan");


module.exports = {
solidity: "0.8.20",
  networks: {
    apothem: {
      url: process.env.XDC_TESTNET_URL,
      accounts: [process.env.PRIVATE_KEY]
    }
  },
  etherscan: {
    apiKey: {
      apothem: "abc",
      devnet: "abc",
      xdc: "abc",
    },
    customChains: [
      {
        network: "apothem",
        chainId: 51,
        urls: {
          apiURL: "https://abapi.blocksscan.io/api",
          browserURL: "https://apothembeta.blocksscan.io/",
        },
      },
      {
        network: "devnet",
        chainId: 551,
        urls: {
          apiURL: "https://devnetapi.blocksscan.io/api",
          browserURL: "https://devnet.blocksscan.io/",
        },
      },
      {
        network: "xdc",
        chainId: 50,
        urls: {
          apiURL: "https://bapi.blocksscan.io/api",
          browserURL: "https://beta.blocksscan.io/",
        },
      },
    ],
  },
};

Step 7: Installing Dependencies
Install the necessary dependencies by running the following commands:

npm install dotenv
npm install --save-dev @nomiclabs/hardhat-ethers --force
npm install --save-dev @nomiclabs/hardhat-etherscan --force
npm install --force @openzeppelin/contracts
npm install --save-dev ethers@^5.7.2

Step 8: DogeCoin Deploy Script
Create a deploy script test/deploy.js and add the following code:

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

async function main() {
  const DogeCoin = await ethers.getContractFactory("DogeCoin");
  const dogeCoin = await DogeCoin.deploy(1000000); // Initial supply: 1,000,000 tokens

  await dogeCoin.deployed();

  console.log("DogeCoin deployed to:", dogeCoin.address);
  console.log("DogeCoin deployed to HASH:", dogeCoin.deployTransaction.hash);
}

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

Step 9: Compiling Smart Contracts
Compile your smart contracts for deployment and testing using the following command:

npx hardhat compile

Once command run successfully, you’ll see output similar to the following:

After the initial compilation, Hardhat will try to do the least amount of work possible the next time you compile. For example, if you didn't change any files since the last compilation, nothing will be compiled:

To force a compilation you can use the --force argument, or run npx hardhat clean to clear the cache and delete the artifacts.

Step 9: Deploying Smart Contracts
Deploy your compiled smart contract by running the deploy script:

npx hardhat run test/deploy.js --network apothem

After running the command, you should receive output similar to the following:

After deploying the contract, you will receive a transaction hash. To verify the contract deployment, you can check the BlocksScan explorer using this transaction hash.

Step 10: Verifying Smart Contracts
Verify your deployed smart contract by following these steps:

Open and review the deploy.js file located inside the test folder.
Identify the parameter passed to the constructor of the DogeCoin contract during deployment.
Include this parameter in the verification command:

npx hardhat verify --network apothem DEPLOYED_CONTRACT_ADDRESS  1000000

Replace DEPLOYED_CONTRACT_ADDRESS with your contract address.

Congratulations! By successfully deploying your smart contracts on the XDC Network using Hardhat, you've achieved a significant milestone in your blockchain development journey. This article has provided you with the necessary skills to navigate Hardhat's robust toolset and harness the capabilities of the XDC Network efficiently. As you continue to explore decentralized applications (DApps) and smart contract development, remember to remain curious, continuously learn, and embrace the endless possibilities that this groundbreaking technology presents. If you have any questions or need assistance, don't hesitate to leave a comment below or connect with us on social media by tagging XDC Network. Happy coding!

[Informative] How to Deploy and Verify Smart Contracts on XDC Network using HardHat

Jay_Kulkarni — Wed, 27 Mar 2024 18:21:10 +0000

Navigating the landscape of smart contract deployment and verification on the XDC Mainnet/ Apothem Testnet/ Devnet via Hardhat empowers developers with a robust and streamlined approach to safeguard the integrity and effectiveness of their decentralized applications (DApps). This inclusive manual serves as your compass, guiding you through every step from environment configuration to the seamless deployment and verification of smart contracts.

Prerequisites:
Before diving into the deployment and verification process, ensure you have the following prerequisites in place:

Git Installed:
You need Git installed on your system to clone the repository containing necessary files.
Node.js and npm:
Ensure you have Node.js and npm (Node Package Manager) installed on your machine to execute commands and manage dependencies.
Hardhat Installed:
Install Hardhat globally on your system using npm to utilize its powerful features for smart contract development and deployment.

Let’s start! We will use the “XDC Apothem network” to deploy a smart contract here.

To get some test funds, visit XDC-BlocksScan Faucet, Enter your XDC wallet address and click the “Request XDC” button.

Step 1: Clone the Repository
Start by cloning the repository that holds the important files needed to deploy and check smart contracts on the Apothem testnet or Devnet.

git clone https://github.com/0xmetaschool/Mint-Elon-Must-NFT

Step 2: Create .env File
After cloning the repository, create a .env file and set the following environment variables:

PRIVATE_KEY=your_private_key
API_URL_KEY=https://apothem.xdcrpc.com

Replace PRIVATE_KEY with your private key.

Step 3: Install dependencies
To install dependencies,

npm install

After installing you will be able to see the node_modules folder.

Step 4: Add XDC Network in your hardhat.config.js file
Copy the below code and paste it in your hardhat.config.js file

  etherscan: {
    apiKey: {
      apothem: "abc",
      devnet: "abc",
      xdc: "abc",
    },
    customChains: [
      {
        network: "apothem",
        chainId: 51,
        urls: {
          apiURL: "https://abapi.blocksscan.io/api",
          browserURL: "https://apothembeta.blocksscan.io/",
        },
      },
      {
        network: "devnet",
        chainId: 551,
        urls: {
          apiURL: "https://devnetapi.blocksscan.io/api",
          browserURL: "https://devnet.blocksscan.io/",
        },
      },
      {
        network: "xdc",
        chainId: 50,
        urls: {
          apiURL: "https://bapi.blocksscan.io/api",
          browserURL: "https://beta.blocksscan.io/",
        },
      },
    ],
  },

After you've added it, your file will appear like this.

/**
 * @type import('hardhat/config').HardhatUserConfig
 */
 require('dotenv').config(); //all the key value pairs are being made available due to this lib
 require('@nomiclabs/hardhat-ethers');

 const {API_URL_KEY, PRIVATE_KEY} = process.env; //environment variables are being loaded here.

 module.exports = {
   solidity: "0.8.1",
   defaultNetwork: 'apothem',
   networks: {
     hardhat: {},
     apothem: {
         url: API_URL_KEY,
         accounts: [`0x${PRIVATE_KEY}`]
     }
   },
   etherscan: {
    apiKey: {
      apothem: "abc",
      devnet: "abc",
      xdc: "abc",
    },
    customChains: [
      {
        network: "apothem",
        chainId: 51,
        urls: {
          apiURL: "https://abapi.blocksscan.io/api",
          browserURL: "https://apothembeta.blocksscan.io/",
        },
      },
      {
        network: "devnet",
        chainId: 551,
        urls: {
          apiURL: "https://devnetapi.blocksscan.io/api",
          browserURL: "https://devnet.blocksscan.io/",
        },
      },
      {
        network: "xdc",
        chainId: 50,
        urls: {
          apiURL: "https://bapi.blocksscan.io/api",
          browserURL: "https://beta.blocksscan.io/",
        },
      },
    ],
  },
 };

Step 5: Starting a Local Ethereum Node
To start a local Ethereum node for development and testing purposes, you can use the following command:

npx hardhat node

Step 6: Compile your smart contracts
To compile your smart contracts for deployment and testing, run the below command

npx hardhat compile

This command ensures that your Solidity code is translated into bytecode.Once command run successfully, you’ll see output similar to the following:

Step 7: Cleaning the Build Artifacts
If you want to clean the build artifacts generated during the compilation process, you can use the following command:

npx hardhat clean

This command removes all the build artifacts, including compiled contracts and other temporary files.

Step 8: Running Tests
Hardhat provides a testing framework that allows you to write and run tests for your smart contracts. You can run tests using the following command:

npx hardhat test

This command executes all the tests defined in the test/ directory and provides detailed output regarding the test results.

Step 9: Deploy your compiled smart contract
Once compiled successfully, run the below command for deploying

node scripts/sample-script.js

After deployment, you'll receive a transaction hash. Verify the contract deployment by checking the BlocksScan explorer using this hash.

Make sure to save that contract address for later use.

Step 10: Verify Smart Contracts
To verify your deployed smart contract, follow these steps:

Install the package named @nomiclabs/hardhat-etherscan.

npm install --save-dev @nomiclabs/hardhat-etherscan

Now required that dependencies in your hardhat.config.js file

Open and review the sample-script.js file located inside the scripts folder.Locate the main function in the script and identify the parameter passed to the constructor of the Greeter contract during deployment

During verification, include this parameter in the verification command.Your command should resemble the example below.

npx hardhat verify --network apothem DEPLOYED_CONTRACT_ADDRESS 'Hello, Class!

Replace DEPLOYED_CONTRACT_ADDRESS with the address you copied earlier

Congratulations! By successfully deploying your smart contracts on the XDC Network using Hardhat, you've taken a significant step forward in your blockchain development journey. This article has equipped you with the essential skills to navigate Hardhat's powerful toolset and leverage the capabilities of the XDC Network effectively. As you delve deeper into the world of decentralized applications (DApps) and smart contract development, remember to stay curious, keep learning, and explore the vast array of possibilities that this innovative technology offers. Should you have any questions or need further assistance, feel free to drop a comment below or reach out on social media, tagging XDC Network. Happy coding!

A Step-by-Step Guide: How to Add/View NFTs in MetaMask Using Contract address

Jay_Kulkarni — Fri, 23 Jun 2023 15:29:58 +0000

MetaMask, a popular cryptocurrency wallet and decentralized application (dApp) browser extension, has gained significant traction in the world of non-fungible tokens (NFTs). NFTs, unique digital assets stored on blockchain networks, have become a vibrant part of the digital art, collectibles, and gaming industries. If you are an NFT enthusiast and want to explore or manage your NFTs within MetaMask using contract codes, this guide will walk you through the process.

To deploy and mint your first NFT refer, How to Deploy XRC721/NFT Contract and mint your First NFT using Remix

Step 1: Install MetaMask
If you don’t have MetaMask, start by installing the MetaMask extension and follow the installation instructions displayed on the screen to set up the MetaMask wallet.

Step 2: Access MetaMask Wallet
After installation, access the wallet by clicking the MetaMask extension icon in the toolbar of your browser. If you are using MetaMask for the first time, you must create a new wallet by following the instructions and storing your seed phrase safely.

Step 3: Connect to a Supported Blockchain Network
MetaMask supports various blockchain networks, including XDCNetwork, Ethereum, Binance Smart Chain, and others. If you want to add any other networks you can go through this. Ensure that you are connected to the Correct network where the NFT contract you want to add/view resides.

To add XDC Network manually, refer below details:

XDC Apothem Network
RPC — https://rpc.apothem.network
Chain Id — 51
URL — https://apothem.blocksscan.io

XDC Mainnet
RPC — https://eRPC.BlocksScan.io
Chain Id — 50
URL — https://xdc.blocksscan.io

You can also switch between networks by clicking on the network name at the top of the MetaMask wallet.

Step 4: Add the NFT Contract

To add an NFT contract to MetaMask, you’ll need the contract address. If you don’t have it, refer to this link to create our contract address. Once you have the contract address, follow these steps:

Click on the NFT’s tab in the MetaMask wallet.

Click on the Import NFTs.

Enter the NFT Contract address and token Id in the provided field.

Now, Click on Add button to complete the process.

Step 5: View your NFTs

Congratulations! You’ve successfully added your NFT in your metamask wallet. Well done!

How to Deploy XRC721/NFT Contract and mint your First NFT using Remix

Jay_Kulkarni — Sat, 17 Jun 2023 10:48:13 +0000

In this tutorial, we will explore the final step in the NFT tutorial series, which focuses on viewing your newly minted NFT on a virtual wallet. Let’s demonstrate the process using MetaMask and the XDC Apothem network. Additionally, we will provide some insights about the XDC network’s relation to NFTs.

Understanding XDC and NFTs:
The XDC Network — XinFin Hybrid Blockchain, offers a scalable and efficient infrastructure for various decentralized applications, including non-fungible tokens (NFTs). With its high transaction throughput and low fees, the XinFin - XDC Network. Refer the articles about XDC Network: https://docs.xdc.org/xdc-tools/

Now, Let’s start the actual setup:

Step 1: Deploy an NFT contract with XinFin Remix

What is XinFin Remix?

XinFin Remix is an integrated development environment (IDE) specifically designed for developing and testing smart contracts on the XinFin blockchain platform. It provides a web-based interface where developers can write, compile, and deploy their Solidity smart contracts. It is a powerful tool that simplifies the smart contract development process, making it easier for developers to build and deploy decentralized applications on the XinFin network.

Let’s start by creating a MyNFT.sol file. To create a new file, click on the “Create new file” icon positioned at the top Left of the main screen.

Select a proper compiler version, language as Solidity and click on the "Compile MyNFT.sol" button.

Here, we have provided our NFT smart contract code. To add this code to your own project, simply copy and paste the contents below into your MyNFT.sol file. This code serves as the foundation for creating and managing your own non-fungible tokens (NFTs).

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

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

contract MyNFT is ERC721URIStorage, Ownable {
    constructor() ERC721("MyNFT", "NFT") {}

    function mint(
        address _to,
        uint256 _tokenId,
        string calldata _uri
    ) external onlyOwner {
       _mint(_to, _tokenId);
       _setTokenURI(_tokenId, _uri);

    }
}

Once you have written your contract code, click on the “Compile icon” button at the top of the Remix interface. This will show you “compile button“ By clicking on this button, you will initiate the compilation process for your contract. It will examine your code for syntax errors or warnings that may be present, allowing you to identify and address them.

After a successful compilation, navigate to the “Deploy & Run Transactions” screen.

Now, select Injected Web3 as the environment and make sure your Metamask wallet is unlocked and connected to the appropriate Network and address with the Remix.

Make sure your MetaMask wallet is unlocked and connected to the XinFin Apothem network.

Finally, click on the "Deploy" button to deploy your contract to the XDC Apothem network.

Once the deployment is successful, Remix will provide you with the transaction hash and the deployed contract address. These details allow you to interact with your contract on the XDC Apothem network. Additionally, if you want to explore and monitor your contract's activity, you can easily track it on the BlocksScan Explorer. Simply enter your contract address in the explorer's search bar, and you'll gain access to a comprehensive view of your contract's transactions and other relevant information.

The "From address" will be a "Contract Creation" address and the "To address" will be a "Contract address". By clicking on the Contract address, you will be able to see the deployed contract details(Token details).

Congratulations! You've successfully deployed your NFT smart contract to the XDC Apothem! Well done!

Now, Add Your NFT's in NFT.STORAGE

NFT.Storage is a service that specializes in storing the metadata of Non-Fungible Tokens (NFTs) in a decentralized manner. It provides a convenient solution for developers and creators to securely store and retrieve the metadata associated with their NFTs. By leveraging decentralized storage systems like IPFS (InterPlanetary File System),One of the powerful features of NFTs is that they can reference off-chain data, saving you the cost of storing your images, videos, and other large NFT data on-chain. An example of this is with the ERC-1155 standard, which defines places where you should reference data off-chain via URIs.

If you're unfamiliar with the process of adding NFTs to NFS.Storage, you can refer to this article on How to Upload NFTs to NFT.Storage for step-by-step instructions.

Once you successfully upload the images and metadata file ,you'll see your main screen similar to the following, Keep your metadata "VIEW URL" safe. We'll need this in a future step.

Let's interact with Contract to Mint NFT:

To interact with a contract, copy the Contact address, visit XinFin Remix, enter the contract address into the "At address" input field, and then click on the "At address" button.

Once you Clicked, you will observe that your Contract is now visible in XinFin Remix, indicating its successful deployment.To access the functions, open the dropdown and access the functions.

To mint NFT, access "mint" function, enter "_to" address, "_tokenId" & "_uri" and click on the transact button to complete the minting.

Great! You've successfully deployed your NFT in your smart contract.

Check your NFT in XDC - BlocksScan Explorer

Access the XDC - BlocksScan explorer. After entering your contract address in the search bar, you will be able to view all the transactions.

By clicking on the "View NFT" button, you can also preview your NFT image.

Congratulations on your remarkable achievement! Successfully deploying the NFT in the contract is truly a momentous milestone.

Deploy an XRC721 Contract on XDC Apothem Network using Truffle

Jay_Kulkarni — Fri, 09 Jun 2023 18:13:56 +0000

The XDC network is gaining popularity as a fast, scalable, and cost-effective blockchain platform. With its Apothem network, developers can build decentralized applications (dApps) that leverage the benefits of XDC’s ecosystem. In this article, we will guide you through the process of deploying an XRC721 contract on the XDC Apothem network using Truffle, a popular development framework. By the end of this tutorial, you will be able to create and deploy your own non-fungible tokens (NFTs) on XDC.

What is NFT?

NFT stands for Non-Fungible Token. It is a unique digital asset that represents ownership or proof of authenticity for a specific item or piece of content, such as collectibles, or virtual real estate, on a blockchain. Unlike cryptocurrencies like Bitcoin or Ethereum, NFTs are indivisible and cannot be exchanged on a one-to-one basis due to their unique properties. NFTs have gained popularity for their ability to establish verifiable ownership and provide new opportunities for creators and collectors in the digital realm.

Before we begin, ensure that you have the following prerequisites:

In order to create a Truffle project, we need NPM and Node on our local machine. You can download both for free.

$ node -v
$ npm -v

Wallet and Testnet XDC:

To successfully transfer contacts onto Apothem, it is essential to authorize transactions and cover the associated gas expenses. To accomplish this, it is imperative to possess a cryptocurrency wallet capable of accommodating the gas currency.

One of the highly acclaimed options for a self-custodial wallet in the current market is BlocksPay. Renowned for its popularity, BlocksPay is not only free but also offers a secure and user-friendly experience. Accessible as a browser extension, you can conveniently download BlocksPay to avail its benefits.

For users who are new to BlocksPay, the wallet setup process includes a series of guided steps to ensure a seamless experience. As you progress, Blockspay will offer the opportunity to enhance the security of your wallet. It is crucial to take advantage of this option and diligently save your wallet’s secret recovery phrase. This recovery phrase will play a significant role in subsequent steps, so its preservation is essential.

Once you unlock your wallet, you will see the dashboard screen. On the top center of your BlocksPay window, click on the Network dropdown and select the XDC Apothem network.

As you may have already guessed, BlocksPay comes automatically configured with the XDC Apothem testnet. We don’t have to do any additional configuration.

Upon your initial usage of Apothem, you will notice a balance of 0 XDCT. However, we can rectify this by obtaining a portion of free XDCT from the Faucet.

Step 1: Set up the project

Let’s start by setting up a new project directory for our XRC721 contract. Open your terminal and create a new directory for the project:

mkdir xdc-apothem-nft

cd xdc-apothem-nft

Once inside the project directory, initialize a new Truffle project with given command:

$ npm install -g truffle

$ truffle init

$ npm install dotenv

$ npm install @openzeppelin/contracts @truffle/hdwallet-provider dotenv

This will create the necessary project structure for us to work with.

Step 2: Configure Truffle for XDC Apothem network

To ensure our Truffle project can interact with the XDC Apothem Network, we need to configure it properly. Follow the steps below:

Create a new file in the project’s root directory named .env.
Add the following contents to the .env file:

MNEMONIC=” YOUR METAMASK WALLET RECOVERY PHRASE ”

Within the networks section, add the configuration for the
Apothem network. Here’s an example configuration:

javascript
module.exports = {
  networks: {
    development: {
      host: "127.0.0.1",
      port: 8545,
      network_id: "*"
    },
    apothem: {
      provider: () => new HDWalletProvider("<your-mnemonic>", "https://apothem.xdcrpc.com/"),
      network_id: 1666700000,
      gasPrice: 1000000000,
      gas: 8000000
    }
  },
};

Replace <your-mnemonic> with your wallet mnemonic or private key. The gasPrice and gas values can be adjusted according to your needs.

Step 3: Write the XRC721 contract

In this step, we will write the XRC721 contract that will define our NFTs. Create a new Solidity file called ApothemNft.sol in the contracts directory of your project.

XDC Network is EVM Compatible, So here in ApothemNft.sol, we are importing the necessary libraries and defining the ERC721 contract. Here’s a basic example:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract ApothemNft is ERC721URIStorage {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;
    string private _metadataUrl;

    constructor() ERC721("Apothem NFT", "ANFT") {

        // Set metadata of the NFT
        _metadataUrl = "ipfs://QmUyZoK21qb8YknXGfDB34RTY8vMqPb6Bsj9U9iLEnyrZR";

        // Mint NFT
        _mintNFT();
    }

    function _mintNFT() private {
        _tokenIds.increment();

        uint256 newItemId = _tokenIds.current();
        _mint(msg.sender, newItemId);
        _setTokenURI(newItemId, _metadataUrl);
    }
}

In this example, we import the required ERC721 and Counters libraries from OpenZeppelin. The mintNFT function allows us to mint new NFTs and assign them to recipients with the provided token URI.

Step 4: Compile and migrate the contract

Now that we have our XRC721 contract ready, we can compile and migrate it to the XDC Apothem network.

In your terminal, run the following command to compile the contract:

truffle compile

If the compilation is successful, you’ll see output similar to the following:

PS C:\Desktop\contract> truffle compile

Compiling your contracts...
===========================
> Compiling @openzeppelin\contracts\interfaces\IERC165.sol
> Compiling @openzeppelin\contracts\interfaces\IERC4906.sol
> Compiling @openzeppelin\contracts\interfaces\IERC721.sol
> Compiling @openzeppelin\contracts\token\ERC721\ERC721.sol
> Compiling @openzeppelin\contracts\token\ERC721\IERC721.sol
> Compiling @openzeppelin\contracts\token\ERC721\IERC721Receiver.sol
> Compiling @openzeppelin\contracts\token\ERC721\extensions\ERC721URIStorage.sol
> Compiling @openzeppelin\contracts\token\ERC721\extensions\IERC721Metadata.sol
> Compiling @openzeppelin\contracts\utils\Address.sol
> Compiling @openzeppelin\contracts\utils\Context.sol
> Compiling @openzeppelin\contracts\utils\Counters.sol
> Compiling @openzeppelin\contracts\utils\Strings.sol
> Compiling @openzeppelin\contracts\utils\introspection\ERC165.sol
> Compiling @openzeppelin\contracts\utils\introspection\IERC165.sol
> Compiling @openzeppelin\contracts\utils\math\Math.sol
> Compiling @openzeppelin\contracts\utils\math\SignedMath.sol
> Compiling .\contracts\Nft.sol
> Artifacts written to C:\Users\kulka\OneDrive\Desktop\contract\build\contracts
> Compiled successfully using:
   - solc: 0.8.19+commit.7dd6d404.Emscripten.clang

If the compilation is successful, you should see a build directory created within your project, containing the compiled contract artifacts.

Step 5: Deploy the Contract to Apothem Testnet

Once we have successfully compiled our contract and set up our Truffle project, the next step is to create a deployment script that will deploy our contract on the Apothem testnet.

In the migrations folder of your project, create a new file called 1_deploy_contract.js and add the following code:

// Get instance of the Apothem NFT contract
const ApothemNftContract = artifacts.require("ApothemNft");

module.exports = function (deployer) {
    // Deploy the contract to Apothem
    deployer.deploy(ApothemNftContract);
};

Next, let’s migrate the contract to the XDC Apothem network. Run the following command:

truffle migrate --network apothem

If the deployment is successful, you’ll see a response similar to the following:

Starting migrations...
======================
> Network name:    'apothem'
> Network id:      51
> Block gas limit: 420000000 (0x1908b100)


1_deploy_contract.js
====================

   Deploying 'ApothemNft'
   ----------------------
   > transaction hash:    0x99c5bbb2bd105170f77baa985a6087fe6ff8e7b5ea353c5e647352c6b989dd15
   > Blocks: 2            Seconds: 4
   > contract address:    0xCD6E45a39966585d1B4C35B3cc5e4C278c595BB1
   > block number:        50195140
   > block timestamp:     1686328463
   > account:             0x7447Ac246AEefBFBf56D02c4c466a9f33f51eEc7
   > balance:             14963.999221539875
   > gas used:            2763463 (0x2a2ac7)
   > gas price:           0.25 gwei
   > value sent:          0 ETH
   > total cost:          0.00069086575 ETH

   > Saving artifacts
   -------------------------------------
   > Total cost:       0.00069086575 ETH

Summary
=======
> Total deployments:   1
> Final cost:          0.00069086575 ETH

Truffle will deploy the contract to the XDC Apothem network using the configuration we defined earlier. Once the migration is complete, Truffle will display the deployed contract address on the network.

Step 6: Interact with the deployed contract

Congratulations! You have successfully deployed your XRC721 contract on the XDC Apothem network. Now, access the BlocksScan Apothem Explorer to view the Deployed Contract. To view the Contract code, we need to verify the code on BlocksScan Apothem Explorer. Also you can interact with the contract to mint some NFTs.

Conclusion

In this article, we have learned how to deploy an XRC721 contract on the XDC Apothem network using Truffle. You should now have a good understanding of the necessary steps to create and deploy your own NFTs on XDC. Feel free to explore more advanced features and customize your contract to suit your specific requirements. Happy coding!

For any doubts or questions comment below or post on social media by tagging BlocksScan.

Follow BlocksScan to know more updates:

Unlocking the Full Potential: A Step-by-Step Guide to Connecting BlocksPay to the XDC Network

Jay_Kulkarni — Wed, 07 Jun 2023 11:30:33 +0000

The BlocksPay is an innovative, decentralized, and user-friendly Web3 browser wallet. With BlocksPay, users can effortlessly manage their digital assets, interact with decentralized applications (DApps), and explore the vast opportunities offered by the XDC Network. The wallet ensures the highest level of security by empowering users with full control over their private keys and keeping custody of their assets. In this article, we will provide you with a step-by-step guide on how to connect BlocksPay to the XDC Network, enabling you to experience the full potential of this exciting blockchain ecosystem.

Installation Process

To get started, you need to install the BlocksPay extension. Click on the BlocksPay Once you find the appropriate link, click on the “Add to chrome” button located in the top right corner of the page.

Proceed to add the BlocksPay extension to your browser by following the installation instructions specific to your browser. Once the installation is complete, you are ready to proceed.

Creating Your BlocksPay Wallet

Upon opening the BlocksPay extension for the first time, you will be greeted with a window that provides a brief overview of BlocksPay’s features. Here, you have the option to either create a new wallet or restore an existing one. Let’s start by creating a new wallet.

Click on the “Create a new wallet” button, and you will be prompted to set a password. Enter a strong password and click “Next.”

You will be asked to confirm your password by entering it again.

Once confirmed, it’s time to generate your secret recovery phrase.

A window will appear displaying your unique secret recovery phrase. Please note that the words shown below are for illustrative purposes only, and your recovery phrase will consist of a different set of completely random words. It is crucial to write down your secret recovery phrase and keep it in a safe place. Never share your recovery phrase with anyone, as it grants full access to your wallet and crypto assets. Once you have securely noted your recovery phrase, click “Next.”

To verify that you have correctly recorded your secret recovery phrase, a pop-up will appear, asking you to select the correct words from your unique recovery phrase. Carefully select the words and click “Next” to proceed.

After setting up your secret recovery phrase, your BlocksPay wallet is ready for use. It is important to emphasize that BlocksPay is a non-custodial wallet, meaning that only you have control over your wallet’s keys. Remember the golden rule: “Not your keys, not your crypto!” BlocksPay does not hold custody of your assets and does not collect or sell personal user data. As a final step, we recommend pinning the BlocksPay extension in your browser for easy access.

Restoring BlocksPay Wallet

If you already have a wallet on another compatible platform, such as XdcPay or Metamask, you can import it into BlocksPay. Follow the steps below to restore your existing wallet.

Click on the “Restore existing wallet” button within the BlocksPay extension.

Next, select the option to “Use recovery phrase.”

Enter your 12–24 word recovery phrase and click “Next.”

Once you have entered your recovery phrase, your wallet will be successfully restored.

We recommend pinning the BlocksPay extension to your browser’s extension bar for convenient access.

Connecting BlocksPay to the XDC Network

Once you have installed BlocksPay and created or restored your wallet, it’s time to establish a connection with the XDC Network. Simply click on the dropdown arrow positioned at the top center of the BlocksPay wallet.

Once you have clicked on the dropdown, you will be able to see the Network screen. Here you can select the XDC Mainnet or Apothem Network. Now, you can simply close the window or click the “X” in the top right corner to continue.

Upon closing the pop-up window, you will see the XDC Network added to your network list within BlocksPay. You can now start interacting with the XDC ecosystem.

Basic Functions

Below, we provide screenshots to guide you on how to receive, send, and purchase crypto using BlocksPay. By clicking the drop-down menu located in the top center of the BlocksPay app, you can access your different accounts. BlocksPay generates multiple addresses compatible with both EVM from the same recovery phrase. You can use these addresses to receive crypto into your BlocksPay wallet. The app provides options to copy the address, open a QR code, or view it on a block explorer using the buttons located in the upper right corner.

By clicking on the Deposit button, you will be able to see the account address with QR code. Clicking on “Send” will open a new page within BlocksPay, allowing you to fill in the necessary details to send a transaction.

For detailed guides on using BlocksPay to send, add and import accounts, connect a hardware wallet, and interact with DApps(Coming soon…) on the XDC Network and Ethereum, please refer to this guide article

Some Important links to refer:

BlocksScan Social Channels:

Deploying a Pepe Contract on XinFin and Apothem Networks Using Truffle

Jay_Kulkarni — Thu, 01 Jun 2023 14:33:13 +0000

Smart contracts are a fundamental aspect of blockchain development. In this article, we will walk you through the process of creating a simple (Pepe) smart contract and deploying it on the Apothem network using Truffle, a powerful development tool and testing framework. By following these steps, you’ll gain hands-on experience with Truffle and learn how to compile, deploy, and interact with your smart contract on the XDC Apothem.

Prerequisites:

Node.js installed on your machine
An XDC wallet for testing purposes. You can use the Metamask or Blockspay wallet by adding XDC Apothem Network.

To add network manually in Metamask refer below details:

XDC Apothem Network
RPC: https://rpc.apothem.network
Chain Id: 51
URL: https://apothem.blocksscan.io

Now, Let’s start the actual setup:

Step 1: Set Up a New Truffle Project
Create a new directory for your project using the command line. Execute the following commands:

mkdir truffleProject

For changing the directory, enter below command:

cd truffleProject

Step 2: Installing Truffle
Truffle simplifies smart contract development and provides a testing framework for blockchain networks. Install Truffle globally using the Node.js package manager by executing the following command in your terminal:

npm install -g truffle

Step 3: Funding your XDC Account
To proceed with deploying your smart contract on the Apothem network, you’ll need testnet XDC(tXDC) in your XDC account. Use the BlocksScan Faucet to load testnet XDC onto your account specifically for the Apothem network. If you plan to use a different network, ensure that you update your environment file with the appropriate network name.

Step 4: Installing Dotenv
Dotenv allows you to store private environment variables in a .env file on your local machine. This is useful for securely managing your wallet’s mnemonic. Install the dotenv package by running the following command:

npm install dotenv –-save

Step 5: Creating a Truffle Project
Truffle provides a project initialization command that generates the necessary directory structure for testing and deploying contracts. Execute the following command to create a bare Truffle project:

truffle init

Truffle will create the following directory structure for your project:

contracts/: Directory for your Solidity contracts
migrations/: Directory for scriptable deployment files
test/: Directory for files that test your application and contracts
truffle-config.js: Truffle configuration file

Step 6: Installing hdwallet-provider
“hdwallet-provider” is a package that enables transaction signing for addresses derived from a 12 or 24-word mnemonic. By default, the hdwallet-provider uses the first address generated from the mnemonic, but this behavior can be customized. Run the following command to install hdwallet-provider:

npm install @truffle/hdwallet-provider

Step 7: Creating the .env File
Create a .env file in your project directory to store your project and XDC apothem/mainnet account details securely. The .env file should include your Metamask/Blockspay and XDCpay secret recovery. Refer the below points:

Here is an example of the .env file contents:

MNEMONIC = Your-Secret-Recovery-Phrase

Make sure to replace with the mnemonic of your wallet. Remember, never disclose your secret recovery phrase as it can be used to steal your assets.

Step 8: Creating a Smart Contract
Using your preferred code editor, create a new file called PepeToken.sol within the contracts/ directory. This file will contain a basic smart contract called PepeToken. Here’s an example of the contract code:

Refer this link to copy the PepeToken contract code.

Step 9: Configuring Truffle Settings
Modify the truffle-config.js file located in the root directory of your project. This file contains the configuration settings for Truffle, including the integration of the HDWalletProvider and network-specific deployment configurations. Make sure to require the dotenv package and access the required environment variables. Refer to the Truffle documentation for detailed information on configuring Truffle settings.

require('dotenv').config();
    const { MNEMONIC } = process.env;
    const HDWalletProvider = require('@truffle/hdwallet-provider');

    module.exports = {

      networks: {

        xinfin: {
          provider: () => new HDWalletProvider(
            MNEMONIC,
            'https://erpc.apothem.network/'),
          network_id: 50,
          gasLimit: 6721975,
          confirmation: 2,
        },

        apothem: {
          provider: () => new HDWalletProvider(
            MNEMONIC,
            'https://erpc.apothem.network'),
          network_id: 51,
          gasLimit: 6721975,
          confirmation: 2,
        }
      },

      mocha: {
      },

      compilers: {
        solc: {
          version: "0.8.16",
        }
      },
    };

Step 10: Compiling the Smart Contract
To compile the smart contract, navigate to the root directory of your project in the terminal and run the following command:

truffle compile

If the compilation is successful, you’ll see output similar to the following:

Compiling your contracts...
===========================
> Compiling ./contracts/PepeToken.sol
> Artifacts written to /home/omkar/Desktop/New_truffle/build/contracts
> Compiled successfully using:
   - solc: 0.8.16+commit.07a7930e.Emscripten.clang

The compiled artifacts will be placed in the build/contracts/ directory relative to your project root.

Step 11: Creating the Deployment Script
Truffle uses migration scripts to deploy smart contracts. These scripts are located in the migrations/ directory and are numbered to determine the execution order. Create a new file called 1_deploy_contract.js in the migrations/ directory and add the following code:

const Demo_Contract = artifacts.require("PepeToken");

let TotalValue = 100000000000;

module.exports = function(deployer) {
  deployer.deploy(Demo_Contract,TotalValue);
};

Step 12: Deploying the Smart Contract
To deploy the smart contract on the XDC Apothem network, execute the following command in the terminal:

truffle migrate --network Apothem

If the deployment is successful, you’ll see a response similar to the following:

Compiling your contracts...
===========================
> Everything is up to date, there is nothing to compile.
Starting migrations...
======================
> Network name:    'apothem'
> Network id:      51
> Block gas limit: 420000000 (0x1908b100)
1_deploy_contract.js
====================
   Deploying 'PepeToken'
   ---------------------
   > transaction hash:    0x4caecd574ccd8553e163d2e5aa74ab229cd62198484ed9036435382868405f47
   > Blocks: 2            Seconds: 4
   > contract address:    0x7A95f2579eF1700048455271272f178e79b965E6
   > block number:        49838985
   > block timestamp:     1685611976
   > account:             0x35ef9e7eCB979297907370C2Ab64ef4a8a3F2FbE
   > balance:             4502.997212086625
   > gas used:            2723061 (0x298cf5)
   > gas price:           0.25 gwei
   > value sent:          0 ETH
   > total cost:          0.00068076525 ETH
   > Saving artifacts
   -------------------------------------
   > Total cost:       0.00068076525 ETH
Summary
=======
> Total deployments:   1
> Final cost:          0.00068076525 ETH

Use a block explorer like BlocksScan to view the transaction details, that includes transaction hash, contract address, block number, and gas usage.

Congratulations! You have successfully created a simple smart contract and deployed it on the Apothem network using Truffle. This article has provided you with a solid foundation for working with Truffle and deploying contracts on the XDC network (apothem/mainnet). Explore the documentation and resources to expand your knowledge and continue building decentralized applications.For any doubts or questions comment below or post on social media tagging BlocksScan.

How to Restore an Existing Wallet in BlocksPay and How to take a backup of your BlocksPay Wallet?

Jay_Kulkarni — Mon, 20 Mar 2023 06:20:56 +0000

BlocksPay is a cryptocurrency wallet used to interact with the EVM Compatible blockchains such as XDC Network, Ethereum, and many more in near future.

BlocksPay allows users to store and manage account keys, broadcast transactions, send and receive EVM Compatible cryptocurrencies and tokens, and securely connect to decentralized applications through a compatible web browser.

Hey folks, Don’t know how to restore a wallet? Then you’re in the correct place.

Let’s start to restore an existing wallet on BlocksPay!

Follow the below few steps and easily restore your existing wallet.

Step 1: Once you successfully download your extension, click on the “Restore existing wallet” button to restore your existing wallet account.

Step 2: After clicking on the restore existing wallet button, the user will be able to see ‘’Two’’ options. Now, Click on the “Use recovery phrase” option.

Step 3: Here, users need to enter their recovery phrase(Seed Phrase words). Once entered, click on the “Next” button.

Step 4: Now, create a new password to unlock the wallet. Once you enter the password click on the “Next” button.

Step 5: Confirm the Password and click on “Next” button.

Step 6: Now, click on the Finish button. To Pin the BlocksPay extension, Click on the puzzle icon on the Browser, find BlocksPay icon and click on the Pin icon to pin it.

Let’s take a backup of the BlocksPay Wallet?

With a few steps users can take a backup of their Recovery phrase(Seed Phrase).

Step 1: It is very easy to take a backup of your BlocksPay wallet, click here on the ‘’THREE ‘’dots and then visit the “Settings” tab.

Step 2: After clicking on the ‘’Settings’’, click on the “View my recovery phrase” tab.

Step 3: Unlock the wallet by entering the password.

Step 4: Once you entered the password, you will see your recovery phrase. Make sure you will not share this to anyone.

This is how users can take a backup of the BlocksPay Wallet.

Explore the BlocksPay and share your feedback with the BlocksScan Team!

For any queries, follow BlocksScan — Social channels:

BlocksPay Twitter: https://twitter.com/blockspaywallet

First post on XDC Dev

Jay_Kulkarni — Tue, 08 Nov 2022 08:08:57 +0000

function hello(name)
{
  console.log('Hello ' + name);
}

hello('XDC Network!')

Developers Forum for XinFin XDC Network: Jay_Kulkarni

ETHDubai:XDC Hackathon Revolutionizing Global Supply Chains with XDC Network

The Challenge

Our Solution

Tech Stack Highlights

How It Works

Smart Contract Automation

QR Code Traceability

Key Advantages

Live Demo

Deployed On

Team Innovators

Project Images

[Informative] A Guide to Migrating from Truffle to Hardhat on the XDC Network: EVM Smart Contract Development

Understanding the Need for Migration

[Informative] Deploying and Verifying a Pepe Token on the XDC Network using Hardhat

Follow these steps to compile, deploy, and verify your smart contract:

[Informative] Deploying and Verifying a DogeCoin-inspired ERC20 Token on the XDC Network using Hardhat

[Informative] How to Deploy and Verify Smart Contracts on XDC Network using HardHat

Let’s start! We will use the “XDC Apothem network” to deploy a smart contract here.

A Step-by-Step Guide: How to Add/View NFTs in MetaMask Using Contract address

How to Deploy XRC721/NFT Contract and mint your First NFT using Remix

Now, Let’s start the actual setup:

Now, Add Your NFT's in NFT.STORAGE

Check your NFT in XDC - BlocksScan Explorer

Deploy an XRC721 Contract on XDC Apothem Network using Truffle

Step 1: Set up the project

Step 2: Configure Truffle for XDC Apothem network

Step 3: Write the XRC721 contract

Step 4: Compile and migrate the contract

Step 5: Deploy the Contract to Apothem Testnet

Step 6: Interact with the deployed contract

Conclusion

Unlocking the Full Potential: A Step-by-Step Guide to Connecting BlocksPay to the XDC Network

Installation Process

Creating Your BlocksPay Wallet

Restoring BlocksPay Wallet

Connecting BlocksPay to the XDC Network

Basic Functions

Deploying a Pepe Contract on XinFin and Apothem Networks Using Truffle

How to Restore an Existing Wallet in BlocksPay and How to take a backup of your BlocksPay Wallet?

Let’s start to restore an existing wallet on BlocksPay!

Let’s take a backup of the BlocksPay Wallet?

First post on XDC Dev

Output: