Building a Web3 Discord Clone DApp: Smart Contract Implementation — Part 1

2 weeks ago 19

Discord has transformed online community interactions, but its centralized nature raises concerns over censorship, ownership, and data privacy. By leveraging blockchain technology, we can build Dappcord — a decentralized Discord alternative that offers:

True ownership of channel access through NFTs
Censorship resistance with on-chain verification
Monetization through access fees
Community governance for decentralized decision-making

In this step-by-step tutorial, we’ll build the smart contract foundation for our Web3 Discord clone using Solidity, ERC721 NFTs, and Ethers.js.

Source : Dapp University

Before diving into code, let’s outline our key technical requirements and design decisions.

🔹 Channel Creation — Admin can create chat channels
🔹 Access Control — Users must verify access via NFTs
🔹 Monetization — Users pay ETH for premium channels
🔹 Ownership Verification — On-chain tracking of membership

1.) ERC721 NFTs for Access Control
Each channel membership is an NFT, allowing verifiable on-chain proof of access.

2.) Fee-Based Access Model
Users pay ETH to join private channels, enabling a revenue model.

3.) Minimal On-Chain Storage
To reduce gas fees, we store only essential data (channel info & user access).

4.) Off-Chain Messaging
Messages are not stored on-chain to keep transactions cost-efficient.

The foundation of our Dappcord application is the smart contract. Let’s dive into the Solidity code that powers our application:

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
contract Dappcord is ERC721 {

Our contract inherits from OpenZeppelin’s ERC721 implementation, which provides standard NFT functionality. We chose this standard because it allows each channel access to be represented as a unique, non-fungible token — perfect for proving membership rights.

// Tracks total number of channels created
uint256 public totalChannels;
// Contract owner address - can create channels and withdraw funds
address public owner;
// Total NFTs minted - used for token IDs
uint256 public totalSupply;

These variables act as the essential storage for our application:

totalChannels keeps track of how many channels exist
owner stores who can perform administrative actions
totalSupply counts the total NFT membership tokens created

Each variable has a clear, focused purpose with a short comment explaining what it does.

// Structure defining a channel with name, cost to join, and unique ID
struct Channel {
string name;
uint256 cost;
uint256 id;
}

The Channel struct packages all related channel data together:

A human-readable name
The cost to join (in wei)
A unique identifier

This organized approach makes the code more readable and helps manage related data efficiently.

// Maps channel IDs to their Channel data
mapping(uint256 => Channel) public channels;
// Tracks which users have joined which channels
mapping(uint256 => mapping(address => bool)) public hasJoined;

These mappings store the core data relationships:

channels links each channel ID to its full data
hasJoined tracks which users have access to which channels

The nested mapping provides an efficient way to check membership without looping through arrays.

// Ensures only the contract owner can call certain functions
modifier onlyOwner() {
require(msg.sender == owner);
_;
}

This modifier provides a simple security check — only the contract owner can call functions that use this modifier. This prevents unauthorized users from creating channels or withdrawing funds.

// Sets up the NFT collection and establishes the contract owner
constructor(string memory _name, string memory _symbol)
ERC721(_name, _symbol) {
owner = msg.sender;
}

The constructor does two things:

Initializes the ERC721 token with a name and symbol
Sets the deployer as the contract owner

This happens once when the contract is deployed to the blockchain.

// Creates a new channel with specified name and joining cost
function createChannel(string memory _name, uint _cost) public onlyOwner {
totalChannels++;
channels[totalChannels] = Channel(_name, _cost, totalChannels);
}

This function allows the owner to add new channels:

It increments the channel counter for a new ID
It creates and stores a new Channel with the provided name and cost

The onlyOwner modifier ensures only the admin can create channels.

// Allows users to join a channel by paying the required fee
function mint(uint256 _id) public payable {
// Check if channel exists and payment is sufficient
require(_id != 0, "Channel ID cannot be zero");
require(_id <= totalChannels, "Channel ID does not exist");
require(msg.value >= channels[_id].cost, "Not enough ether sent");
require(hasJoined[_id][msg.sender] == false, "Already joined");

// Mark user as joined and mint their access NFT
hasJoined[_id][msg.sender] = true;
totalSupply++;
_safeMint(msg.sender, totalSupply);
}

The mint function is where users interact to join channels:

It verifies the channel exists and the user isn’t already a member
It checks that enough ETH was sent to cover the channel cost
It records the user’s membership in the hasJoined mapping
It mints a new NFT to the user’s address as proof of access

Each validation has a clear error message, helping users understand why a transaction might fail.

// Returns all data for a specific channel
function getChannel(uint256 _id) public view returns (Channel memory) {
return channels[_id];
}

This helper function allows the frontend to easily fetch all information about a particular channel in one call.

// Allows owner to withdraw all fees collected from channel joins
function withdraw() public onlyOwner {
(bool success, ) = owner.call{value: address(this).balance}("");
require(success);
}

The withdraw function lets the owner collect all ETH paid by users to join channels:

It uses the low-level call method to transfer the full contract balance
It checks if the transfer succeeded with a require statement

This creates a simple monetization model for the platform.

🔹 Users own their channel access with an NFT
🔹 Allows on-chain proof of membership

🔹 ETH-based access fees for premium channels
🔹 Future scope: subscription models, token-based access

🔹 Minimal gas costs by storing only essential data
🔹 Restricts admin privileges with onlyOwner

By following this Web3 DApp tutorial, you will:

1.) Master Solidity & Smart Contracts
2.) Learn ERC721 NFT Integration
3.) Implement Web3 Monetization Strategies
4.) Apply Blockchain Security Best Practices
5.) Connect Solidity to a React Frontend (Ethers.js)
6.) Optimize Gas Usage for Efficient Transactions
7.)🛠 Deploy & Test a Fully Functional Web3 DApp

Now that we’ve built the smart contract, the next step is to:

1.) Develop the frontend using React & Ethers.js
2.)Integrate Web3 authentication
3.)Create the user interface for Dappcord

Stay tuned for Part 2,

Check out the full source code on GitHub:
🔗 GitHub Repository

Have questions about the smart contract? Drop a comment!
Planning to build your own Web3 app? Share your thoughts!

👀 Follow me for more Web3 tutorials!

Shoutout to Dapp University for inspiration in building Web3 applications!

Read Entire Article