Ashish Gushain (Backend-Associate Consultant L2- Development)

The blockchain ecosystem is rapidly evolving, with numerous networks offering unique features and capabilities. However, this diversity often leads to fragmentation, where assets and applications are siloed within their respective chains. Non-fungible tokens (NFTs), which have gained immense popularity, are no exception to this challenge. To unlock the full potential of NFT development, it is crucial to enable their seamless transfer and interaction across different blockchain networks. This is where cross-chain bridges come into play.

In this blog, we will explore the theoretical underpinnings of building cross-chain NFT bridges using Solana's Wormhole protocol. We'll delve into the architecture, key components, and the steps involved in creating a bridge that allows NFTs to move between Solana and other blockchain networks.

Understanding the Need for Cross-Chain NFT Bridges

NFTs are unique digital assets that represent ownership of a specific item or piece of content. They have found applications in art, gaming, virtual real estate, and more. However, the value and utility of NFTs are often limited to the blockchain on which they are minted. Cross-chain NFT bridges aim to overcome this limitation by enabling NFTs to be transferred and utilized across different blockchain networks.

Benefits of Cross-Chain NFT Bridges:

Interoperability: NFTs can be used across multiple platforms and ecosystems, increasing their utility and value.

Liquidity: By enabling NFTs to move between chains, bridges can tap into larger and more diverse markets.

Innovation: Developers can create cross-chain applications that leverage the unique features of multiple blockchains.

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

Solana Wormhole: A Primer

Solana's Wormhole is a generic message-passing protocol that facilitates communication between Solana and other blockchain networks. It acts as a bridge, allowing data and assets to be transferred across chains. Wormhole achieves this by using a set of validators (called "guardians") that observe and verify events on one chain and relay them to another.

Key Features of Wormhole:

Decentralized: Wormhole relies on a network of guardians to ensure the security and integrity of cross-chain transactions.

Extensible: The protocol is designed to support multiple blockchain networks, making it a versatile solution for cross-chain interoperability.

Efficient: Wormhole leverages Solana's high throughput and low latency to enable fast and cost-effective cross-chain transactions.

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

Architecture of a Cross-Chain NFT Bridge Using Wormhole

Building a cross-chain NFT bridge using Solana Wormhole involves several key components and steps. Let's break down the theoretical architecture:

NFT Representation on the Source Chain

• Minting NFTs: NFTs are minted on the source blockchain (e.g., Ethereum) using a standard like ERC-721 or ERC-1155.

• Locking NFTs: To initiate a cross-chain transfer, the NFT is locked in a smart contract on the source chain. This ensures that the NFT cannot be transferred or sold while it is being bridged.

   

Wormhole Message Passing

• Creating a Wormhole Message: Once the NFT is locked, a Wormhole message is created. This message contains essential information about the NFT, such as its metadata, ownership, and the target chain.
• Guardian Validation: The Wormhole guardians observe the locking event on the source chain and validate the Wormhole message. Once validated, the message is signed and relayed to the target chain.

NFT Representation on the Target Chain

• Receiving the Wormhole Message: On the target chain (e.g., Solana), the Wormhole message is received and verified by the local Wormhole smart contract.
• Minting a Wrapped NFT: A wrapped NFT is minted on the target chain, representing the original NFT from the source chain. This wrapped NFT adheres to the target chain's NFT standard (e.g., SPL Token on Solana).

• Unlocking the Original NFT: Once the wrapped NFT is minted, the original NFT remains locked on the source chain until it is redeemed.

   

Redeeming the Original NFT

• Burning the Wrapped NFT: To redeem the original NFT, the wrapped NFT on the target chain is burned, and a corresponding Wormhole message is created.

• Unlocking the Original NFT: The Wormhole guardians validate the burning event and relay the message back to the source chain. The original NFT is then unlocked and can be transferred or sold.

   

Security and Trust Considerations

• Guardian Network: The security of the bridge relies on the integrity of the Wormhole guardians. A decentralized and diverse set of guardians is essential to prevent collusion and ensure trust.
• Smart Contract Audits: Both the source and target chain smart contracts must be thoroughly audited to prevent vulnerabilities and ensure the safe handling of NFTs.
• Economic Incentives: Guardians and participants in the bridge should be incentivized to act honestly, with mechanisms in place to penalize malicious behavior.

Also, Discover | A Guide to Implementing NFT Royalties on ERC-721 & ERC-1155

Potential Challenges and Solutions

Cross-Chain Compatibility

• Challenge: Different blockchains have different standards and architectures, making it challenging to create a seamless bridge.
• Solution: Wormhole's extensible design allows it to support multiple chains, and the use of wrapped NFTs ensures compatibility with the target chain's standards.

Security Risks

• Challenge: Cross-chain bridges are attractive targets for hackers due to the value of assets being transferred.
• Solution: Implementing robust security measures, such as multi-signature schemes, regular audits, and a decentralized guardian network, can mitigate these risks.

Scalability

• Challenge: As the number of cross-chain transactions grows, the bridge must be able to handle increased load without compromising performance.
• Solution: Leveraging Solana's high throughput and low latency can help ensure that the bridge remains scalable and efficient.

You may also like | How to Get the Transaction History of an NFT

Conclusion

Cross-chain NFT bridges represent a significant step forward in the evolution of the blockchain ecosystem. By enabling NFTs to move seamlessly between different networks, these bridges unlock new possibilities for interoperability, liquidity, and innovation. Solana's Wormhole protocol provides a powerful foundation for building such bridges, offering a decentralized, extensible, and efficient solution.

While there are challenges to overcome, the theoretical architecture outlined in this blog provides a roadmap for building secure and scalable cross-chain NFT bridges. As the blockchain space continues to mature, we can expect to see more sophisticated and user-friendly bridges that bring the vision of a truly interconnected blockchain ecosystem to life. If you are planning to build and launch your NFT project, connect with our skilled blockchain developers to get started. 

The capacity to transfer assets across networks effortlessly is more important than ever in the ever-changing world of blockchain development. Envision a bridge that unites the Ethereum and Solana worlds, letting tokens move freely while upholding security and openness. In this project, we use the robust programming languages Solidity and Rust to set out on the task of creating a cross-chain bridge. Through utilizing Rust's efficiency for Solana's on-chain logic and Solidity's capabilities for Ethereum smart contracts, our goal is to provide a solid framework that makes token exchanges simple. Whether you're a crypto enthusiast excited to explore new possibilities or a developer trying to improve interoperability, this guide will take you through all the necessary steps to realize this ambitious aim. Now let's dive in.

Prerequisites 

Programming Languages:

Solidity, Javascript/Typescript, and Rust

IDE:

VS-Code and any preferred IDE

Libraries:

ETH: Hardhat, Ethers, Axios, Openzepplin

SOL: Solana Web3.js, Solana Spl-token

Also, Explore | How To Build "Buy Me a Coffee" DeFi dApp Using Solidity

How to Build a Cross-Chain Bridge Using Solidity and Rust 

It's preferred that you setup 3 projects, separately for:

I) Ethereum's ERC-20 Token Smart Contract:

You'll need to setup node.js, solidity and hardhat in your IDE/ system. So, we'll begin with setting up hardhat code, for example "click-here". Here's the code for the ERC-20 Token using Openzepplin's library.

code..................................................................................................
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Testtoken is ERC20, Ownable {
event BurnAndMoveToSolana(address indexed user, string solanaAddress, uint256 amount);
event MintFromSolana(address indexed user, uint256 amount);
address public relayer;
constructor() ERC20("EthereumToken", "ETHR") Ownable(msg.sender){
_mint(msg.sender, 1000000 * (10 ** decimals())); // change amount as per your understanding
}
modifier onlyRelayer() {
require(msg.sender == relayer, "Not authorized");
_;
}
function setRelayer(address _relayer) external onlyOwner {
relayer = _relayer;
}
function burnAndMoveToSolana(uint256 amount, string memory solanaAddress) external { // main transfering function
_burn(msg.sender, amount);
emit BurnAndMoveToSolana(msg.sender, solanaAddress, amount);
}
function mintFromSolana(address to, uint256 amount) external onlyRelayer {
_mint(to, amount);
emit MintFromSolana(to, amount);
}
event TokensBurned(address indexed from, address indexed solanaAddress, uint256 amount);
}

You may also like | Building a Decentralized Voting System with Solidity and Hardhat

2) Solana's SPL Token Program:

You'll need to setup node.js, Solana, and Rust in your IDE/ system. To begin with, we'll set-up a empty solana-sdk code. Here's the full code/implementation for the SPL Token using Solana-web3.js & Solana spl-token.

code.................................................................................................
const {
Connection,
Keypair,
PublicKey,
clusterApiUrl,
LAMPORTS_PER_SOL
} = require('@solana/web3.js');
const {
createMint,
getOrCreateAssociatedTokenAccount,
mintTo,
getAccount,
burn
} = require('@solana/spl-token');
async function mintAndBurnTokens(connection, fromWallet, tokenAccount, mint, amountToMint, amountToBurn, ethAddress) {
await mintTo(
connection,
fromWallet,
mint,
tokenAccount.address,
fromWallet.publicKey,
amountToMint
);
console.log(`Minted ${amountToMint / (10 ** 9)} tokens to your associated token account.`);
const tokenAccountBalance = await getAccount(connection, tokenAccount.address);
console.log(`Token account balance after minting: ${Number(tokenAccountBalance.amount) / (10 ** 9)} tokens`);
if (Number(tokenAccountBalance.amount) < amountToBurn) {
console.log(`Insufficient funds. Current balance: ${Number(tokenAccountBalance.amount) / (10 ** 9)} tokens.`);
return;
}
await burn(
connection,
fromWallet,
tokenAccount.address,
mint,
fromWallet.publicKey,
amountToBurn
);
console.log(`Burned ${amountToBurn / (10 ** 9)} tokens from ${fromWallet.publicKey} and moving to Ethereum wallet ${ethAddress}.`);
console.log(`Relaying burn event to Ethereum relayer for Ethereum wallet: ${ethAddress}, amount: ${amountToBurn / (10 ** 9)}.`);
}
(async () => {
const fromWallet = Keypair.fromSecretKey(new Uint8Array([your,secret,keypair]));
const ethAddress = "0xyourAddress"; //add your eth wallet address
const mintAmount = 100000 * 10 ** 9; // amount of SPL tokens to mint
const burnAmount = 1000 * 10 ** 9; // amount of SPL tokens to burn/transfer
const connection = new Connection(clusterApiUrl('devnet'), 'confirmed'); // put your preferred cluster
console.log('Creating SPL token...');
const mint = await createMint(
connection,
fromWallet,
fromWallet.publicKey,
null,
9
);
const fromTokenAccount = await getOrCreateAssociatedTokenAccount(
connection,
fromWallet,
mint,
fromWallet.publicKey
);
console.log('Minting tokens...');
await mintAndBurnTokens(connection, fromWallet, fromTokenAccount, mint, mintAmount, burnAmount, ethAddress);
console.log(`View token account on Solana Explorer: https://explorer.solana.com/address/${fromTokenAccount.address}?cluster=devnet`);
})();
////////////////////////////////////////////////////////////////////////

Also, Read | How To Create a Daily Game Reward System in Solidity

3) Relayer-Bridge Project:

In order to facilitate safe and transparent token transfers between two blockchains, a relayer-bridge project serves as an essential bridge. Using smart contracts and event listeners, the relayer in the Ethereum and Solana context watches on particular occurrences on one blockchain, like an Ethereum token burn. When the relayer notices one of these events, it sends the required information—such as the recipient's address and the quantity of tokens—to the other chain so that the corresponding action—like minting the tokens on Solana—can take place there. In order to preserve network balance, this bi-directional communication makes sure that tokens burned on one chain are minted on the other. In order to smoothly connect the two ecosystems, the relayer's job is to validate and relay these transactions without sacrificing security or speed.

Here's the Code for the Relayer-Bridge :

code..................................................................................................
const WebSocket = require("ws");
const { ethers } = require("ethers");
const fs = require("fs");
require('dotenv').config();
const wsUrl = "wss://api.devnet.solana.com"; //your desired network
const connection = new WebSocket(wsUrl);
const provider = new ethers.WebSocketProvider(process.env.ETH_WSS_URL);
const wallet = new ethers.Wallet(process.env.ETH_PRIVATE_KEY, provider);
const contractAddress = process.env.ETH_CONTRACT_ADDRESS;
const abi = JSON.parse(fs.readFileSync("./path_to_your/eth_contract_abi.json"));
const contract = new ethers.Contract(contractAddress, abi, wallet);
connection.on("open", () => {
console.log("Connected to Solana WebSocket");
const subscriptionMessage = JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "logsSubscribe",
params: [
{
mentions: [""], // Your SPL token address
},
{
commitment: "finalized",
},
],
});
connection.send(subscriptionMessage);
});
connection.on("message", async (data) => {
const response = JSON.parse(data);
if (response.method === "logsNotification") {
const logData = response.params.result;
// Check if the log indicates a burn
if (isBurnLog(logData)) {
const amountBurned = extractBurnAmount(logData);
console.log(`Burn detected: ${amountBurned} tokens`);
await mintTokens(amountBurned);
}
} else {
console.log("Received message:", response);
}
});
connection.on("close", () => {
console.log("Connection closed");
});
connection.on("error", (error) => {
console.error("WebSocket error:", error);
});
// Function to Check the log data structure to confirm it's a burn event
function isBurnLog(logData) {
return logData && logData.err === null && logData.logs && logData.logs.some(log => log.includes("burn"));
}
// Function to extract the amount burned from the log data
function extractBurnAmount(logData) {
const amountLog = logData.logs.find(log => log.includes("burn"));
if (amountLog) {
const amount = /* logic to parse your burn amount format */;
return parseFloat(amount); // Return the amount as a number
}
return 0;
}
// Function to mint tokens on Ethereum
async function mintTokens(amount) {
try {
const tx = await contract.mint(wallet.address, ethers.utils.parseUnits(amount.toString(), 18));
console.log(`Mint transaction sent: ${tx.hash}`);
await tx.wait();
console.log("Minting successful");
} catch (error) {
console.error("Minting failed:", error);
}
}
/////////////////////////////////////////////////////////////////////////

This part of the relayer works for the transfer of SPL tokens to the ERC-20 tokens on Ethereum. Similarly, we can perform the transfer of ERC-20 tokens to SPL Tokens on the Solana blockchain, burn them, and its functionality will trigger the SPL Token's mint function to complete the cross-chain transaction.

Also, Discover | How to Create a MultiSig Wallet in Solidity

Conclusion

In conclusion, creating a relayer-equipped cross-chain bridge enables users to transfer assets between Ethereum and Solana with ease, opening up a world of decentralised opportunities. Utilising Solidity and Rust's respective advantages, you can build a scalable, secure solution that connects two robust blockchain ecosystems. This project shapes the future of decentralised finance by paving the ground for true blockchain interoperability with the correct tools and knowledge. Connect with our skilled Solidity developers to bring your blockchain-related vision into reality. 

In this blog, we will guide you through the process of building a decentralized voting system using Solidity and Hardhat, which are heavily used in blockchain app development. You will learn how to create and deploy smart contracts that ensure secure, transparent, and tamper-proof voting. Ideal for developers looking to harness the power of blockchain technology in democratic processes, this tutorial covers everything from setting up your environment to writing and testing your contracts. With the help of this mechanism, voters will be able to safely cast their ballots on the Ethereum blockchain, guaranteeing that they cannot be manipulated.

Also, Check | How To Build "Buy Me a Coffee" DeFi dApp Using Solidity

Setting Up the Development Environment

1. Install Node.js.

2. Setup Hard Hat: Install Hardhat by running the following command in your terminal:
 

 npm install --save-dev hardhat

3. Create a Hardhat Project: Initialize a new Hardhat project by running:
 

  npx hardhat

You may also like | How To Create a Daily Game Reward System in Solidity

Writing the Smart Contract

1. Create the Contract: Inside the contracts directory, create a new file named Voting.sol. This Solidity file will hold our voting logic.
 

2. Implement the Contract:
 

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 contract Voting {
     struct Candidate {
         uint id;
         string name;
         uint voteCount;
     }
     mapping(uint => Candidate) public candidates;
     uint public candidatesCount;
     mapping(address => bool) public voters;
     constructor() {
         addCandidate('Alice');
         addCandidate('Bob');
     }
     function addCandidate(string memory _name) private {
         candidatesCount ++;
         candidates[candidatesCount] = Candidate(candidatesCount, _name, 0);
     }
     function vote(uint _candidateId) public {
         require(!voters[msg.sender], 'You have already voted.');
         require(_candidateId > 0 && _candidateId <= candidatesCount, 'Invalid candidate ID.');
         voters[msg.sender] = true;
         candidates[_candidateId].voteCount ++;
     }
 }

Also, Check | How to Create a MultiSig Wallet in Solidity

Deploying the Contract

1. Configure Deployment Scripts:

 - Inside the scripts directory, create a file named deploy.js.
 - Add the following code to deploy the contract:

   async function main() {
       const Voting = await ethers.getContractFactory('Voting');
       const voting = await Voting.deploy();
       await voting.deployed();
       console.log('Voting deployed to:', voting.address);
   }
   main().catch((error) => {
       console.error(error);
       process.exitCode = 1;
   });

Also, Read | Exploring Data Structures in Solidity for Advanced Smart Contracts

Testing the Contract 

1. Write Tests:
 

 - In the test directory, create a new file for the tests.
 - Use Hardhat's testing framework to write tests for your contract.

2. Run Tests:

 npx hardhat test

Also, Explore | Identifying Smart Contract Orchestration Patterns in Solidity

Conclusion

Congratulations! You now have a sophisticated decentralized voting system deployed on Ethereum using Solidity and Hardhat. This system lays the groundwork for numerous enhancements, such as advanced voting mechanisms, time-bound functionalities, and complex candidate structures. Imagine implementing features like weighted votes, multi-tiered elections, or secure voter verification – the possibilities are endless!

Ready to take your decentralized voting system to the next level? Contact our expert Solidity developers at Oodles to transform your vision into a robust, feature-rich solution tailored to your specific needs. Let's innovate together and redefine the future of voting!

The Graph is a tool that helps apps quickly access blockchain data. It uses a technology called GraphQL to pull data efficiently. Developers use it during blockchain app development to build faster and more reliable blockchain apps. It organizes blockchain data into something called subgraphs, making it easier to handle. This tool supports several blockchains, enhancing its usefulness for developers.

Advantages

• Speed: It speeds up how quickly apps can access blockchain data.
• Efficiency: It makes data retrieval more efficient using GraphQL.
• Simplicity: Organizes data into subgraphs, which are easier for developers to manage.
• Flexibility: Supports multiple blockchains, giving developers more options.
• Reliability: Enhances the stability and reliability of decentralized applications.

Also, Check | How to Setup and Run a Solana RPC Node

Steps to create and deploy subgraph

Install Graph CLI:

Command:

yarn global add @graphprotocol/graph-cli` or `npm install -g @graphprotocol/graph-cli`

This installs the necessary tools to create and manage subgraphs.

Initialize Your Subgraph:

Command: 

`graph init --from-example <GITHUB_USER>/<SUBGRAPH_NAME>`

This sets up a new subgraph directory with starter files based on a template.

Define subgraph.yaml:

 Example

  yaml
  specVersion: 0.0.2
  description: "Example subgraph"
  repository: "https://github.com/example/repo"
  dataSources:
    - kind: ethereum/contract
      name: ContractName
      source:
        address: "0x..."
        abi: ContractABI
      mapping:
        kind: ethereum/events
        apiVersion: 0.0.4
        language: wasm/assemblyscript
        entities:
          - EntityName
        abis:
          - name: ContractABI
            file: ./abis/ContractABI.json
        eventHandlers:
          - event: Transfer(address,address,uint256)
            handler: handleTransfer
        file: ./src/mapping.ts
 

 This file configures your subgraph, defining which blockchain events it listens to and how they map to the data entities.

You may also like | How To Build "Buy Me a Coffee" DeFi dApp Using Solidity

Create the GraphQL Schema:

 File: schema.graphql

Example content:

  ```graphql
  type Transfer @entity {
    id: ID!
    from: Bytes!
    to: Bytes!
    value: BigInt!
  }
  ```

This defines the data structures that your subgraph will store and make queryable.

Write AssemblyScript Mappings:

File: `src/mapping.ts`

Example function:

  ```typescript
  import { BigInt } from "@graphprotocol/graph-ts"
  import { Transfer } from "../generated/Contract/Contract"

  export function handleTransfer(event: Transfer): void {
    let transfer = new Transfer(event.params.from, event.params.to, event.params.value)
    transfer.save()
  }
  ```

This script processes incoming blockchain events and translates them into entities defined in the GraphQL schema.

Deploy Your Subgraph:

Command:

`graph deploy --product hosted-service <GITHUB_USER>/<SUBGRAPH_NAME>`

This uploads your subgraph to The Graph's hosted service, making it available for queries.

Also, Read | A Guide to Google Calendar API Integration into Your React Application

Conclusion

In conclusion, The Graph Protocol is a powerful tool for developers looking to build and deploy efficient, reliable, and scalable blockchain applications. By using GraphQL to quickly access and manage blockchain data, and organizing it into subgraphs, developers can significantly enhance the performance and stability of their decentralized applications. With support for multiple blockchains, The Graph provides flexibility and a robust solution for a variety of use cases. Following the steps outlined—installing the Graph CLI, initializing your subgraph, defining the subgraph.yaml, creating a GraphQL schema, writing AssemblyScript mappings, and deploying your subgraph—will enable you to leverage the full potential of The Graph Protocol, streamlining your development process and improving your application's overall functionality. Connect with our skilled blockchain developers for a quick consultation regarding your blockchain or crypto project. 

Within the quickly developing realm of blockchain gaming, tokenized loot boxes have become a fascinating fusion of virtual cash and gaming fun. With blockchain development services, you can create a unique gaming experience where players can purchase, earn, and open loot boxes containing a range of tokenized things by utilizing the Ethereum network and the ERC1155 multi-token standard. Using the "MyToken" contract as a foundational example, this blog post will walk you through the process of creating a tokenized loot-box game using the ERC1155 standard.

Core Concept of the Tokenized Loot-box Game

The essence of our game revolves around loot boxes—special tokens that can contain an array of other tokenized items, ranging from common to rare. Players can acquire loot boxes through gameplay, purchases, or trading with other players. Opening a loot box reveals its contents, adding an element of surprise and anticipation to the gaming experience.

The "MyToken" Contract: A Blueprint

Our game's backbone is the "MyToken" smart contract, which implements the ERC1155 standard along with additional functionalities for managing loot boxes. Let's dissect the main components and functionalities that make this contract suitable for our game:

1. ERC1155 Foundation: This allows for efficient handling of multiple token types, essential for distinguishing between different loot boxes and items within our game.
2. LootBox Functions: These provide the game developers (contract owners) with exclusive rights to mint new items and loot boxes.

Also, Check |  Game On! Mastering Web3 Game Development

Prerequisites:-

• Nodejs installed
• Solidity Familiarity
• ERC 1155 Familiarity

Implementing the Game Logic

Step 1: Setting up the Hardhat Environment

Create a new folder for the project. 

Use the following command:-  

npx hardhat 

And create a hardhat project.

We can now create our solidity contract in the contract folder by deleting the lock.sol file provided by hardhat. 

run
npm install @openzeppelin/contracts

You may also like | A Guide on How to Develop a Dutch Auction Smart Contract

Step 2: Smart Contract Development

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


// Importing ERC1155, Ownable, and ERC1155Burnable contracts from OpenZeppelin.
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";


// MyToken is a contract that combines ERC1155 for multi-token functionality,
// Ownable for ownership management, and ERC1155Burnable for token burnability.
contract MyToken is ERC1155, Ownable, ERC1155Burnable {
  // Private variable to keep track of the next item ID.
  uint256 private _nextItemId = 1;
  // Private variable to keep track of the next loot box ID.
  uint256 private _nextBoxId = 1;


  // Struct representing a loot box, which contains arrays of item IDs and quantities.
  struct LootBox {
      uint256[] itemIds;
      uint256[] itemQuantities;
  }


  // Mapping from loot box ID to LootBox struct, storing each loot box's details.
  mapping(uint256 => LootBox) private lootBoxes;


  // Event emitted when a loot box is opened.
  event LootBoxOpened(uint256 indexed boxId, address opener);


  // Constructor sets the base URI for token metadata and transfers ownership.
  constructor(string memory uri, address initialOwner) ERC1155(uri) Ownable(initialOwner) {
  }


  // Function to create a new loot box. Only the owner can call this function.
  function createLootBox(uint256[] memory itemIds, uint256[] memory itemQuantities) public onlyOwner {
      require(itemIds.length == itemQuantities.length, "Mismatch between item IDs and quantities");
      uint256 newBoxId = _nextBoxId++;
      lootBoxes[newBoxId] = LootBox(itemIds, itemQuantities);
  }


  // Function to open a loot box, burning one instance of the box and minting one of the items inside.
  function openLootBox(uint256 boxId) public {
      require(balanceOf(msg.sender, boxId) > 0, "You do not own this loot-box");
      _burn(msg.sender, boxId, 1); // Burn one loot box from the caller's balance.


      LootBox memory box = lootBoxes[boxId];
      // Generate a random index to determine which item to mint.
      uint256 randomIndex = uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender))) % box.itemIds.length;
      uint256 itemId = box.itemIds[randomIndex];
      uint256 quantity = box.itemQuantities[randomIndex];


      _mint(msg.sender, itemId, quantity, ""); // Mint the item to the caller.
      emit LootBoxOpened(boxId, msg.sender); // Emit an event for opening the loot box.
  }


  // Allows the owner to mint a new item directly to an address.
  function mintItem(address to, uint256 id, uint256 quantity, bytes memory data) public onlyOwner {
      _mint(to, id, quantity, data);
  }


  // Allows the owner to mint a new loot box and assigns it to an address.
  function mintLootBox(address to, uint256[] memory itemIds, uint256[] memory itemQuantities, uint256 quantity) public onlyOwner {
      createLootBox(itemIds, itemQuantities); // Create the loot box first.
      _mint(to, _nextBoxId - 1, quantity, ""); // Then mint it to the specified address.
  }


  // Function for the owner to set a new URI for all token types.
  function setURI(string memory newuri) public onlyOwner {
      _setURI(newuri);
  }


  // Function for the owner to mint tokens of a given ID and amount to a specified account.
  function mint(address account, uint256 id, uint256 amount, bytes memory data) public onlyOwner {
      _mint(account, id, amount, data);
  }


  // Function for the owner to mint multiple tokens of different IDs to a specified account.
  function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) public onlyOwner {
      _mintBatch(to, ids, amounts, data);
  }
}

• Create MyToken Contract:

• Create a new Solidity file named MyToken.sol.
• Copy the provided Solidity code into MyToken.sol.

• Understand Contract Components:

• ERC1155: This is a multi-token standard allowing the contract to manage multiple token types.
• Ownable: Provides basic authorization control functions, simplifying the implementation of "user permissions".
• ERC1155Burnable: Allows tokens to be burnt, removing them from the total supply.

• Implement Constructor: The constructor sets the base URI for token metadata and optionally transfers ownership to another address. Be prepared to provide the URI and the initial owner's address upon deployment.

• Implement Loot Box Logic:

• createLootBox: Allows the contract owner to create new loot boxes, each defined by arrays of item IDs and their quantities.
• openLootBox: Allows a loot box owner to open it, burning the loot box token and minting one of the items inside to the opener.

• Implement Minting Functions:

• mintItem: For the contract owner to mint a specific item directly to an address.
• mintLootBox: For the contract owner to mint a loot box (after creating it) directly to an address.
• mint: For minting tokens of a given ID to a specific account.
• mintBatch: Allows the owner to mint multiple types of tokens to a specified account in a single transaction.

• Utility Functions:

• setURI: To update the base URI for all token types.
• Private variables _nextItemId and _nextBoxId are used to keep track of the IDs for new items and loot boxes, ensuring uniqueness.

Explore More | Smart Contract Development Using Python

Step 3: Minting Loot Boxes

The game developer mints a variety of loot boxes, each characterized by a unique ID and containing a predefined set of items. This step involves calling the mintLootBox function to distribute the loot boxes to players.

Step 4: Acquiring and Opening Loot Boxes

Players acquire loot boxes through gameplay, purchases, or trades. To open a loot box, a player calls the openLootBox function, which burns the loot box token and randomly selects an item from its contents to mint to the player's address.

Also, Read | Creating a Staking Smart Contract on Solana using Anchor

Conclusion

Building a tokenized loot-box game with ERC1155 offers a unique opportunity to blend blockchain technology with engaging gameplay elements. The "MyToken" contract serves as a solid foundation, showcasing how to manage loot boxes and items within a unified framework. By embracing this technology, developers can create rich, interactive gaming experiences that leverage the power of blockchain for transparency, ownership, and traceability of digital assets. As the blockchain gaming industry continues to grow, innovative applications like tokenized loot boxes will undoubtedly play a significant role in shaping its future. Interested in developing a similar project for a wider audience, get in touch with smart contract developers to get started. 

Find out the step-by-step guide for gasless ERC20 token transfers in Ethereum development services to streamline transactions and foster accessibility in blockchain assets. 

Gasless ERC20 Token Transfers: Embracing Efficiency and Accessibility

In the evolving world of blockchain technology, the implementation of gasless ERC20 token transfers stands out as a significant innovation. This approach utilizes meta-transactions to enhance the efficiency and accessibility of token transfers on the Ethereum network.

What are ERC20 Tokens?

ERC20 tokens are digital assets built on the Ethereum blockchain. They adhere to a specific set of standards, making them interoperable with various applications and services within the Ethereum ecosystem.

Suggested Read | ERC-20 Token Standard | Development Essentials

The Role of Meta Transactions

Meta transactions represent a pivotal shift in how blockchain transactions are processed. By allowing a third party to pay the transaction fees ('gas'), users can transfer ERC20 tokens without incurring these costs directly. This method significantly lowers the barrier to entry and makes transactions more user-friendly.

Exploring the Solidity Code

IERC20Permit Interface

The IERC20Permit interface extends the standard ERC20 functionalities, introducing the permit function. This function is crucial for authorizing third-party transactions without the token holder incurring gas fees.

GaslessTokenTransfer Contract

The GaslessTokenTransfer contract leverages the permit method to enable gasless transactions. The send function within this contract allows the transfer of tokens from a sender to a receiver, with the transaction fee being handled externally.

ERC20Permit Contract

The ERC20Permit contract is a concrete implementation of the ERC20 standard, incorporating the EIP-2612 standard. This includes the permit function, allowing for more flexible and efficient token transfers.

Example Code:

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

interface IERC20Permit {
   function totalSupply() external view returns (uint256);

   function balanceOf(address account) external view returns (uint256);

   function transfer(address recipient, uint256 amount) external returns (bool);

   function allowance(address owner, address spender) external view returns (uint256);

   function approve(address spender, uint256 amount) external returns (bool);

   function transferFrom(
       address sender,
       address recipient,
       uint256 amount
   ) external returns (bool);

   function permit(
       address owner,
       address spender,
       uint256 value,
       uint256 deadline,
       uint8 v,
       bytes32 r,
       bytes32 s
   ) external;

   event Transfer(address indexed from, address indexed to, uint256 value);
   event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract GaslessTokenTransfer {
   function send(
       address token,
       address sender,
       address receiver,
       uint256 amount,
       uint256 fee,
       uint256 deadline,
       // Permit signature
       uint8 v,
       bytes32 r,
       bytes32 s
   ) external {
       // Permit
       IERC20Permit(token).permit(
           sender,
           address(this),
           amount + fee,
           deadline,
           v,
           r,
           s
       );
       // Send amount to receiver
       IERC20Permit(token).transferFrom(sender, receiver, amount);
       // Take fee - send fee to msg.sender
       IERC20Permit(token).transferFrom(sender, msg.sender, fee);
   }
}


/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
   /*//////////////////////////////////////////////////////////////
                                EVENTS
   //////////////////////////////////////////////////////////////*/

   event Transfer(address indexed from, address indexed to, uint256 amount);

   event Approval(address indexed owner, address indexed spender, uint256 amount);

   /*//////////////////////////////////////////////////////////////
                           METADATA STORAGE
   //////////////////////////////////////////////////////////////*/

   string public name;

   string public symbol;

   uint8 public immutable decimals;

   /*//////////////////////////////////////////////////////////////
                             ERC20 STORAGE
   //////////////////////////////////////////////////////////////*/

   uint256 public totalSupply;

   mapping(address => uint256) public balanceOf;

   mapping(address => mapping(address => uint256)) public allowance;

   /*//////////////////////////////////////////////////////////////
                           EIP-2612 STORAGE
   //////////////////////////////////////////////////////////////*/

   uint256 internal immutable INITIAL_CHAIN_ID;

   bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;

   mapping(address => uint256) public nonces;

   /*//////////////////////////////////////////////////////////////
                              CONSTRUCTOR
   //////////////////////////////////////////////////////////////*/

   constructor(string memory _name, string memory _symbol, uint8 _decimals) {
       name = _name;
       symbol = _symbol;
       decimals = _decimals;

       INITIAL_CHAIN_ID = block.chainid;
       INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
   }

   /*//////////////////////////////////////////////////////////////
                              ERC20 LOGIC
   //////////////////////////////////////////////////////////////*/

   function approve(address spender, uint256 amount) public virtual returns (bool) {
       allowance[msg.sender][spender] = amount;

       emit Approval(msg.sender, spender, amount);

       return true;
   }

   function transfer(address to, uint256 amount) public virtual returns (bool) {
       balanceOf[msg.sender] -= amount;

       // Cannot overflow because the sum of all user
       // balances can't exceed the max uint256 value.
       unchecked {
           balanceOf[to] += amount;
       }

       emit Transfer(msg.sender, to, amount);

       return true;
   }

   function transferFrom(
       address from,
       address to,
       uint256 amount
   ) public virtual returns (bool) {
       uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.

       if (allowed != type(uint256).max)
           allowance[from][msg.sender] = allowed - amount;

       balanceOf[from] -= amount;

       // Cannot overflow because the sum of all user
       // balances can't exceed the max uint256 value.
       unchecked {
           balanceOf[to] += amount;
       }

       emit Transfer(from, to, amount);

       return true;
   }

   /*//////////////////////////////////////////////////////////////
                            EIP-2612 LOGIC
   //////////////////////////////////////////////////////////////*/

   function permit(
       address owner,
       address spender,
       uint256 value,
       uint256 deadline,
       uint8 v,
       bytes32 r,
       bytes32 s
   ) public virtual {
       require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");

       // Unchecked because the only math done is incrementing
       // the owner's nonce which cannot realistically overflow.
       unchecked {
           address recoveredAddress = ecrecover(
               keccak256(
                   abi.encodePacked(
                       "\x19\x01",
                       DOMAIN_SEPARATOR(),
                       keccak256(
                           abi.encode(
                               keccak256(
                                   "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
                               ),
                               owner,
                               spender,
                               value,
                               nonces[owner]++,
                               deadline
                           )
                       )
                   )
               ),
               v,
               r,
               s
           );

           require(
               recoveredAddress != address(0) && recoveredAddress == owner,
               "INVALID_SIGNER"
           );

           allowance[recoveredAddress][spender] = value;
       }

       emit Approval(owner, spender, value);
   }

   function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
       return
           block.chainid == INITIAL_CHAIN_ID
               ? INITIAL_DOMAIN_SEPARATOR
               : computeDomainSeparator();
   }

   function computeDomainSeparator() internal view virtual returns (bytes32) {
       return
           keccak256(
               abi.encode(
                   keccak256(
                       "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
                   ),
                   keccak256(bytes(name)),
                   keccak256("1"),
                   block.chainid,
                   address(this)
               )
           );
   }

   /*//////////////////////////////////////////////////////////////
                       INTERNAL MINT/BURN LOGIC
   //////////////////////////////////////////////////////////////*/

   function _mint(address to, uint256 amount) internal virtual {
       totalSupply += amount;

       // Cannot overflow because the sum of all user
       // balances can't exceed the max uint256 value.
       unchecked {
           balanceOf[to] += amount;
       }

       emit Transfer(address(0), to, amount);
   }

   function _burn(address from, uint256 amount) internal virtual {
       balanceOf[from] -= amount;

       // Cannot underflow because a user's balance
       // will never be larger than the total supply.
       unchecked {
           totalSupply -= amount;
       }

       emit Transfer(from, address(0), amount);
   }
}

contract ERC20Permit is ERC20 {
   constructor(
       string memory _name,
       string memory _symbol,
       uint8 _decimals
   ) ERC20(_name, _symbol, _decimals) {}

   function mint(address to, uint256 amount) public {
       _mint(to, amount);
   }
}

Advantages of Gasless Token Transfers

• Cost Efficiency: Users can transfer tokens without the burden of gas fees.
• User Accessibility: Lowers the entry barrier for new users unfamiliar with the complexities of gas fees.
• Enhanced Transaction Flow: Streamlines the process, making it more appealing for regular use.

Check It Out | ERC-20 Token Standard | Things You Must Know

Conclusion

The integration of gasless ERC20 token transfers marks a significant stride in blockchain technology, offering a more accessible and efficient means of handling digital assets. As blockchain matures, innovations like these play a critical role in shaping its future, making it more inclusive and user-friendly. 

Interested in ERC20 token development? Connect with our Ethereum developers today to get started. 

In this article, we provide a step-by-step guide to staking smart contract development, deployment, and testing.

What are Smart Contracts?

A smart contract is a computer program that executes the rules of a contract automatically when certain conditions are satisfied. These contracts are often kept on a blockchain, ensuring their tamper-proof and transparent nature. Smart contracts can be used for a variety of applications, including financial transactions, supply chain management, and enforcing agreements between parties.

What is a Staking Smart Contract?

A staking smart contract is a type of blockchain-based contract that enables users to lock up their cryptocurrency holdings for a certain period of time, typically in exchange for rewards or benefits. Staking smart contracts facilitate the staking process by automating the process of locking up cryptocurrency holdings and distributing rewards to users who participate in staking.

Staking smart contracts are a popular tool for blockchain networks that use a proof-of-stake (PoS) consensus mechanism, as they allow users to participate in the consensus process and earn rewards without having to invest in expensive mining hardware. By staking their cryptocurrency holdings, users can earn rewards while helping to secure the network and maintain its integrity.

You may also like | The Increasing Inevitability of Hybrid Smart Contract Development

Steps to deploy and test Staking Smart Contract by using Remix

Step 1: Define the Token Contract

We need to create two ERC20 tokens. One for reward and one for staking.

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.9;

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

import "@openzeppelin/contracts/access/Ownable.sol";

contract Rtoken is ERC20, Ownable {

   constructor() ERC20("MyToken", "MTK") {}

   function mint(address to, uint256 amount) public onlyOwner {

       _mint(to, amount);

   }

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.9;

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

import "@openzeppelin/contracts/access/Ownable.sol";

contract Stoken is ERC20, Ownable {

   constructor() ERC20("MyToken", "MTK") {}

   function mint(address to, uint256 amount) public onlyOwner {

       _mint(to, amount);

   }

}

Step 2: Define the Staking Contract

Now that we have the token contracts in place, we can create the staking contract that will use the token for staking and reward distribution. Here's a basic implementation of the staking contract:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.9;

contract Staking {

   IERC20 public tokenToStake;

   IERC20 public rewardToken;

   mapping(address => uint256) public stakedAmount;

   mapping(address => uint256) public lastStakeTime;

   event Staked(address indexed user, uint256 amount);

   event Withdrawn(address indexed user, uint256 amount);

   event RewardPaid(address indexed user, uint256 reward);

   constructor(address _tokenToStake, address _rewardToken) {

       tokenToStake = IERC20(_tokenToStake);

       rewardToken = IERC20(_rewardToken);

   }

   function stake(uint256 amount) external {

       require(amount > 0, "Staking amount must be greater than 0");

       require(tokenToStake.balanceOf(msg.sender) >= amount, "Insufficient balance");

       require(tokenToStake.allowance(msg.sender, address(this)) >= amount, "Insufficient allowance");

       if (stakedAmount[msg.sender] == 0) {

           lastStakeTime[msg.sender] = block.timestamp;

       }

       tokenToStake.transferFrom(msg.sender, address(this), amount);

       stakedAmount[msg.sender] += amount;

       emit Staked(msg.sender, amount);

   }

   function withdraw(uint256 amount) external {

       require(amount > 0, "Withdrawal amount must be greater than 0");

       require(stakedAmount[msg.sender] >= amount, "Insufficient staked amount");

       uint256 reward = getReward(msg.sender);

       if (reward > 0) {

           rewardToken.mint(msg.sender, reward);

           emit RewardPaid(msg.sender, reward);

       }

       stakedAmount[msg.sender] -= amount;

       tokenToStake.transfer(msg.sender, amount);

       emit Withdrawn(msg.sender, amount);

   }

   function getReward(address user) public view returns (uint256) {

       uint256 timeElapsed = block.timestamp - lastStakeTime[user];

       uint256 stakedAmountUser = stakedAmount[user];

       if (timeElapsed == 0 || stakedAmountUser == 0) {

           return 0;

       }

       uint256 reward = stakedAmountUser * timeElapsed;

       return reward;

   }

   function getStakedBalance(address user) public view returns (uint256) {

       return stakedAmount[user];

   }

}

interface IERC20 {

   function totalSupply() external view returns (uint);

   function balanceOf(address account) external view returns (uint);

   function transfer(address recipient, uint amount) external returns (bool);

   function allowance(address owner, address spender) external view returns (uint);

   function approve(address spender, uint amount) external returns (bool);

   function transferFrom(

       address sender,

       address recipient,

       uint amount

   ) external returns (bool);

   function mint(address to, uint256 amount) external;

   event Transfer(address indexed from, address indexed to, uint value);

   event Approval(address indexed owner, address indexed spender, uint value);

}

Also, Check | Exploring the Potential of Solana Smart Contract Development

Step 3: Deploy the Rtoken, Stoken, and Staking Contract created above on Remix.

Step 4: Transfer the Ownership of the reward token to the staking contract

Step 5: Let's Test the Staking Smart Contract

Mint some tokens for yourself and approve the staking contract with the number of stokens you want to stake.

Go to the staking contract and use the stake function.

Now. click on withdraw after some time.

You will be able to check your reward token balance.

Suggested Read | Ethereum Smart Contract Development | Discovering the Potential

Conclusion

You may also connect with our skilled smart contract developers if you want to integrate staking smart contract solutions into your projects or have any questions in mind.