Developers Forum for XinFin XDC Network: Satheesh Kumar

XDC.cash showcase product - XDC Payments ecosystem

Satheesh Kumar — Fri, 14 Feb 2025 10:10:08 +0000

XDC.cash is a next-generation payment solutions platform designed for fintech companies, cross-border payment institutions, and crypto-focused enterprises, offering seamless financial transactions with blockchain technology.
Currently in its beta launch phase for the XDC community, XDC.Cash provides an easy-to-use off-ramp solution to convert XDC tokens into fiat currency. Based on user feedback, the service will soon be available to the general public.

How to Use XDC.Cash

1. Access the Service
Visit https://xdc.cash/.
Click on “Click here to Access demo” to proceed.
Ensure that pop-ups are enabled in your browser to avoid access issues.

2. Navigate the Widget
A new window will open with the XDC.Cash widget. Follow these steps:
Select Your Country
Choose your country from the provided list to comply with regulations.
Login with Email and Use Passkeys
Enter your email and follow the authentication process using passkeys.
Connect Your Wallet
Select your preferred wallet and allow the necessary permissions to connect it.
Complete KYC Verification
Upload the required identity verification documents.
Wait for the KYC process to complete (status will be updated accordingly).
Confirm KYC Completion
Once verified, a blue tick will appear on the menu option.

3. Deposit Funds
Add Bank Details
Enter your banking information for future transactions.
Initiate a Deposit
Click on the Deposit option to begin the fund transfer process.
Transfer funds from your EOA (Externally Owned Account) wallet to your platform-managed wallet.
Modify Address Format
Change the address prefix from xdc to 0x when entering your deposit address.

Enter Deposit Amount
Specify the amount of XDC to deposit.
The widget will display the equivalent amount in FIAT currency.
Submit the Request
Review and confirm the transaction details before submitting.

4. Check Transaction Status
Check the Status
Navigate to the menu bar to track transaction history.
The initial status will appear as ACKNOWLEDGED.
Completion Confirmation
Once the transaction is successfully processed, the status will change to COMPLETED.

Beta Launch and Community Feedback

This off-ramp solution is currently in beta phase and is open for community testing. Your feedback will help us enhance the platform before its public release. We encourage users to report any issues or share suggestions to improve the service.

XDC.Cash bridges the gap between crypto and traditional finance by offering a reliable, compliant, and user-friendly on/off-ramp solution. Whether you're an individual user or a business, the platform provides a seamless way to integrate XDC payments and withdrawals into your daily financial operations.

ERC-4337 Shared Mempool Live on XDC network

Satheesh Kumar — Tue, 14 Jan 2025 07:27:10 +0000

Revolutionizing Blockchain User Experience with Account Abstraction

The XDC Network is proud to announce the launch of Shared Mempools on Etherspot’s Account Abstraction (AA) infrastructure. This innovation marks a significant milestone in enhancing the user and developer experience within the XDC ecosystem by simplifying blockchain interactions and introducing advanced decentralization mechanisms.

If you are new to the topic of Account Abstraction or to understand more on Shared mempols refer to my previous articles.
https://www.xdc.dev/satz07/unlocking-blockchain-usability-with-account-abstraction-and-chain-abstraction-on-the-xdc-network-3jk7
https://www.xdc.dev/satz07/unlocking-blockchain-usability-with-account-abstraction-and-chain-abstraction-on-the-xdc-network-3jk7
https://www.xdc.dev/satz07/exploring-erc-4337-shared-mempools-a-decentralized-future-for-account-abstraction-on-the-xdc-network-5e2a

Understanding Bundlers
With the introduction of Account Abstraction, blockchain technology takes a leap towards more intuitive and seamless interactions. At the heart of this advancement lies the concept of bundlers—specialized entities designed to aggregate multiple user operations (UserOps) into a single transaction before submitting them to the blockchain.

This approach introduces several benefits:

Streamlined Transactions: Reduces complexity for end-users by abstracting cryptographic signatures and gas management.
Cost Efficiency: Lowers transaction costs by bundling multiple operations.
Enhanced Usability: Paves the way for Web2-like experiences in the Web3 world.

Shared Mempool: The Backbone of Decentralized Bundlers
To enable the decentralized operation of bundlers, the Shared Mempool was developed in collaboration with leading teams, including Etherspot, ERC-4337 contributors, and ecosystem partners.

Key Benefits of the Shared Mempool:
Decentralized Processing: Ensures that UserOps validated by one bundler are shared across a peer-to-peer network of bundlers.
Increased Network Resilience: Prevents delays or congestion by allowing any available bundler in the network to process UserOps.
Elimination of Single Points of Failure: Enhances the censorship resistance and openness of the blockchain.

The Shared Mempool mimics the standard mempool functionality found on blockchains but is tailored for UserOps, providing a reliable mechanism for decentralized transaction processing.

Why This Matters for the XDC Network
By deploying Shared Mempools and AA infrastructure, the XDC Network opens up new possibilities for building decentralized applications with enhanced efficiency and accessibility. Key advantages includes Simplified User Experience,Improved Developer Tools,Scalability and Sustainability

Building the Future of Blockchain on XDC
The Shared Mempool infrastructure represent a transformative step forward in creating a blockchain ecosystem that is user-friendly, scalable, and resilient. This initiative aligns with the XDC Network's vision to foster innovation and adoption in the blockchain space.

Join us in shaping the future of decentralized technology. The Shared Mempool is now live on the XDC Network—ready for developers and users to explore its full potential!

Exploring ERC-4337 Shared Mempools: A Decentralized Future for Account Abstraction on the XDC Network

Satheesh Kumar — Tue, 26 Nov 2024 07:34:43 +0000

In the Web3 ecosystem, decentralized applications (dApps) drive innovation, but user experience remains a key barrier to mass adoption. Account abstraction (AA) is a game-changing concept designed to simplify user interactions with blockchain, making them as intuitive as using traditional applications. However, existing implementations of account abstraction often lean on centralized infrastructure, introducing vulnerabilities like system bugs, faulty relayers, and even censorship.

To address these challenges, the concept of ERC-4337 shared mempools has emerged, offering a decentralized approach to handling user operations (UserOps). This article delves into the mechanics and benefits of shared mempools and how they can revolutionize the XDC Network’s account abstraction capabilities.

If you are new to the topic of Account Abstraction refer to my previous articles.
https://www.xdc.dev/satz07/unlocking-blockchain-usability-with-account-abstraction-and-chain-abstraction-on-the-xdc-network-3jk7
https://www.xdc.dev/satz07/unlocking-blockchain-usability-with-account-abstraction-and-chain-abstraction-on-the-xdc-network-3jk7

What Are Shared Mempools in ERC-4337?

ERC-4337 introduced a decentralized architecture for account abstraction, comprising two key innovations:

A separate mempool for managing UserOps from smart contract wallets.
Bundlers, entities responsible for validating and submitting UserOps to the blockchain. Shared mempools enable bundlers to collaborate in a peer-to-peer network, ensuring seamless UserOp processing across different bundlers. By decentralizing the UserOp handling process, shared mempools eliminate single points of failure and censorship risks associated with centralized relayers.

How Shared Mempools Work

1. User Operation Submission: A user initiates a transaction via a smart account. The transaction is packaged as a UserOp and submitted to a bundler.
2. Peer-to-Peer Propagation: The bundler validates the UserOp and propagates it to other bundlers connected to the shared mempool through a peer-to-peer (P2P) network.
3. Resilience in Processing: If one bundler fails (due to bugs, downtime, or malicious behavior), other bundlers in the network pick up the UserOp, ensuring it is processed and added to the blockchain.
4. Canonical and Custom Mempools: Each blockchain network typically maintains a canonical mempool, adhering strictly to ERC-4337 rules. Bundlers can also establish custom mempools to accommodate specific needs, such as integrating a paymaster for gasless transactions or bypassing certain checks for specialized use cases.

Benefits of Shared Mempools

1. Decentralization: Shared mempools eliminate the reliance on centralized relayers, enhancing the censorship resistance and trustlessness of account abstraction.
2. Resilience and Redundancy: The P2P nature of shared mempools ensures that even if some bundlers experience issues, others can take over, reducing the risk of failed transactions.
3. Scalability: Shared mempools allow bundlers to process UserOps efficiently, enabling higher transaction throughput across the network.
4. Flexibility: Bundlers can join or leave a shared mempool dynamically and create custom mempools tailored to specific requirements.
5. Improved User Experience: By enabling features like gasless transactions through paymasters, shared mempools make blockchain interactions smoother and more intuitive, bringing blockchain closer to mainstream usability.

How to Connect a Bundler to Shared Mempools on XDC

1. Unique Mempool IDs: Each shared mempool is identified by a unique ID, referencing its metadata stored on IPFS.
2. Bundler Configuration: To connect to a shared mempool, a bundler includes the mempool ID in its metadata. This allows peer bundlers to determine compatibility and share UserOps seamlessly.
3. Canonical Shared Mempool: Developers can refer to the canonical mempool ID for XDC, which will adhere strictly to ERC-4337 rules, ensuring interoperability with other networks like Ethereum and Goerli.
4. Active Collaboration: Any of the community can ru the bundlers like Skandha and join the XDC bundler network, enabling a robust ecosystem for UserOp processing.

The Future of Shared Mempools on XDC

As the XDC Network prepares to integrate ERC-4337 shared mempools, it will open up new possibilities for developers and users alike. By decentralizing account abstraction infrastructure and enhancing the reliability of UserOps, XDC can offer a superior user experience and position itself as a leader in blockchain innovation.

With shared mempools and account abstraction, the XDC Network is poised to become a hub for seamless, decentralized interactions, driving mass adoption of Web3 technologies.

Introduction to ERC-3643: Enhancing Digital Asset Compliance in Web3

Satheesh Kumar — Tue, 26 Nov 2024 07:25:45 +0000

Overview

The ERC-3643 standard brings a new level of compliance and control to blockchain assets, making it especially relevant for industries needing strict regulatory adherence. Known as the "Compliance Token Standard," ERC-3643 enables issuers to enforce compliance requirements directly on-chain. With this standard, organizations can better manage their assets, ensuring only authorized participants engage with their tokens while maintaining the decentralized benefits of blockchain.

Why ERC-3643 Matters for Tokenizing Real-World Assets

Tokenization of Real-World Assets (RWAs) holds the promise of making traditionally illiquid assets (like real estate, commodities, and financial instruments) accessible on blockchain platforms. For these tokenized assets to work effectively, however, regulatory compliance is paramount. ERC-3643 allows asset issuers to implement know-your-customer (KYC) and anti-money laundering (AML) checks directly into the asset's smart contract. This feature is particularly valuable for the XDC Network, which is designed to support regulated institutions, such as banks and enterprises, by bringing compliant RWAs on-chain.

Key Features of ERC-3643

Access Control: Provides issuers with the ability to restrict or grant access to the token, ensuring only approved participants can buy, sell, or trade.
On-Chain Compliance: Enables issuers to integrate KYC/AML rules directly into token transactions, reducing the risk of regulatory violations.
Revocable Permissions: Allows issuers to revoke permissions, offering an extra layer of security in case of compliance issues.
Flexibility in Transfer Rules: Customizable transfer rules ensure tokens are managed in line with changing regulations.

The Benefits of ERC-3643 on XDC Network The XDC Network, with its focus on RWAs, is an ideal environment for implementing ERC-3643 due to the network’s support for financial-grade, regulated digital assets.

Benefits include:

Improved Compliance: Regulatory compliance embedded directly in tokens reduces risk for issuers.
Enhanced Security: Permissioned tokens provide added control over asset management.
Trustworthy Ecosystem: By adopting ERC-3643, XDC can enhance its reputation as a network that prioritizes regulatory alignment, attracting institutions that require this level of assurance.

Closing Thoughts

As we look to the future, ERC-3643 will be a cornerstone in bringing secure, compliant tokenization to the XDC Network, offering a way to tokenize assets without compromising on regulatory requirements.

Unlocking Blockchain Usability with Account Abstraction and Chain Abstraction on the XDC Network

Satheesh Kumar — Tue, 05 Nov 2024 06:58:42 +0000

Introduction

The blockchain world is evolving to meet increasing user demands for seamless, secure, and flexible solutions. At the forefront of this transformation are account abstraction (AA) and chain abstraction (CA), two powerful paradigms that simplify blockchain interactions, particularly for developers and end-users on the XDC Network. By bringing Ethereum-compatible smart contract technology, high-speed, and low-cost transactions to a wider audience, the XDC Network is positioned as a leading choice for businesses looking to harness the benefits of both abstractions.
This blog explores how account abstraction and chain abstraction are shaping the blockchain landscape, delving into the critical role that Etherspot’s account abstraction (AA) solution already plays on XDC and discussing the future possibilities for chain abstraction in enabling multi-chain ecosystems.

What is Account Abstraction?

In traditional blockchains, users interact with assets using private keys and Externally Owned Accounts (EOAs). While secure, this model has limitations, such as the rigidity in account management and the risk of permanent asset loss if a private key is lost. Account abstraction addresses these challenges by shifting control from EOAs to smart contract-based accounts (also known as "smart accounts"). This enables dynamic, programmable account functionality and improves security and user experience.

Key Benefits of Account Abstraction:

Enhanced Security: Multiple key management options (such as multi-signature and time-based locking) can protect assets from single points of failure.
Gasless Transactions: Using Paymasters, third parties can fund transaction fees, making transactions free for end-users.
Customizable Authentication: Flexibility to add various authentication methods (e.g., biometrics, email, multi-factor authentication).
Seamless Onboarding: Reduces the complexities of wallet management, making it ideal for non-crypto users.

Etherspot’s AA Solution on XDC: The Etherspot AA solution on XDC enhances account abstraction by leveraging programmable accounts that lower transaction costs and provide advanced security features. It allows users to manage transactions efficiently, paving the way for dApps to offer improved user experiences.

What is Chain Abstraction?

Chain abstraction, on the other hand, focuses on hiding the complexities of working across multiple blockchain networks. With chain abstraction, users can interact with dApps across various chains without needing in-depth knowledge of the underlying infrastructure or native tokens required for gas.

Key Benefits of Chain Abstraction:

Interoperability: Cross-chain compatibility makes it easier for developers to build dApps that can operate seamlessly on multiple chains.
Cost Efficiency: Users can benefit from lower transaction costs by transacting on chains with cheaper gas fees as XDC Network.
Reduced Complexity: Users don’t need to manage different native tokens or wallet addresses, enabling a more fluid experience.

Applications for XDC: XDC’s architecture enables secure and fast interoperability, making it ideal for chain abstraction. As more developers deploy on XDC, chain abstraction could allow applications on XDC to connect with other blockchain ecosystems, such as Ethereum, for greater flexibility in token usage and transaction execution. This positions XDC to potentially become a hub in a larger interoperable blockchain network.

Advantages in terms of Liquidity

1. Interoperability for Cross-Chain Assets
Chain abstraction allows users and dApps on XDC to access and manage assets across multiple chains without the complexities typically associated with cross-chain transfers. Through chain abstraction, XDC-based dApps could interact with liquidity pools on chains like Ethereum or BNB Chain, pulling in assets or tokens from other ecosystems and broadening the liquidity available on XDC.

2. Simplified User Experience for Cross-Chain Trading
By abstracting chain-specific complexities, users on XDC can trade assets on different blockchains without switching networks or acquiring native tokens for gas fees on each chain. Users could buy, sell, or swap tokens originating from other chains directly on XDC-based platforms, making the process seamless, which in turn attracts a wider audience and boosts liquidity flow.

3. Enhanced Decentralized Finance (DeFi) Opportunities
Cross-chain liquidity can supercharge XDC’s DeFi ecosystem by enabling decentralized exchanges (DEXs) and liquidity providers to source and pool assets across multiple blockchains. This provides XDC-based DeFi projects with greater liquidity depth, improving trading volume, reducing slippage, and making XDC a more attractive chain for DeFi innovation.

4. Increased Capital Efficiency
With chain abstraction, users can lend, borrow, or leverage assets from different blockchains while staying within the XDC ecosystem. By doing so, XDC maximizes capital efficiency, as assets can move freely to where they’re most productive, increasing returns for users and reducing the need for redundant asset reserves across chains.

5. Broader Market Access and Network Effects
Enabling cross-chain liquidity through chain abstraction attracts dApps and users from different blockchain ecosystems. As assets flow into the XDC Network, the network effect grows, increasing user engagement, transaction volume, and dApp activity. This also enhances XDC’s appeal to developers who want to build cross-chain applications, creating a self-reinforcing cycle of growth and liquidity.

6. Encourages Microtransactions and High-Volume
Activities
XDC’s low gas fees make it viable for microtransactions, enabling use cases like micropayments, IoT data transactions, and small-scale financial activities that are cost-prohibitive on high-fee networks. Chain abstraction further boosts this by allowing seamless transfers between XDC and other ecosystems, keeping costs down while expanding access.

Conclusion

Chain abstraction solution on the XDC Network can transform it into a key player in a multi-chain ecosystem by making cross-chain liquidity accessible and user-friendly. As assets and users from various blockchains converge on XDC, its utility, transaction volumes, and attractiveness to new users will strengthen, propelling XDC’s position in the DeFi and broader Web3 landscape. This makes chain abstraction a strategic avenue for expanding the XDC Network’s liquidity and reach.

Stay tuned for more updates on how XDC Network will support Chain abstraction and paving the way for the future of decentralized applications.!

Gasless Transactions with Account abstraction & Paymasters

Satheesh Kumar — Tue, 22 Oct 2024 07:46:51 +0000

One of the recent advancements in the blockchain space is account abstraction, which simplifies user interactions with decentralized applications (dApps) by abstracting away complex blockchain-specific details. Etherspot, a solution supporting account abstraction, now extends this innovation to the XDC Network, enabling a seamless user experience. A key feature of this setup is gasless transactions, made possible by the use of Paymasters.

To further improve user onboarding, Web3Auth integrates with Etherspot to enable users to log in using familiar social accounts, making the process of accessing their smart contract wallets even simpler.

In this article, we'll dive into how Etherspot facilitates account abstraction on XDC, how Web3Auth enhances the onboarding experience, and how you can enable gasless transactions using Paymasters.

Implementing Web3Auth, Etherspot, and Gasless Transactions
Below is a high-level example of how to implement user authentication with Web3Auth, account abstraction with Etherspot, and gasless transactions using Paymasters on the XDC Network:

import { useState, useEffect } from "react";
import { Web3Auth } from "@web3auth/modal";
import { CHAIN_NAMESPACES, WEB3AUTH_NETWORK } from "@web3auth/base";
import { EthereumPrivateKeyProvider } from "@web3auth/ethereum-provider";
import { ethers } from "ethers";
import { EtherspotBundler, ModularSdk } from '@etherspot/modular-sdk';
import { ERC20_ABI } from '../abi/ERC20_ABI';
import * as dotenv from 'dotenv';
import { sleep } from '@etherspot/modular-sdk/dist/sdk/common';

dotenv.config();

// Setup Web3Auth parameters and initialize chain configurations
const clientId = "WEBS_AUTH_ID";
const erc20TokenAddress = '0x2E71C75Ad02E8ad2eC0f1469de1FC3d835B5E7AD';
const apiKey = "arka_public_key";
const explorerBaseUrl = "https://explorer.apothem.network/";

// Chain configuration for the XDC Apothem test network
const chainConfig = {
  chainId: "0x33",
  rpcTarget: "https://erpc.apothem.network",
  chainNamespace: CHAIN_NAMESPACES.EIP155,
  displayName: "XDC APOTHEM",
  blockExplorerUrl: "https://explorer.apothem.network/",
  ticker: "XDC",
  tickerName: "Xinfin",
  logo: "https://images.toruswallet.io/eth.svg",
};

// Setting up the Ethereum private key provider for Web3Auth
const privateKeyProvider = new EthereumPrivateKeyProvider({
  config: { chainConfig: chainConfig }
});

// Initialize Web3Auth instance
const web3auth = new Web3Auth({
  clientId,
  web3AuthNetwork: WEB3AUTH_NETWORK.SAPPHIRE_DEVNET,
  privateKeyProvider: privateKeyProvider,
});


// Main component function handling Smart Account and minting with Account Abstraction
export function SmartAccountW() {
  const [userPrivateKey, setUserPrivateKey] = useState<string | null>(null); // State for user's private key
  const [message, setMessage] = useState<string | JSX.Element>("");
  const [showPopup, setShowPopup] = useState(false); // State to show/hide popup
  const [recipient, setRecipient] = useState<string>(""); // State for the input user address
  const [value, setValue] = useState<string>(""); // State for the input user address

  // Initialize Web3Auth and Smart Account on component mount
  useEffect(() => {
    const initWeb3Auth = async () => {
      try {
        await web3auth.initModal(); // Initialize Web3Auth modal
        await web3auth.connect(); // Connect to Web3Auth
        if (web3auth.connected) {
          // Fetch private key after connection
          const privateKey = await web3auth.provider?.request({
            method: "eth_private_key",
          });
          if (privateKey) {
            const formattedPrivateKey = `0x${privateKey}`;
            setUserPrivateKey(formattedPrivateKey);
            const wallet = new ethers.Wallet(formattedPrivateKey);

            setShowPopup(true); // Display popup with connection details
          }
        }
      } catch (error) {
        console.error("Web3Auth initialization error:", error);
        setMessage("Error initializing Web3Auth. Please try again.");
        setShowPopup(true);
      }
    };
    initWeb3Auth();
  }, []);



  // Function to mint ERC20 tokens using PayMaster (gasless transaction)
  const handleERC20MintWithPayMaster = async () => {
    if (!userPrivateKey) {
      console.error("User not authenticated");
      setMessage("Error: User not authenticated");
      setShowPopup(true);
      return;
    }

    try {
      const modularSdk = new ModularSdk(
        { privateKey: userPrivateKey },
        {
          chainId: Number(51),
          bundlerProvider: new EtherspotBundler(Number(51)),
        }
      );

      const balance: string = await modularSdk.getNativeBalance();
      console.log("EtherspotWallet balance before:", balance);
      console.log("SCW", await modularSdk.getCounterFactualAddress());

      const provider = new ethers.providers.JsonRpcProvider(process.env.BUNDLER_URL);
      const erc20Instance = new ethers.Contract(erc20TokenAddress, ERC20_ABI, provider);

      const transactionData = erc20Instance.interface.encodeFunctionData('mint', [recipient, ethers.utils.parseEther(value)]);
      const userOpsBatch = await modularSdk.addUserOpsToBatch({ to: erc20TokenAddress, data: transactionData });

      const op = await modularSdk.estimate({
        paymasterDetails: { url: `https://arka.etherspot.io?apiKey=${apiKey}&chainId=${Number(51)}`, context: { mode: 'sponsor' } }
      });

      const uoHash = await modularSdk.send(op);
      console.log(`UserOpHash: ${uoHash}`);

      console.log('Waiting for transaction...');
      let userOpsReceipt = null;
      const timeout = Date.now() + 60000; // 1 minute timeout
      while ((userOpsReceipt == null) && (Date.now() < timeout)) {
        await sleep(2);
        userOpsReceipt = await modularSdk.getUserOpReceipt(uoHash);
      }
      console.log('Transaction Receipt: ', userOpsReceipt);

      const Pbalance: string = await modularSdk.getNativeBalance();
      console.log("EtherspotWallet After:", Pbalance);

      const transactionLink = `${explorerBaseUrl}tx/${userOpsReceipt.receipt.transactionHash}`;
      setMessage(
        <span style={{ color: "green" }}> {/* Change the text color */}
          Mint with PayMaster successful! View the transaction here:{" "}
          <a
            href={transactionLink}
            target="_blank"
            rel="noopener noreferrer"
            style={{ color: "blue", textDecoration: "underline" }} // Change the link color
          >
            {transactionLink}
          </a>
        </span>
      );
      setShowPopup(true);
    } catch (error) {
      console.error("Error in minting transaction:", error);
      setMessage("Error in minting transaction with PayMaster. Please try again.");
      setShowPopup(true);
    }
  };

  return (
    <div className="app-container">
    <div className="paymaster-section">
      <h3>Mint with Smart Account + PayMaster (Gasless)</h3>
      <input type="text" 
          value={recipient} 
          onChange={(e) => setRecipient(e.target.value)} 
          placeholder="Enter recipient address" 
          className="input-field"
        />
        <label className="label">Token Amount:</label>
        <input 
          type="number" 
          value={value} 
          onChange={(e) => setValue(e.target.value)} 
          placeholder="Enter token amount" 
          className="input-field"
        />
      <button className="action-button" onClick={handleERC20MintWithPayMaster} disabled={!userPrivateKey}>
        Mint ERC20 with PayMaster
      </button>
    </div>
    {showPopup}
  </div>
  );
 }

Explanation of the Code
User Authentication with Web3Auth: The Web3Auth instance is initialized with a client ID and XDC chain configuration. This allows users to log in with social accounts, making the onboarding process smooth and accessible. Upon successful login, Web3Auth provides a user-specific private key that can be used to set up the Etherspot SDK.

Setting Up Etherspot: With the private key from Web3Auth, we initialize the Etherspot SDK, which manages interactions with the XDC Network and creates a user-specific smart contract wallet.

Creating a Smart Contract Wallet: Using Etherspot's createAccount() function, we generate a smart contract wallet for the user. This wallet is an essential part of account abstraction, allowing the user to have a programmable account that can automate transactions.

Gasless Transactions with Paymaster: A Paymaster object is used to specify a Paymaster smart contract that will cover the gas fees for transactions. The user can send value (XDC or tokens) without needing to hold XDC for gas, making the experience truly frictionless.

Refer to my previous article [https://www.xdc.dev/satz07/xgate-accelerating-web3-onboarding-with-account-abstraction-web3auth-and-gasless-transactions-on-xdc-network-1jdk] for sample repo to integrate AA in any the web3 platforms and get a web2 experience.

Feel free to leave your suggestions on how we can enhance this project and further develop an ecosystem around Account Abstraction (AA) that benefits all projects on the XDC network.

XGate: Accelerating Web3 Onboarding with Account Abstraction, Web3Auth, and Gasless Transactions on XDC Network

Satheesh Kumar — Thu, 05 Sep 2024 10:31:53 +0000

Web3 projects often face a common challenge: making decentralized technology accessible to everyday users. The complexities of managing wallets, understanding gas fees, and interacting with smart contracts can be intimidating, especially for non-crypto natives. This is where XGate steps in.

XGate is an innovative tool designed to simplify the Web3 user experience. It integrates Web3Auth, Account Abstraction (AA) and gasless transactions through Etherspot Paymaster, making it easy for developers to build decentralized applications that feel like traditional Web2 platforms.

What is Account Abstraction?

Account Abstraction (AA) separates the management of user accounts from the technical details of interacting with the blockchain. Instead of relying solely on Externally Owned Accounts (EOAs), AA uses smart contract-based accounts. This brings a range of benefits:

Smart Accounts: Accounts that can be programmed to handle complex operations, making automation and smart contract interactions easier.
Custom Logic: The ability to embed custom logic in smart accounts, enabling features like multi-sig wallets, time-locked transactions, and more.
Reduced User Complexity: Users don't need to understand the intricacies of private keys and blockchain interactions — it's all abstracted away.
Gasless Transactions for a Better User Experience:
One of the biggest barriers to entry for Web3 users is gas fees — the transaction costs paid in cryptocurrency. XGate solves this problem by integrating Etherspot Paymaster, which allows for gasless transactions.

With gasless transactions, the platform covers the transaction fees, giving users a seamless experience where they don't need to worry about holding cryptocurrency for gas:

Simplified Onboarding: Users can interact with decentralized applications without having to first acquire cryptocurrency for gas fees.
Enhanced Adoption: By removing gas fees, you can onboard a wider range of users who may not be familiar with the nuances of blockchain.
Smoother Experience: Paymaster enables smoother transactions for end users, making Web3 applications feel as intuitive as Web2 platforms.

XGate provides a modular SDK, allowing developers to quickly integrate Account Abstraction and gasless transaction features into their applications.

Sample code is available here https://github.com/satz07/XGate

Building an Ecosystem Together
XGate is just the beginning of what we envision as a much larger movement towards making decentralized applications on XDC accessible to everyone. By leveraging Account Abstraction (AA) and gasless transactions, we’re taking steps toward a more user-friendly Web3 experience.

We invite the developer community to get involved and help us improve this tool. Whether it's through feature suggestions, code contributions, or simply sharing your feedback, your input will help shape the future of the XGate ecosystem and provide a smoother, more intuitive user experience for Web3 projects on XDC.

Feel free to leave your suggestions on how we can enhance this project and further develop an ecosystem around Account Abstraction (AA) that benefits all projects on the XDC network. Let’s work together to simplify Web3 for both developers and users, making the decentralized future a reality.

Note: This is the initial release aimed at supporting projects that require a Web3 + Account Abstraction (AA) solution for immediate use.
This utility will continue to evolve with additional features and integrations, driven by the needs and interests of the users and community.

[Informative] Account Abstraction Support on the XDC Network with Etherspot

Satheesh Kumar — Tue, 02 Jul 2024 10:38:02 +0000

We are thrilled to announce that account abstraction support is now available on the XDC network through Etherspot, and it is live on the testnet! This milestone represents a significant advancement in the usability and functionality of blockchain interactions, making it easier for developers to build more versatile and user-friendly decentralized applications (dApps).

Account abstraction is a concept in the Ethereum blockchain that allows for greater flexibility and functionality when it comes to executing transactions and smart contracts. It is an upgrade to the Ethereum Virtual Machine (EVM) that introduces new features and capabilities.

Traditionally, in Ethereum, user accounts are externally owned accounts (EOAs) and smart contracts are contract accounts. EOAs are controlled by private keys and can send and receive ether, while contract accounts hold the code and state of smart contracts and can be interacted with by sending transactions to them.

Account abstraction brings several benefits to the Ethereum ecosystem:

Enhanced efficiency: By allowing contracts to directly control funds, account abstraction reduces the number of transactions and storage operations required. This leads to improved efficiency and reduces gas costs.

Improved privacy: Account abstraction enables the creation of more sophisticated smart contracts that can handle transactions privately within the contract itself. It eliminates the need for external transactions, enhancing privacy for users.

Flexible fee payment models: With account abstraction, contracts can pay transaction fees on behalf of users. This allows for more flexible fee payment models, such as subscriptions or microtransactions, where users don’t need to have ether to execute transactions.

Customized transaction semantics: Account abstraction opens up possibilities for customizing transaction semantics. Contracts can define their own rules and conditions for executing transactions, enabling more complex and dynamic interactions.

How to Get Started
To start experimenting with account abstraction on the XDC network using Etherspot, follow these steps:

Set Up Your Development Environment:
Ensure you have Node.js installed. Then, clone the Etherspot Modular SDK repository from GitHub:

git clone https://github.com/etherspot/etherspot-modular-sdk.git
cd etherspot-modular-sdk
npm install

Configure the SDK:
Update your environment configuration with the following details:

const bundlerApiKey = 'your-api-key-here';
const bundlerUrl = 'https://testnet-rpc.etherspot.io/v2/51';
const entryPoint = '0x0000000071727De22E5E9d8BAf0edAc6f37da032';

Initialize and Use Etherspot:
Use the following code snippet to initialize Etherspot and interact with the XDC testnet:

import { EtherspotBundler, ModularSdk } from '@etherspot/modular-sdk';
import * as dotenv from 'dotenv';

dotenv.config();

async function main() {
  const modularSdk = new ModularSdk(
    { privateKey: process.env.WALLET_PRIVATE_KEY },
    {
      chainId: 51,
      bundlerProvider: new EtherspotBundler(51, bundlerUrl),
      entryPoint
    }
  );

  const address = await modularSdk.getCounterFactualAddress();
  console.log(`Etherspot Wallet Address: ${address}`);

  // Additional logic for your dApp
}

main().catch(console.error);

Join the Community
We invite developers and enthusiasts to test out these features on the XDC testnet. Your feedback will be invaluable in improving and refining the tools and capabilities we offer.

Stay tuned for more updates as we continue to enhance the Account abstraction capabilities on the XDC network.

Happy coding!

[Informative] Harnessing AI in Smart Contract Development: Remix IDE Integrates ChatGPT

Satheesh Kumar — Wed, 08 May 2024 10:38:14 +0000

As the boundaries of blockchain technology continue to expand, the tools we use to interact with and develop on various platforms are also evolving. In a significant development, Remix, one of the most popular Ethereum development environments, has integrated ChatGPT into its interface. This integration marks a pivotal moment for smart contract developers, offering a powerful new way to streamline and enhance the coding process.

The latest update to Remix IDE brings with it an exciting beta feature—the integration of ChatGPT. This integration aims to leverage the capabilities of AI to assist developers in writing, testing, and deploying smart contracts more efficiently. Here’s how ChatGPT can assist within the Remix environment:

Code Assistance: ChatGPT can help generate code snippets, explain complex code blocks, and offer suggestions for code improvement. This can be particularly helpful for new developers or those looking to optimize existing contracts.
Debugging Help: Often, debugging smart contracts can be a tedious task. ChatGPT can help explain error messages and suggest corrections, potentially reducing the time developers spend on troubleshooting.
Documentation and Tutorials: ChatGPT can dynamically generate documentation and tutorials based on the context of the project you’re working on, providing a customized learning experience.
Interactive Learning: For educational purposes, ChatGPT can act as an interactive tutor, helping developers understand Solidity concepts and smart contract design patterns through conversation.

The integration of ChatGPT into Remix IDE represents a leap forward in the blending of AI with blockchain development tools. This feature could not only enhance the productivity of individual developers but also accelerate the overall pace of smart contract development. As AI continues to evolve, its integration into development environments like Remix could become standard practice, opening new avenues for innovation and efficiency in blockchain technology.

XDC network is keeping pace with the latest developments in AI through its platform, coderun.ai. Furthermore, XDC is advancing its integration of AI by incorporating it into the blocksscan explorer, which can be accessed here: https://apothem.blocksscan.io/AI.

[Informative] XDC Subnets and Deployment Guide

Satheesh Kumar — Thu, 31 Aug 2023 08:18:43 +0000

The much awaited feature of the XDC network, the Subnets, is here.!

Blockchain technology has revolutionized the way we envision decentralized systems, enabling trust, security, and transparency. However, as the popularity of blockchain platforms grows, challenges related to scalability, speed, and efficiency have become more pronounced. To tackle these issues, various projects are exploring innovative solutions. One such solution is the XinFin XDC Network and its unique feature: XDC Subnets. In this blog, we will dive into the concept of XDC Subnets, their significance, and how they contribute to overcoming scalability limitations.

The link provides a good understanding of XDC subnets and its importance.
https://docs.xdc.network/subnet/

XDC Subnets can be understood as individual sidechains within the XinFin XDC Network ecosystem. These subnets operate independently while remaining interconnected to the main XDC Network through the use of Relayers and checkpoint smart contracts. Each XDC Subnet can have its own tokenomics, and governance rules, making it a highly customizable and flexible solution.

Benefits of XDC Subnets

Scalability: One of the most significant challenges facing many blockchain platforms is scalability. As the number of users and transactions increases, the main network can become congested, leading to slower transaction processing times and higher fees. XDC Subnets address this issue by allowing transactions to be processed on separate sidechains, thus significantly increasing the network's capacity to handle more transactions simultaneously.

Efficiency: XDC Subnets enable improved resource allocation. Different use cases can be allocated to different subnets, preventing resource contention and enhancing overall network efficiency. This means that applications with specific requirements, such as high throughput or privacy, can be catered to more effectively.

Customization: Each XDC Subnet can have its own set of rules, and even tokens. This flexibility allows enterprises and developers to create tailored solutions that suit their specific requirements. For instance, one subnet might focus on supply chain management, while another might be optimized for decentralized finance (DeFi) applications.

Interoperability: While XDC Subnets operate as separate entities, they can still interact with each other and the main XDC Network through Relayers and smart contracts. This interoperability allows for the seamless transfer of assets across different subnets, creating a unified ecosystem.
XDC subnet-mainnet checkpointing is light-client based and the relayer cannot foul anyone. This is much more secure than the common bridge, which is controlled by a third-party which has to be trusted.

Reduced Transaction Costs: With increased scalability and optimized resource allocation, XDC Subnets can potentially lead to lower transaction costs compared to traditional blockchain networks, making it more feasible for both individuals and enterprises to participate.

Privacy:: Only consensus info (i.e., headers) of the subnets are checkpointed to XDC mainnet,the parent chain, so there is no exposure of subnet transactions to the public.

XDC Subnets represent a pioneering solution to the challenges of scalability and efficiency that have long plagued traditional blockchain networks. By offering a customizable, interconnected, and scalable ecosystem, XinFin's XDC Network paves the way for a new generation of blockchain applications. As the technology continues to evolve, XDC Subnets could play a pivotal role in transforming industries and driving the widespread adoption of blockchain solutions.

XDC Subnets Deployment Guide

Prerequisites:
docker - 20.10.25
docker compose - v2.12.2
OS - Linux. Only Linux is supported right now, due to docker network limitation
For manual installation of docker compose V2 please refer to: https://docs.docker.com/compose/install/linux

Steps:
Clone the repo

git clone https://github.com/XinFinOrg/XinFin-Node.git
cd XinFin-Node/subnet/deployment-generator/

Create a new environment file
cp docker.env.example docker.env
Update the below params in the env file

CONFIG_PATH= (~/XinFin-Node/subnet/deployment-generator)
NETWORK_NAME=CUSTOM_NAME (xdcsubnet)
NUM_MACHINE=1
NUM_SUBNET=3
MAIN_IP=IP_OF_THE_BOOT_SERVER <1.11.111.111>
PARENTCHAIN=devnet
PARENTCHAIN_WALLET=Wallet address
PARENTCHAIN_WALLET_PK=Wallet private key

Pull the latest subnet-generator image
docker pull xinfinorg/subnet-generator:latest

Run the below command while will generate all the required files in the generated directory
docker run --env-file docker.env -v $(pwd)/generated:/app/generated xinfinorg/subnet-generator:latest && cd generated

Follow the generated commands (machine1) in commands.txt file as below to start Subnet Nodes and make sure they are mining

To check if new blocks are being mined use the below commands (8545,8546 and 8547 for 3 subnets) and see if the block number is increasing.

Below commands will update the block numbers when new blocks are being mined.
Each subnet will have its own genesis block and the block numbers will be different.
One subnet cannot be able to communicate with the other subnets and only the parent chain has a checkpoint smart contract for each subnet.

curl --location 'http://localhost:8545' \
--header 'Content-Type: application/json' \
--data '{"jsonrpc":"2.0","method":"XDPoS_getV2BlockByNumber","params":["latest"],"id":1}'

Deploy subnet on machine1
cd ~/.XinFin-Node/subnet/deployment-generator/generated

 docker compose --env-file docker-compose.env --profile machine1 pull
  docker compose --env-file docker-compose.env --profile machine1 up -d

Deploy checkpoint smart contract (please be mindful of docker image tag if you are not using 'latest')

cd ~/.XinFin-Node/subnet/deployment-generator
  docker run --env-file docker.env \
    -v $(pwd)/generated/deployment.json:/app/generated/deployment.json \
    --entrypoint 'bash' xinfinorg/subnet-generator:latest ./deploy_csc.sh 
  make an edit to ./config/common.env to include values for CHECKPOINT_CONTRACT which is generated in the above step

Start services and frontend

docker compose --env-file docker-compose.env --profile services pull
  docker compose --env-file docker-compose.env --profile services up -d

Use the docker ps -a command and check if the below processes are running and check the logs with docker logs <container_id>.

CONTAINER ID   IMAGE                                   COMMAND                  CREATED        STATUS                          PORTS                                                                                                     NAMES
3a8dfd10ec75   xinfinorg/subnet-frontend:v0.1.1        "docker-entrypoint.s…"   21 hours ago   Up 20 hours                     0.0.0.0:5000->5000/tcp                                                                                    generated-frontend-1
8460ad3ea79f   xinfinorg/subnet-stats-service:v0.1.1   "docker-entrypoint.s…"   21 hours ago   Up 20 hours                     443/tcp, 0.0.0.0:3000->3000/tcp                                                                           generated-stats-1
7bd263401024   xinfinorg/xdc-relayer:v0.1.1            "docker-entrypoint.s…"   21 hours ago   Up 20 hours                     3000/tcp                                                                                                  generated-relayer-1
23c154f2568e   xinfinorg/xdcsubnets:latest             "bash /work/start.sh"    23 hours ago   Up 23 hours                                                                                                                               generated-subnet1-1
a50de921728d   xinfinorg/xdcsubnets:latest             "bash /work/start.sh"    23 hours ago   Up 23 hours                                                                                                                               generated-subnet3-1
5cd389701cfd   xinfinorg/xdcsubnets:latest             "bash /work/start-bo…"   23 hours ago   Up 23 hours                     8545/tcp, 8555/tcp, 30301/tcp, 30303/tcp, 0.0.0.0:20301->20301/tcp, 0.0.0.0:20301->20301/udp, 30301/udp   generated-bootnode-1

And finally check out the Subnet UI at :5000

We can see from the above image that the Relayer pushes the blocks from the Subnets to the parent chain at a specific interval which is configurable.
And an interesting thing is that there are two ways in which a Subnet can be setup.
-> Fully isolated network which will not use the parent chain to checkpoint (Private network)
-> Subnets on top of the parent XDC chain which uses checkpoint smart contract to confirm the transactions (Hybrid network)

A Relayer is used for this purpose to relay the transactions from the Subnets to the parent chain. The Relayer component can be turned on/off as required and it makes sure all the blocks are broadcasted to the parent chain once it is turned on.
This gives the flexibility for institutions to have the subnets completely isolated from the parent chain as and when required.
For removing the subnet and debugging and other instructions below link can be referred

Lets harness the real power of Subnets with the XDC network.!! Keep building.

#BuildOnXDC

[Closed]erpc.xinfin.network RPC not working

Satheesh Kumar — Wed, 01 Mar 2023 07:53:01 +0000

@blocksscanio Team - From today morning, we are facing an issue while using the RPC erpc.xinfin.network

`_return new Error(message);
^

Error: Invalid JSON RPC response: ""
at Object.InvalidResponse (C:\Users\data-feed\web-new\client\node_modules\xdc3-core-helpers\lib\errors.js:43:16)
at XMLHttpRequest.request.onreadystatechange (C:\Users\data-feed\web-new\client\node_modules\xdc3-providers-http\lib\index.js:95:32)
at XMLHttpRequestEventTarget.dispatchEvent (C:\Users\data-feed\web-new\client\node_modules\xhr2-cookies\dist\xml-http-request-event-target.js:34:22)
at XMLHttpRequest.setReadyState (C:\Users\data-feed\web-new\clien at XMLHttpRequest._onHttpRequestError (C:\Users\data-feed\web-new\client\node_modules\xhr2-cookies\dist\xml-http-request.js:349:14)
at ClientRequest. (C:\Users\data-feed\web-new\client\node_modules\xhr2-cookies\dist\xml-http-request.js:252:61)
at ClientRequest.emit (node:events:390:28)
at TLSSocket.socketErrorListener (node:_http_client:447:9)
at TLSSocket.emit (node:events:390:28)
at emitErrorNT (node:internal/streams/destroy:157:8)
at emitErrorCloseNT (node:internal/streams/destroy:122:3)
at processTicksAndRejections (node:internal/process/task_queues:83:21)
`
Any update made recently or should we use any other RPC for time being.

Please assist.

Note: The same RPC "erpc.xinfin.network" was working fine till yesterday.

PLUGIN - More data feeds coming up.!!

Satheesh Kumar — Tue, 29 Nov 2022 06:24:27 +0000

This post is in continuation to the previously published article
here
To all the developers out there on the XDC ecosystem, we have got some good news for you.
If you are building DApps on XDC which required the data feeds from external world like real time index pair rates it is now possible with the help of PLUGIN which is a decentralized oracle built on XDC.

Currently we have data feeds available on the below categories on Mainnet (Apothem testnet feeds will be available soon)

Stablecoins
Cryptocurrencies (XDC pairs)
Foreign exchange
Commodities
Cryptocurrencies (other)

You could get a feel of it here https://goplugin.co and a more detailed steps for integrating it onto your application at https://feeds.goplugin.co

Smart contract developers can do it in a much simpler way with our *customized npm package *https://www.npmjs.com/package/plugin-pricing-index-pair

We at Plugin are continuously working on making things easier for the developers and as a result of which any data feeds can be used in the smart contracts with just few steps https://docs.goplugin.co/plugin-data-feeds-platform/end-data-consumers

If you are looking for any specific feeds to be used in your application you can also reach out to us and we can get it added for you.
Keep a watch at this space https://feeds.goplugin.co/ as new feeds are being added up regularly.

We are continuously enhancing our platform so if you have any suggestions feel free to leave your comment/feedback here.!