Web3 Loyalty Programs: Drive Retention with Token Rewards & Real-Time Community Engagement

Traditional loyalty programs are broken. Points expire. Rewards feel arbitrary. Members have zero emotional connection to the brand. The average loyalty program loses 50% of enrolled members within the first year—not because the rewards are bad, but because there's nothing holding people together beyond a transactional exchange.

Web3 loyalty programs fix the incentive structure with token ownership. But here's what most guides won't tell you: tokens alone don't retain users. The projects with 80%+ retention rates aren't winning because of better tokenomics. They're winning because they combine on-chain rewards with real-time community experiences—voice AMAs where holders talk directly to founders, live exclusive events that make membership tangible, and chat channels that create daily social gravity.

This is Loyalty 2.0: token rewards + real-time community interaction. This guide shows you exactly how to build it—from smart contract reward distribution to voice rooms, live events, and member-only chat channels using Tencent RTC infrastructure.

Why Web3 Loyalty Programs Outperform Traditional Models

Before diving into implementation, let's establish why web3 loyalty programs represent a fundamental shift—not just a technology upgrade.

The Traditional Loyalty Problem

Traditional programs like airline miles or coffee stamps operate on a simple loop: spend money, earn points, redeem for discounts. The relationship is purely transactional. There's no community, no shared identity, and no reason to engage beyond the next purchase.

The Web3 Loyalty Advantage

A web3 loyalty program transforms customers into stakeholders. When members hold tokens that represent real value—governance rights, exclusive access, tradeable assets—they have skin in the game. But the projects that truly excel add a layer most miss: synchronous community experiences that make token ownership feel like belonging to something alive.

Consider the difference:

• Program A: Earn tokens for purchases. Redeem for discounts. Passive, transactional, forgettable.
• Program B: Earn tokens for purchases AND community participation. Use tokens to access weekly voice AMAs with the founding team, vote on product direction in live town halls, and chat in member-only channels with other power users. Active, social, sticky.

Program B retains 3-4x more members because it creates social bonds that transcend individual transactions. This is the web3 loyalty model we're building.

The Loyalty 2.0 Architecture: Tokens + Real-Time Community

A complete web3 loyalty program needs four interconnected layers:

┌──────────────────────────────────────────────────────────────┐
│                    Member-Facing Experience                    │
│              (dApp / Mobile App / Web Portal)                  │
├──────────────────────────────────────────────────────────────┤
│                                                               │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
│  │  Voice AMA  │  │ Live Events │  │  Chat Channels      │  │
│  │   Rooms     │  │  (Streams)  │  │  (Member-Only)      │  │
│  │   (TRTC)    │  │   (TRTC)    │  │  (TRTC Chat)        │  │
│  └──────┬──────┘  └──────┬──────┘  └──────────┬──────────┘  │
│         │                 │                     │             │
├─────────┴─────────────────┴─────────────────────┴────────────┤
│             Token-Gating & Reward Distribution Layer           │
│          (Smart Contracts + Wallet Auth + Tier Logic)          │
├──────────────────────────────────────────────────────────────┤
│                  On-Chain Loyalty Engine                       │
│   (ERC-20 reward token + Tier NFTs + Activity tracking)       │
└──────────────────────────────────────────────────────────────┘

Layer 1: On-Chain Loyalty Engine

Smart contracts that:

• Mint reward tokens based on qualifying actions
• Track membership tiers (Bronze, Silver, Gold, Diamond)
• Record participation proofs (attendance POAPs, engagement scores)
• Distribute bonuses for streaks and milestones

Layer 2: Token-Gating & Tier Logic

Middleware that:

• Verifies wallet holdings before granting access
• Maps token balances to tier-specific permissions
• Triggers reward distribution when members complete community actions
• Syncs on-chain state with real-time access controls

Layer 3: Real-Time Community Features

The engagement layer powered by TRTC:

• Voice AMA Rooms: Token-gated voice sessions where leadership answers member questions live
• Live Exclusive Events: Streamed events (product reveals, workshops, fireside chats) only for qualifying tiers
• Chat Channels: Persistent member-only messaging with tier-based channels

Layer 4: Member Experience

The unified interface where members:

• See their token balance, tier status, and available rewards
• Join upcoming voice AMAs and live events
• Chat with other members in real-time
• Track their activity and streak progress

Smart Contract: Loyalty Token & Reward Distribution

The foundation of any web3 loyalty program is the on-chain reward mechanism. Here's a production-ready smart contract that handles token rewards, tier management, and activity-based distribution.

Loyalty Reward Contract

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract LoyaltyRewardToken is ERC20, AccessControl, ReentrancyGuard {
    bytes32 public constant REWARD_MANAGER = keccak256("REWARD_MANAGER");
    bytes32 public constant TIER_MANAGER = keccak256("TIER_MANAGER");

    enum Tier { Bronze, Silver, Gold, Diamond }

    struct MemberInfo {
        Tier tier;
        uint256 totalEarned;
        uint256 joinedAt;
        uint256 lastActivityAt;
        uint256 streakDays;
        uint256 communityScore;
    }

    // Tier thresholds (in token units)
    uint256 public silverThreshold = 500 * 10**18;
    uint256 public goldThreshold = 2000 * 10**18;
    uint256 public diamondThreshold = 10000 * 10**18;

    // Reward amounts per action
    uint256 public voiceAMAReward = 50 * 10**18;
    uint256 public liveEventReward = 30 * 10**18;
    uint256 public chatActivityReward = 10 * 10**18;
    uint256 public dailyStreakBonus = 5 * 10**18;
    uint256 public referralReward = 100 * 10**18;

    // Tier multipliers (basis points: 10000 = 1x)
    mapping(Tier => uint256) public tierMultipliers;

    // Member data
    mapping(address => MemberInfo) public members;
    mapping(address => mapping(uint256 => bool)) public dailyClaimed;

    // Anti-abuse: cooldown per action type
    mapping(address => mapping(bytes32 => uint256)) public lastActionTime;
    uint256 public actionCooldown = 1 hours;

    // Events
    event RewardEarned(address indexed member, uint256 amount, string action, Tier tier);
    event TierUpgraded(address indexed member, Tier oldTier, Tier newTier);
    event StreakUpdated(address indexed member, uint256 newStreak);
    event MemberJoined(address indexed member, uint256 timestamp);

    constructor() ERC20("LoyaltyToken", "LOYAL") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(REWARD_MANAGER, msg.sender);
        _grantRole(TIER_MANAGER, msg.sender);

        // Set tier multipliers
        tierMultipliers[Tier.Bronze] = 10000;   // 1x
        tierMultipliers[Tier.Silver] = 12500;   // 1.25x
        tierMultipliers[Tier.Gold] = 15000;     // 1.5x
        tierMultipliers[Tier.Diamond] = 20000;  // 2x
    }

    function joinProgram() external {
        require(members[msg.sender].joinedAt == 0, "Already a member");
        
        members[msg.sender] = MemberInfo({
            tier: Tier.Bronze,
            totalEarned: 0,
            joinedAt: block.timestamp,
            lastActivityAt: block.timestamp,
            streakDays: 1,
            communityScore: 0
        });

        // Welcome bonus
        _mintReward(msg.sender, 100 * 10**18, "welcome_bonus");
        emit MemberJoined(msg.sender, block.timestamp);
    }

    function rewardVoiceAMA(address member) external onlyRole(REWARD_MANAGER) nonReentrant {
        _enforceCooldown(member, "voice_ama");
        uint256 reward = _calculateReward(member, voiceAMAReward);
        _mintReward(member, reward, "voice_ama");
        _updateCommunityScore(member, 5);
    }

    function rewardLiveEvent(address member) external onlyRole(REWARD_MANAGER) nonReentrant {
        _enforceCooldown(member, "live_event");
        uint256 reward = _calculateReward(member, liveEventReward);
        _mintReward(member, reward, "live_event");
        _updateCommunityScore(member, 3);
    }

    function rewardChatActivity(address member) external onlyRole(REWARD_MANAGER) nonReentrant {
        _enforceCooldown(member, "chat_activity");
        uint256 reward = _calculateReward(member, chatActivityReward);
        _mintReward(member, reward, "chat_activity");
        _updateCommunityScore(member, 1);
    }

    function rewardReferral(address referrer, address newMember) external onlyRole(REWARD_MANAGER) nonReentrant {
        require(members[newMember].joinedAt > 0, "New member must join first");
        uint256 reward = _calculateReward(referrer, referralReward);
        _mintReward(referrer, reward, "referral");
        _updateCommunityScore(referrer, 10);
    }

    function claimDailyStreak() external nonReentrant {
        require(members[msg.sender].joinedAt > 0, "Not a member");
        uint256 today = block.timestamp / 1 days;
        require(!dailyClaimed[msg.sender][today], "Already claimed today");

        dailyClaimed[msg.sender][today] = true;

        // Check if streak continues
        uint256 yesterday = today - 1;
        if (dailyClaimed[msg.sender][yesterday]) {
            members[msg.sender].streakDays += 1;
        } else {
            members[msg.sender].streakDays = 1;
        }

        uint256 streakMultiplier = members[msg.sender].streakDays > 30 
            ? 30 
            : members[msg.sender].streakDays;
        
        uint256 reward = dailyStreakBonus * streakMultiplier / 10;
        _mintReward(msg.sender, reward, "daily_streak");
        
        emit StreakUpdated(msg.sender, members[msg.sender].streakDays);
    }

    function getMemberTier(address member) external view returns (Tier) {
        return members[member].tier;
    }

    function getMemberInfo(address member) external view returns (MemberInfo memory) {
        return members[member];
    }

    // Internal functions
    function _calculateReward(address member, uint256 baseReward) internal view returns (uint256) {
        Tier tier = members[member].tier;
        return (baseReward * tierMultipliers[tier]) / 10000;
    }

    function _mintReward(address member, uint256 amount, string memory action) internal {
        _mint(member, amount);
        members[member].totalEarned += amount;
        members[member].lastActivityAt = block.timestamp;

        emit RewardEarned(member, amount, action, members[member].tier);
        _checkTierUpgrade(member);
    }

    function _checkTierUpgrade(address member) internal {
        Tier currentTier = members[member].tier;
        Tier newTier = currentTier;
        uint256 balance = balanceOf(member);

        if (balance >= diamondThreshold) {
            newTier = Tier.Diamond;
        } else if (balance >= goldThreshold) {
            newTier = Tier.Gold;
        } else if (balance >= silverThreshold) {
            newTier = Tier.Silver;
        }

        if (newTier != currentTier) {
            members[member].tier = newTier;
            emit TierUpgraded(member, currentTier, newTier);
        }
    }

    function _updateCommunityScore(address member, uint256 points) internal {
        members[member].communityScore += points;
    }

    function _enforceCooldown(address member, string memory action) internal {
        bytes32 actionKey = keccak256(abi.encodePacked(action));
        require(
            block.timestamp - lastActionTime[member][actionKey] >= actionCooldown,
            "Action on cooldown"
        );
        lastActionTime[member][actionKey] = block.timestamp;
    }

    // Admin functions
    function setRewardAmounts(
        uint256 _voiceAMA,
        uint256 _liveEvent,
        uint256 _chatActivity,
        uint256 _dailyStreak,
        uint256 _referral
    ) external onlyRole(TIER_MANAGER) {
        voiceAMAReward = _voiceAMA;
        liveEventReward = _liveEvent;
        chatActivityReward = _chatActivity;
        dailyStreakBonus = _dailyStreak;
        referralReward = _referral;
    }

    function setTierThresholds(
        uint256 _silver,
        uint256 _gold,
        uint256 _diamond
    ) external onlyRole(TIER_MANAGER) {
        silverThreshold = _silver;
        goldThreshold = _gold;
        diamondThreshold = _diamond;
    }
}

This contract provides:

• Action-based rewards: Members earn tokens for voice AMA attendance, live event participation, chat activity, and referrals
• Tier system: Automatic upgrades based on token holdings (Bronze → Silver → Gold → Diamond)
• Tier multipliers: Higher tiers earn more per action (Diamond gets 2x rewards)
• Streak bonuses: Daily activity streaks compound rewards over time
• Anti-abuse: Cooldown periods prevent reward farming
• Community score: Tracks non-financial engagement for reputation

Building the Real-Time Community Layer

Now for the engagement engine that makes your web3 loyalty program sticky. We'll implement three core features using TRTC: voice AMA rooms, exclusive live events, and member chat channels.

Prerequisites

mkdir web3-loyalty-community
cd web3-loyalty-community
npm init -y
npm install trtc-sdk-v5 tim-js-sdk ethers express jsonwebtoken dotenv

Shared: Token-Gate Verification

All community features require wallet verification before access. This middleware checks on-chain tier status:

// lib/loyalty-gate.js
import { ethers } from 'ethers';

const LOYALTY_ABI = [
  'function getMemberTier(address member) view returns (uint8)',
  'function getMemberInfo(address member) view returns (tuple(uint8 tier, uint256 totalEarned, uint256 joinedAt, uint256 lastActivityAt, uint256 streakDays, uint256 communityScore))',
  'function balanceOf(address account) view returns (uint256)'
];

export class LoyaltyGate {
  constructor(contractAddress, rpcUrl) {
    this.provider = new ethers.JsonRpcProvider(rpcUrl);
    this.contract = new ethers.Contract(contractAddress, LOYALTY_ABI, this.provider);
  }

  async getMemberTier(walletAddress) {
    const tier = await this.contract.getMemberTier(walletAddress);
    return ['Bronze', 'Silver', 'Gold', 'Diamond'][tier];
  }

  async verifyMinTier(walletAddress, requiredTier) {
    const tierOrder = { Bronze: 0, Silver: 1, Gold: 2, Diamond: 3 };
    const memberTier = await this.contract.getMemberTier(walletAddress);
    return memberTier >= tierOrder[requiredTier];
  }

  async getMemberProfile(walletAddress) {
    const [info, balance] = await Promise.all([
      this.contract.getMemberInfo(walletAddress),
      this.contract.balanceOf(walletAddress)
    ]);

    return {
      tier: ['Bronze', 'Silver', 'Gold', 'Diamond'][info.tier],
      totalEarned: ethers.formatEther(info.totalEarned),
      balance: ethers.formatEther(balance),
      joinedAt: new Date(Number(info.joinedAt) * 1000),
      streakDays: Number(info.streakDays),
      communityScore: Number(info.communityScore)
    };
  }
}

export function createGateMiddleware(contractAddress, rpcUrl) {
  const gate = new LoyaltyGate(contractAddress, rpcUrl);

  return (requiredTier) => async (req, res, next) => {
    const { walletAddress } = req.user;
    
    try {
      const hasAccess = await gate.verifyMinTier(walletAddress, requiredTier);
      if (!hasAccess) {
        return res.status(403).json({
          error: 'Insufficient tier',
          required: requiredTier,
          current: await gate.getMemberTier(walletAddress),
          message: `This feature requires ${requiredTier} tier or above`
        });
      }
      req.memberProfile = await gate.getMemberProfile(walletAddress);
      next();
    } catch (error) {
      res.status(500).json({ error: 'Failed to verify membership tier' });
    }
  };
}

Tutorial 1: Voice Room AMA for Loyalty Members

Voice AMAs are the highest-engagement feature in any web3 loyalty program. Members earn tokens for attending, higher tiers get priority speaking slots, and the direct founder-to-member interaction creates emotional bonds that no amount of token rewards can replicate.

Voice AMA Implementation

// features/voice-ama.js
import TRTC from 'trtc-sdk-v5';

class LoyaltyVoiceAMA {
  constructor(config) {
    this.trtc = TRTC.create();
    this.roomId = config.roomId;
    this.walletAddress = config.walletAddress;
    this.memberTier = config.memberTier;
    this.role = config.role; // 'host', 'speaker', 'listener'
    this.speakerQueue = [];
    this.listeners = new Map();
    this.rewardTracker = new Map();
  }

  async joinAMA(userSig) {
    // Determine TRTC role based on membership tier and assigned role
    const trtcRole = this.role === 'listener' ? 'audience' : 'anchor';

    await this.trtc.enterRoom({
      roomId: this.roomId,
      sdkAppId: parseInt(process.env.TRTC_APP_ID),
      userId: this.walletAddress,
      userSig: userSig,
      scene: 'live',
      role: trtcRole
    });

    if (this.role !== 'listener') {
      // Publish audio for hosts and speakers
      await this.trtc.startLocalAudio({
        option: { profile: 'speech' }
      });
    }

    this.setupEventHandlers();
    this.startRewardTracking();
    console.log(`Joined AMA as ${this.role} | Tier: ${this.memberTier}`);
  }

  setupEventHandlers() {
    // Track remote users (speakers) joining
    this.trtc.on(TRTC.EVENT.REMOTE_AUDIO_AVAILABLE, (event) => {
      console.log(`Speaker active: ${event.userId}`);
    });

    this.trtc.on(TRTC.EVENT.REMOTE_USER_ENTER, (event) => {
      this.listeners.set(event.userId, {
        joinedAt: Date.now(),
        tier: null
      });
    });

    this.trtc.on(TRTC.EVENT.REMOTE_USER_EXIT, (event) => {
      this.listeners.delete(event.userId);
    });
  }

  startRewardTracking() {
    // Track attendance duration for reward eligibility
    this.rewardTracker.set(this.walletAddress, {
      joinedAt: Date.now(),
      minimumDuration: 15 * 60 * 1000, // 15 min minimum for rewards
      rewarded: false
    });

    // Check every minute if reward threshold met
    this.rewardInterval = setInterval(() => {
      const tracker = this.rewardTracker.get(this.walletAddress);
      if (!tracker || tracker.rewarded) return;

      const elapsed = Date.now() - tracker.joinedAt;
      if (elapsed >= tracker.minimumDuration) {
        this.triggerAttendanceReward();
        tracker.rewarded = true;
      }
    }, 60000);
  }

  async triggerAttendanceReward() {
    await fetch('/api/rewards/voice-ama', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        walletAddress: this.walletAddress,
        roomId: this.roomId,
        duration: Date.now() - this.rewardTracker.get(this.walletAddress).joinedAt
      })
    });
    console.log('Attendance reward triggered');
  }

  // Priority speaker queue based on loyalty tier
  requestToSpeak() {
    const priority = { Diamond: 0, Gold: 1, Silver: 2, Bronze: 3 };
    
    this.speakerQueue.push({
      walletAddress: this.walletAddress,
      tier: this.memberTier,
      priority: priority[this.memberTier],
      requestedAt: Date.now()
    });

    // Sort by tier priority, then by request time
    this.speakerQueue.sort((a, b) => {
      if (a.priority !== b.priority) return a.priority - b.priority;
      return a.requestedAt - b.requestedAt;
    });

    return this.speakerQueue.findIndex(
      s => s.walletAddress === this.walletAddress
    ) + 1;
  }

  // Host promotes listener to speaker
  async promoteToSpeaker(targetWallet) {
    if (this.role !== 'host') throw new Error('Only host can promote');
    
    await this.trtc.switchRole('anchor');
    await this.trtc.startLocalAudio({ option: { profile: 'speech' } });
    
    this.speakerQueue = this.speakerQueue.filter(
      s => s.walletAddress !== targetWallet
    );
  }

  async leaveAMA() {
    clearInterval(this.rewardInterval);
    
    if (this.role !== 'listener') {
      await this.trtc.stopLocalAudio();
    }
    await this.trtc.exitRoom();
    console.log('Left AMA room');
  }
}

// Usage
const ama = new LoyaltyVoiceAMA({
  roomId: 'loyalty-ama-2024-week-48',
  walletAddress: '0x1234...abcd',
  memberTier: 'Gold',
  role: 'listener'
});

await ama.joinAMA(userSig);
const queuePosition = ama.requestToSpeak();
console.log(`Queue position: ${queuePosition}`);

Voice AMA Backend API

// api/voice-ama-routes.js
import express from 'express';
import { createGateMiddleware } from '../lib/loyalty-gate.js';
import { generateUserSig } from '../lib/trtc-auth.js';

const router = express.Router();
const tierGate = createGateMiddleware(
  process.env.LOYALTY_CONTRACT,
  process.env.RPC_URL
);

// Schedule a new AMA session
router.post('/ama/schedule', tierGate('Gold'), async (req, res) => {
  const { title, scheduledAt, minTier, maxSpeakers } = req.body;
  
  const amaSession = await db.amaSession.create({
    roomId: `ama-${Date.now()}`,
    title,
    scheduledAt: new Date(scheduledAt),
    minTier: minTier || 'Bronze',
    maxSpeakers: maxSpeakers || 10,
    hostWallet: req.user.walletAddress,
    status: 'scheduled'
  });

  res.json({ session: amaSession });
});

// Join an AMA room (generates TRTC credentials)
router.post('/ama/:roomId/join', tierGate('Bronze'), async (req, res) => {
  const { roomId } = req.params;
  const { walletAddress } = req.user;
  const { memberProfile } = req;

  const session = await db.amaSession.findOne({ roomId });
  if (!session) return res.status(404).json({ error: 'AMA not found' });

  // Check minimum tier requirement
  const tierOrder = { Bronze: 0, Silver: 1, Gold: 2, Diamond: 3 };
  if (tierOrder[memberProfile.tier] < tierOrder[session.minTier]) {
    return res.status(403).json({
      error: `This AMA requires ${session.minTier} tier`,
      upgradePath: `/loyalty/upgrade-info`
    });
  }

  const userSig = generateUserSig({
    sdkAppId: parseInt(process.env.TRTC_APP_ID),
    secretKey: process.env.TRTC_SECRET_KEY,
    userId: walletAddress,
    expire: 7200
  });

  const role = session.hostWallet === walletAddress ? 'host' : 'listener';

  res.json({
    roomId,
    userSig,
    role,
    memberTier: memberProfile.tier,
    sdkAppId: parseInt(process.env.TRTC_APP_ID)
  });
});

// Reward endpoint called after attendance threshold
router.post('/rewards/voice-ama', async (req, res) => {
  const { walletAddress, roomId, duration } = req.body;
  
  if (duration < 15 * 60 * 1000) {
    return res.status(400).json({ error: 'Minimum 15 minutes for reward' });
  }

  const tx = await loyaltyContract.rewardVoiceAMA(walletAddress);
  await tx.wait();

  res.json({ 
    rewarded: true, 
    txHash: tx.hash,
    message: 'Voice AMA attendance reward distributed'
  });
});

export default router;

Why Voice AMAs Transform Web3 Loyalty

Voice AMAs in a web3 loyalty program create a feedback loop that no static reward system can match:

1. Members earn tokens for attending → Financial incentive to show up
2. Higher tiers get priority speaking → Motivation to accumulate and hold tokens
3. Direct access to founders → Emotional investment in the project
4. Peer interaction → Social bonds that increase switching costs
5. Regular schedule → Habit formation that drives daily engagement

Tutorial 2: Member-Only Chat Channels

Persistent chat channels are the daily heartbeat of your web3 loyalty program. While voice AMAs happen weekly, chat channels provide continuous engagement. Tier-gated channels create aspiration—members in Bronze can see that Gold and Diamond channels exist, motivating them to participate more.

Chat Channel Architecture

// features/loyalty-chat.js
import TIM from 'tim-js-sdk';

class LoyaltyChatSystem {
  constructor(config) {
    this.tim = TIM.create({
      SDKAppID: config.sdkAppId
    });
    this.walletAddress = config.walletAddress;
    this.memberTier = config.memberTier;
    this.channels = new Map();
  }

  async initialize(userSig) {
    await this.tim.login({
      userID: this.walletAddress,
      userSig: userSig
    });

    this.setupMessageHandlers();
    await this.joinTierChannels();
    console.log(`Chat initialized for ${this.memberTier} member`);
  }

  async joinTierChannels() {
    // Define channel structure per tier
    const channelMap = {
      Bronze: ['general', 'introductions', 'support'],
      Silver: ['general', 'introductions', 'support', 'alpha-signals', 'governance-discussion'],
      Gold: ['general', 'introductions', 'support', 'alpha-signals', 'governance-discussion', 'founders-room', 'early-access'],
      Diamond: ['general', 'introductions', 'support', 'alpha-signals', 'governance-discussion', 'founders-room', 'early-access', 'diamond-lounge', 'strategy-council']
    };

    const accessibleChannels = channelMap[this.memberTier] || channelMap.Bronze;

    for (const channel of accessibleChannels) {
      const groupId = `loyalty-${channel}`;
      try {
        await this.tim.joinGroup({
          groupID: groupId,
          type: TIM.TYPES.GRP_AVCHATROOM
        });
        this.channels.set(channel, groupId);
      } catch (error) {
        if (error.code === 10013) {
          this.channels.set(channel, groupId);
        }
      }
    }

    return Array.from(this.channels.keys());
  }

  setupMessageHandlers() {
    this.tim.on(TIM.EVENT.MESSAGE_RECEIVED, (event) => {
      const messages = event.data;
      messages.forEach(msg => {
        this.handleIncomingMessage(msg);
      });
    });
  }

  handleIncomingMessage(message) {
    const { from, payload, conversationID } = message;
    
    this.trackEngagement(from, conversationID);

    return {
      sender: from,
      content: payload.text,
      channel: conversationID,
      timestamp: message.time
    };
  }

  async sendMessage(channelName, text) {
    const groupId = this.channels.get(channelName);
    if (!groupId) throw new Error(`No access to channel: ${channelName}`);

    const message = this.tim.createTextMessage({
      to: groupId,
      conversationType: TIM.TYPES.CONV_GROUP,
      payload: { text }
    });

    await this.tim.sendMessage(message);
    this.trackSendActivity();
  }

  async sendTierAnnouncement(channelName, announcement) {
    const groupId = this.channels.get(channelName);
    
    const message = this.tim.createCustomMessage({
      to: groupId,
      conversationType: TIM.TYPES.CONV_GROUP,
      payload: {
        data: JSON.stringify({
          type: 'tier_announcement',
          content: announcement.content,
          ctaUrl: announcement.ctaUrl,
          minTier: announcement.minTier
        }),
        description: announcement.content,
        extension: 'loyalty_announcement'
      }
    });

    await this.tim.sendMessage(message);
  }

  trackEngagement(sender, channel) {
    if (!this.engagementLog) this.engagementLog = [];
    this.engagementLog.push({
      sender,
      channel,
      timestamp: Date.now()
    });
  }

  trackSendActivity() {
    if (!this.dailySendCount) this.dailySendCount = 0;
    this.dailySendCount++;

    // Trigger reward after meaningful participation (5+ messages/day)
    if (this.dailySendCount === 5) {
      this.triggerChatReward();
    }
  }

  async triggerChatReward() {
    await fetch('/api/rewards/chat-activity', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        walletAddress: this.walletAddress,
        messageCount: this.dailySendCount,
        date: new Date().toISOString().split('T')[0]
      })
    });
  }

  async getChannelHistory(channelName, count = 50) {
    const groupId = this.channels.get(channelName);
    const result = await this.tim.getMessageList({
      conversationID: `GROUP${groupId}`,
      count
    });
    return result.data.messageList;
  }

  async leaveAllChannels() {
    for (const [name, groupId] of this.channels) {
      await this.tim.quitGroup(groupId);
    }
    await this.tim.logout();
  }
}

// Usage
const chat = new LoyaltyChatSystem({
  sdkAppId: parseInt(process.env.TRTC_APP_ID),
  walletAddress: '0x1234...abcd',
  memberTier: 'Gold'
});

await chat.initialize(userSig);
await chat.sendMessage('founders-room', 'Excited about the new roadmap update!');

Chat Channel Reward Logic

The backend tracks chat engagement and distributes rewards for meaningful participation:

// api/chat-rewards.js
import express from 'express';

const router = express.Router();

// Daily chat activity reward
router.post('/rewards/chat-activity', async (req, res) => {
  const { walletAddress, messageCount, date } = req.body;

  // Check if already rewarded today
  const existing = await db.chatReward.findOne({ walletAddress, date });
  if (existing) {
    return res.json({ alreadyRewarded: true });
  }

  // Minimum 5 messages for reward eligibility
  if (messageCount < 5) {
    return res.status(400).json({ error: 'Minimum 5 messages required' });
  }

  // Quality check: messages must be in different time windows (anti-spam)
  const recentMessages = await db.chatMessages.find({
    sender: walletAddress,
    date,
    timestamp: { $gte: Date.now() - 24 * 60 * 60 * 1000 }
  });

  const uniqueHours = new Set(
    recentMessages.map(m => new Date(m.timestamp).getHours())
  );

  if (uniqueHours.size < 2) {
    return res.status(400).json({ 
      error: 'Messages must span at least 2 different hours' 
    });
  }

  // Distribute on-chain reward
  const tx = await loyaltyContract.rewardChatActivity(walletAddress);
  await tx.wait();

  await db.chatReward.create({ walletAddress, date, txHash: tx.hash });

  res.json({
    rewarded: true,
    txHash: tx.hash,
    message: 'Daily chat activity reward distributed'
  });
});

export default router;

Channel Structure Best Practices for Web3 Loyalty

Tutorial 3: Live Exclusive Events for Tier-Gated Members

Live events—product launches, workshops, fireside chats, exclusive reveals—create peak experiences that members remember and talk about. When gated by loyalty tier, they become powerful retention drivers.

Live Event Streaming Implementation

// features/loyalty-live-event.js
import TRTC from 'trtc-sdk-v5';

class LoyaltyLiveEvent {
  constructor(config) {
    this.trtc = TRTC.create();
    this.eventId = config.eventId;
    this.walletAddress = config.walletAddress;
    this.memberTier = config.memberTier;
    this.isHost = config.isHost || false;
    this.eventType = config.eventType;
    this.attendees = new Map();
    this.interactionLog = [];
  }

  async startEvent(userSig) {
    const roomConfig = {
      roomId: parseInt(this.eventId),
      sdkAppId: parseInt(process.env.TRTC_APP_ID),
      userId: this.walletAddress,
      userSig: userSig,
      scene: 'live',
      role: this.isHost ? 'anchor' : 'audience'
    };

    await this.trtc.enterRoom(roomConfig);

    if (this.isHost) {
      await this.trtc.startLocalVideo({
        view: 'host-video-container',
        option: {
          profile: '1080p',
          mirror: false
        }
      });
      await this.trtc.startLocalAudio({
        option: { profile: 'standard' }
      });

      this.screenShareReady = true;
    }

    this.setupEventHandlers();
    this.startAttendanceTracking();
    
    return { status: 'joined', role: this.isHost ? 'host' : 'viewer' };
  }

  async startScreenShare() {
    if (!this.isHost) throw new Error('Only host can share screen');

    await this.trtc.startScreenShare({
      option: {
        systemAudio: true,
        profile: '1080p'
      }
    });
  }

  async stopScreenShare() {
    await this.trtc.stopScreenShare();
  }

  setupEventHandlers() {
    this.trtc.on(TRTC.EVENT.REMOTE_VIDEO_AVAILABLE, (event) => {
      const { userId, streamType } = event;
      
      if (streamType === TRTC.TYPE.STREAM_TYPE_MAIN) {
        this.trtc.startRemoteVideo({
          userId,
          streamType,
          view: 'main-video-container'
        });
      } else if (streamType === TRTC.TYPE.STREAM_TYPE_SUB) {
        this.trtc.startRemoteVideo({
          userId,
          streamType,
          view: 'screen-share-container'
        });
      }
    });

    this.trtc.on(TRTC.EVENT.REMOTE_AUDIO_AVAILABLE, (event) => {
      console.log(`Audio available from: ${event.userId}`);
    });
  }

  startAttendanceTracking() {
    this.attendanceStart = Date.now();
    
    this.attendanceInterval = setInterval(() => {
      const duration = Math.floor((Date.now() - this.attendanceStart) / 60000);
      this.checkMilestoneRewards(duration);
    }, 5 * 60 * 1000);
  }

  checkMilestoneRewards(minutesAttended) {
    const milestones = [
      { minutes: 10, bonus: 'attendance_start' },
      { minutes: 30, bonus: 'half_event' },
      { minutes: 60, bonus: 'full_event' }
    ];

    milestones.forEach(milestone => {
      if (minutesAttended >= milestone.minutes && !this[`rewarded_${milestone.bonus}`]) {
        this[`rewarded_${milestone.bonus}`] = true;
        this.triggerMilestoneReward(milestone.bonus);
      }
    });
  }

  async triggerMilestoneReward(milestoneType) {
    await fetch('/api/rewards/live-event', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        walletAddress: this.walletAddress,
        eventId: this.eventId,
        milestone: milestoneType,
        duration: Date.now() - this.attendanceStart
      })
    });
  }

  async submitQuestion(question) {
    this.interactionLog.push({
      type: 'question',
      content: question,
      sender: this.walletAddress,
      tier: this.memberTier,
      timestamp: Date.now()
    });

    const priority = { Diamond: 1, Gold: 2, Silver: 3, Bronze: 4 };
    
    await fetch('/api/live-event/question', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        eventId: this.eventId,
        question,
        walletAddress: this.walletAddress,
        tier: this.memberTier,
        priority: priority[this.memberTier]
      })
    });
  }

  async submitPoll(pollId, choice) {
    await fetch('/api/live-event/poll-vote', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        eventId: this.eventId,
        pollId,
        choice,
        walletAddress: this.walletAddress
      })
    });
  }

  async endEvent() {
    clearInterval(this.attendanceInterval);
    
    if (this.isHost) {
      await this.trtc.stopLocalVideo();
      await this.trtc.stopLocalAudio();
    }
    
    await this.trtc.exitRoom();
    
    const totalDuration = Date.now() - this.attendanceStart;
    return {
      attended: Math.floor(totalDuration / 60000),
      interactions: this.interactionLog.length
    };
  }
}

// Usage: Member joining a Gold-tier exclusive product reveal
const liveEvent = new LoyaltyLiveEvent({
  eventId: '20240615-product-reveal',
  walletAddress: '0x1234...abcd',
  memberTier: 'Gold',
  isHost: false,
  eventType: 'product_reveal'
});

await liveEvent.startEvent(userSig);
await liveEvent.submitQuestion('When will the new feature be available for Gold members?');

Event Scheduling & Access Control API

// api/live-event-routes.js
import express from 'express';
import { createGateMiddleware } from '../lib/loyalty-gate.js';

const router = express.Router();
const tierGate = createGateMiddleware(
  process.env.LOYALTY_CONTRACT,
  process.env.RPC_URL
);

// Create a new exclusive live event
router.post('/events/create', tierGate('Diamond'), async (req, res) => {
  const { title, description, scheduledAt, minTier, eventType, maxAttendees } = req.body;

  const event = await db.liveEvent.create({
    eventId: `event-${Date.now()}`,
    title,
    description,
    scheduledAt: new Date(scheduledAt),
    minTier: minTier || 'Silver',
    eventType,
    maxAttendees: maxAttendees || 500,
    hostWallet: req.user.walletAddress,
    status: 'scheduled',
    attendees: [],
    questions: [],
    polls: []
  });

  await notifyEligibleMembers(event);
  res.json({ event });
});

// Register for an upcoming event
router.post('/events/:eventId/register', tierGate('Bronze'), async (req, res) => {
  const { eventId } = req.params;
  const { walletAddress } = req.user;
  const { memberProfile } = req;

  const event = await db.liveEvent.findOne({ eventId });
  if (!event) return res.status(404).json({ error: 'Event not found' });

  const tierOrder = { Bronze: 0, Silver: 1, Gold: 2, Diamond: 3 };
  if (tierOrder[memberProfile.tier] < tierOrder[event.minTier]) {
    return res.status(403).json({
      error: `Requires ${event.minTier} tier`,
      currentTier: memberProfile.tier,
      tokensNeeded: getTokensForNextTier(memberProfile.tier)
    });
  }

  if (event.attendees.length >= event.maxAttendees) {
    if (memberProfile.tier !== 'Diamond') {
      return res.status(409).json({ error: 'Event at capacity', waitlist: true });
    }
  }

  await db.liveEvent.updateOne(
    { eventId },
    { $addToSet: { attendees: walletAddress } }
  );

  res.json({ registered: true, eventId });
});

// Join the live event (generates streaming credentials)
router.post('/events/:eventId/join', tierGate('Bronze'), async (req, res) => {
  const { eventId } = req.params;
  const { walletAddress } = req.user;

  const event = await db.liveEvent.findOne({ eventId });
  
  if (!event.attendees.includes(walletAddress)) {
    return res.status(403).json({ error: 'Not registered for this event' });
  }

  const userSig = generateUserSig({
    sdkAppId: parseInt(process.env.TRTC_APP_ID),
    secretKey: process.env.TRTC_SECRET_KEY,
    userId: walletAddress,
    expire: 7200
  });

  res.json({
    eventId,
    userSig,
    sdkAppId: parseInt(process.env.TRTC_APP_ID),
    isHost: event.hostWallet === walletAddress,
    eventType: event.eventType
  });
});

export default router;

Event Types for Web3 Loyalty Programs

Tutorial 4: Unified Reward Distribution System

The final piece connects all community features to the on-chain reward engine. Every interaction—attending a voice AMA, participating in chat, watching a live event—flows through a unified system that distributes tokens and updates tiers.

Reward Orchestrator

// lib/reward-orchestrator.js
import { ethers } from 'ethers';

const LOYALTY_CONTRACT_ABI = [
  'function rewardVoiceAMA(address member) external',
  'function rewardLiveEvent(address member) external',
  'function rewardChatActivity(address member) external',
  'function rewardReferral(address referrer, address newMember) external',
  'function getMemberInfo(address member) view returns (tuple(uint8 tier, uint256 totalEarned, uint256 joinedAt, uint256 lastActivityAt, uint256 streakDays, uint256 communityScore))',
  'function balanceOf(address account) view returns (uint256)'
];

class RewardOrchestrator {
  constructor(config) {
    this.provider = new ethers.JsonRpcProvider(config.rpcUrl);
    this.signer = new ethers.Wallet(config.privateKey, this.provider);
    this.contract = new ethers.Contract(
      config.contractAddress,
      LOYALTY_CONTRACT_ABI,
      this.signer
    );
    this.pendingRewards = new Map();
    this.batchInterval = config.batchInterval || 60000;
  }

  async initialize() {
    this.processingLoop = setInterval(() => {
      this.processBatch();
    }, this.batchInterval);
  }

  queueReward(walletAddress, actionType, metadata = {}) {
    const key = `${walletAddress}-${actionType}`;
    
    if (this.pendingRewards.has(key)) {
      return { queued: false, reason: 'Already pending' };
    }

    this.pendingRewards.set(key, {
      walletAddress,
      actionType,
      metadata,
      queuedAt: Date.now()
    });

    return { queued: true, batchId: key };
  }

  async processBatch() {
    if (this.pendingRewards.size === 0) return;

    const batch = new Map(this.pendingRewards);
    this.pendingRewards.clear();

    const results = [];

    for (const [key, reward] of batch) {
      try {
        const tx = await this.distributeReward(reward);
        results.push({ key, success: true, txHash: tx.hash });
        this.emitRewardNotification(reward, tx.hash);
      } catch (error) {
        console.error(`Reward failed for ${key}:`, error.message);
        results.push({ key, success: false, error: error.message });
        
        if (!reward.retries || reward.retries < 3) {
          reward.retries = (reward.retries || 0) + 1;
          this.pendingRewards.set(key, reward);
        }
      }
    }

    return results;
  }

  async distributeReward(reward) {
    const { walletAddress, actionType } = reward;

    switch (actionType) {
      case 'voice_ama':
        return await this.contract.rewardVoiceAMA(walletAddress);
      case 'live_event':
        return await this.contract.rewardLiveEvent(walletAddress);
      case 'chat_activity':
        return await this.contract.rewardChatActivity(walletAddress);
      case 'referral':
        return await this.contract.rewardReferral(
          walletAddress, 
          reward.metadata.newMember
        );
      default:
        throw new Error(`Unknown action type: ${actionType}`);
    }
  }

  emitRewardNotification(reward, txHash) {
    const notification = {
      type: 'reward_earned',
      walletAddress: reward.walletAddress,
      action: reward.actionType,
      txHash,
      timestamp: Date.now()
    };

    globalEventBus.emit('reward:distributed', notification);
  }

  async getMemberDashboard(walletAddress) {
    const info = await this.contract.getMemberInfo(walletAddress);
    const balance = await this.contract.balanceOf(walletAddress);
    
    return {
      tier: ['Bronze', 'Silver', 'Gold', 'Diamond'][info.tier],
      totalEarned: ethers.formatEther(info.totalEarned),
      balance: ethers.formatEther(balance),
      streakDays: Number(info.streakDays),
      communityScore: Number(info.communityScore),
      nextTierProgress: this.calculateTierProgress(balance, info.tier)
    };
  }

  calculateTierProgress(balance, currentTier) {
    const thresholds = {
      0: ethers.parseEther('500'),
      1: ethers.parseEther('2000'),
      2: ethers.parseEther('10000'),
      3: null
    };

    if (currentTier === 3) return { progress: 100, nextTier: null };

    const target = thresholds[currentTier];
    const progress = Math.min(100, Math.floor((Number(balance) / Number(target)) * 100));

    return {
      progress,
      nextTier: ['Silver', 'Gold', 'Diamond'][currentTier],
      tokensNeeded: ethers.formatEther(target - balance)
    };
  }

  shutdown() {
    clearInterval(this.processingLoop);
  }
}

// Initialize
const orchestrator = new RewardOrchestrator({
  rpcUrl: process.env.RPC_URL,
  privateKey: process.env.REWARD_SIGNER_KEY,
  contractAddress: process.env.LOYALTY_CONTRACT,
  batchInterval: 60000
});

await orchestrator.initialize();
export default orchestrator;

Integrating All Components: The Complete Web3 Loyalty Stack

Here's how voice AMAs, chat channels, live events, and token rewards work together as a unified web3 loyalty program:

Application Entry Point

// app.js
import express from 'express';
import { LoyaltyGate } from './lib/loyalty-gate.js';
import voiceAMARoutes from './api/voice-ama-routes.js';
import chatRewardRoutes from './api/chat-rewards.js';
import liveEventRoutes from './api/live-event-routes.js';
import orchestrator from './lib/reward-orchestrator.js';

const app = express();
app.use(express.json());

// Wallet authentication middleware
app.use('/api', walletAuthMiddleware);

// Feature routes
app.use('/api', voiceAMARoutes);
app.use('/api', chatRewardRoutes);
app.use('/api', liveEventRoutes);

// Member dashboard
app.get('/api/dashboard', async (req, res) => {
  const { walletAddress } = req.user;
  const dashboard = await orchestrator.getMemberDashboard(walletAddress);
  
  const events = await getAccessibleEvents(walletAddress, dashboard.tier);
  const channels = getChannelsForTier(dashboard.tier);

  res.json({
    ...dashboard,
    upcomingEvents: events,
    availableChannels: channels,
    nextRewardActions: getRecommendedActions(dashboard)
  });
});

// Webhook: On-chain events trigger community notifications
app.post('/webhooks/on-chain', async (req, res) => {
  const { event, data } = req.body;

  switch (event) {
    case 'TierUpgraded':
      await notifyTierUpgrade(data.member, data.oldTier, data.newTier);
      await grantNewChannelAccess(data.member, data.newTier);
      break;
    case 'RewardEarned':
      await sendRewardNotification(data.member, data.amount, data.action);
      break;
    case 'MilestoneReached':
      await celebrateInChat(data.member, data.milestone);
      break;
  }

  res.json({ processed: true });
});

app.listen(3000, () => {
  console.log('Web3 Loyalty Platform running on port 3000');
});

Member Journey: From Signup to Diamond

The integrated system creates a natural progression path:

Day 1 (Bronze):
├── Join program → 100 token welcome bonus
├── Enter #general and #introductions chat
├── Browse upcoming events (see what Gold/Diamond get access to)
└── Daily streak: claim 5 tokens

Week 1-4 (Bronze → Silver):
├── Attend weekly voice AMAs → 50 tokens each
├── Chat daily in channels → 10 tokens/day
├── Refer 2 friends → 200 tokens
├── Complete daily streaks → compounding bonus
└── Hit 500 tokens → AUTO-UPGRADE to Silver

Month 2-4 (Silver):
├── Unlock #alpha-signals and #governance-discussion
├── Participate in governance votes (rewarded)
├── Attend Silver+ live events
├── 1.25x reward multiplier on all actions
└── Hit 2000 tokens → AUTO-UPGRADE to Gold

Month 4-8 (Gold):
├── Unlock #founders-room and #early-access
├── Priority speaking in voice AMAs
├── Access exclusive workshops and product reveals
├── 1.5x reward multiplier
└── Hit 10000 tokens → AUTO-UPGRADE to Diamond

Month 8+ (Diamond):
├── Unlock #diamond-lounge and #strategy-council
├── First-priority speaking in all AMAs
├── Input on product direction in strategy sessions
├── 2x reward multiplier on all actions
└── Participate in quarterly governance councils

Engagement Metrics: Measuring Web3 Loyalty Program Success

Running a web3 loyalty program without metrics is flying blind. Track these KPIs across all community features:

Core Retention Metrics

Community Health Indicators

Implementation: Analytics Dashboard

// analytics/loyalty-metrics.js
class LoyaltyAnalytics {
  async getDashboardMetrics(timeRange = '30d') {
    const [voiceMetrics, chatMetrics, eventMetrics, tokenMetrics] = await Promise.all([
      this.getVoiceAMAMetrics(timeRange),
      this.getChatMetrics(timeRange),
      this.getLiveEventMetrics(timeRange),
      this.getTokenMetrics(timeRange)
    ]);

    return {
      overview: {
        totalMembers: await this.getTotalMembers(),
        activeMembers: await this.getActiveMembers(timeRange),
        retentionRate: await this.getRetentionRate(timeRange),
        avgStreakDays: await this.getAverageStreak()
      },
      voice: voiceMetrics,
      chat: chatMetrics,
      events: eventMetrics,
      tokens: tokenMetrics,
      tierDistribution: await this.getTierDistribution()
    };
  }

  async getVoiceAMAMetrics(timeRange) {
    return {
      totalSessions: await db.amaSessions.count({ timeRange }),
      avgAttendees: await db.amaSessions.aggregate('avg_attendees', { timeRange }),
      avgDuration: await db.amaSessions.aggregate('avg_duration', { timeRange }),
      speakerRequestRate: await this.calculateSpeakerRequestRate(timeRange),
      rewardsDistributed: await this.getRewardsByType('voice_ama', timeRange)
    };
  }

  async getChatMetrics(timeRange) {
    return {
      dailyActiveUsers: await db.chatActivity.distinctCount('wallet', { timeRange }),
      messagesPerDay: await db.chatMessages.aggregate('avg_per_day', { timeRange }),
      topChannels: await db.chatMessages.groupBy('channel', { timeRange, limit: 5 }),
      rewardEligibleMembers: await this.getChatRewardEligible(timeRange)
    };
  }

  async getLiveEventMetrics(timeRange) {
    return {
      eventsHosted: await db.liveEvents.count({ timeRange }),
      avgAttendance: await db.liveEvents.aggregate('avg_attendees', { timeRange }),
      completionRate: await this.calculateEventCompletion(timeRange),
      questionsSubmitted: await db.eventQuestions.count({ timeRange })
    };
  }

  async getTierDistribution() {
    const total = await this.getTotalMembers();
    const tiers = await db.members.groupBy('tier');
    
    return {
      Bronze: { count: tiers.Bronze, percentage: (tiers.Bronze / total * 100).toFixed(1) },
      Silver: { count: tiers.Silver, percentage: (tiers.Silver / total * 100).toFixed(1) },
      Gold: { count: tiers.Gold, percentage: (tiers.Gold / total * 100).toFixed(1) },
      Diamond: { count: tiers.Diamond, percentage: (tiers.Diamond / total * 100).toFixed(1) }
    };
  }
}

Advanced Patterns: Maximizing Web3 Loyalty Retention

Pattern 1: Cross-Feature Reward Multipliers

Members who engage across multiple features (voice + chat + events) get bonus multipliers:

function calculateWeeklyBonus(memberActivity) {
  const features = {
    voice: memberActivity.amaAttended > 0,
    chat: memberActivity.chatDays >= 3,
    events: memberActivity.eventsAttended > 0,
    streak: memberActivity.streakDays >= 7
  };

  const activeFeatures = Object.values(features).filter(Boolean).length;
  
  // Multiplier: 1x for 1 feature, 1.5x for 2, 2x for 3, 3x for all 4
  const multipliers = { 1: 1, 2: 1.5, 3: 2, 4: 3 };
  
  return {
    multiplier: multipliers[activeFeatures] || 1,
    activeFeatures,
    breakdown: features
  };
}

Pattern 2: Community-Driven Reward Governance

Let Diamond members vote on reward parameters:

// Governance extension for LoyaltyRewardToken
function proposeRewardChange(
    string memory actionType,
    uint256 newAmount
) external {
    require(members[msg.sender].tier == Tier.Diamond, "Diamond only");
    
    proposals.push(Proposal({
        proposer: msg.sender,
        actionType: actionType,
        newAmount: newAmount,
        votesFor: 0,
        votesAgainst: 0,
        deadline: block.timestamp + 7 days,
        executed: false
    }));
}

function voteOnProposal(uint256 proposalId, bool support) external {
    require(members[msg.sender].tier >= Tier.Gold, "Gold+ required");
    require(!hasVoted[proposalId][msg.sender], "Already voted");
    
    hasVoted[proposalId][msg.sender] = true;
    
    if (support) {
        proposals[proposalId].votesFor += 1;
    } else {
        proposals[proposalId].votesAgainst += 1;
    }
}

Pattern 3: Referral Chains with Tiered Rewards

async function processReferral(referrerWallet, newMemberWallet) {
  // Direct referrer gets full reward
  await orchestrator.queueReward(referrerWallet, 'referral', {
    newMember: newMemberWallet,
    level: 1
  });

  // Check if referrer was also referred (2-level deep)
  const referrerInfo = await db.referrals.findOne({ referred: referrerWallet });
  if (referrerInfo) {
    await orchestrator.queueReward(referrerInfo.referrer, 'referral_chain', {
      newMember: newMemberWallet,
      level: 2,
      bonusMultiplier: 0.25
    });
  }
}

Pattern 4: Decay Prevention (Keep Members Active)

async function checkDecayRisk() {
  const members = await db.members.find({
    lastActivityAt: { $lt: Date.now() - 48 * 60 * 60 * 1000 }
  });

  for (const member of members) {
    const riskLevel = calculateRiskLevel(member);
    
    if (riskLevel === 'high') {
      await sendChatNotification(member.walletAddress, {
        type: 'streak_warning',
        message: `Your ${member.streakDays}-day streak is at risk! Join today's AMA to keep it alive.`,
        cta: { action: 'join_ama', label: 'Join Now' }
      });
    }
  }
}

Why TRTC for Web3 Loyalty Programs

Building real-time community features for a web3 loyalty program requires infrastructure that matches the decentralization ethos while delivering consumer-grade quality. Here's why TRTC is the right choice:

Technical Advantages

Architectural Benefits

You own the infrastructure: No risk of Discord banning your community. No dependency on centralized platforms that can change policies overnight.

Wallet-native authentication: TRTC's UserSig system accepts any user identifier—including wallet addresses—so token-gating logic lives in your backend, not a third-party bot.

Composable features: Voice rooms, live streaming, and chat are independent modules you combine as needed. Start with chat, add voice AMAs when ready, scale to live events as your community grows.

No vendor lock-in on community data: Message history, attendance records, and engagement metrics live in your database. Export, analyze, and use them for on-chain reward calculations without API restrictions.

GVoice for Gaming-Adjacent Loyalty

For web3 loyalty programs with gaming elements (play-to-earn, gamified quests, metaverse experiences), GVoice provides ultra-low-latency voice optimized for gaming environments—spatial audio, noise suppression, and lightweight SDKs that run alongside game engines.

Deployment Checklist: Launching Your Web3 Loyalty Program

Phase 1: Foundation (Week 1-2)

•  Deploy LoyaltyRewardToken smart contract to testnet
•  Configure TRTC application (get SDKAppID and secret key)
•  Implement wallet authentication (MetaMask / WalletConnect)
•  Set up token-gate verification middleware
•  Create member registration flow (joinProgram)

Phase 2: Core Features (Week 3-4)

•  Build voice AMA room with tier-based priority queue
•  Implement chat channels with tier-gating
•  Set up reward orchestrator and batch processing
•  Create member dashboard (tier, balance, streak, progress)
•  Test reward distribution flow end-to-end

Phase 3: Live Events (Week 5-6)

•  Implement live event scheduling and registration
•  Build event streaming with Q&A and polls
•  Add attendance-based milestone rewards
•  Create event notification system via chat
•  Test capacity management and tier-gating

Phase 4: Optimization (Week 7-8)

•  Implement cross-feature multiplier bonuses
•  Add decay prevention notifications
•  Set up analytics dashboard
•  Deploy to mainnet
•  Launch with founding member bonus event

TRTC Quick Setup via MCP

For rapid prototyping and development assistance, add the TRTC MCP server to your development environment:

npx -y @anthropic-ai/claude-code mcp add trtc -- npx -y @anthropic-ai/mcp-remote https://mcp.trtc.io/sse

This gives you access to TRTC API documentation, code generation, and configuration helpers directly in your development workflow.

Common Pitfalls in Web3 Loyalty Programs (And How to Avoid Them)

Pitfall 1: Token Rewards Without Community

Problem: Members accumulate tokens but have no reason to stay beyond financial speculation. When token price drops, members leave.

Solution: Make community interaction the primary value. Tokens unlock access to voice AMAs, chat channels, and live events. The social bonds become the retention mechanism; tokens are the key that opens the door.

Pitfall 2: Overcomplicated Tier Systems

Problem: Too many tiers, confusing multipliers, and unclear upgrade paths frustrate members.

Solution: Keep it to 4 tiers maximum. Make the math simple: "Earn 500 tokens → Silver. Earn 2000 → Gold." Display progress bars. Celebrate upgrades publicly in chat.

Pitfall 3: Reward Farming and Bots

Problem: Bots spam chat or idle in voice rooms to farm tokens.

Solution: Implement cooldowns (1 action per hour per type), quality checks (messages must span multiple hours), and minimum duration requirements (15 minutes in voice AMA). The smart contract's _enforceCooldown handles on-chain protection.

Pitfall 4: Dead Channels

Problem: You create 20 chat channels and 18 are empty.

Solution: Start with 3-4 channels maximum. Add new channels only when existing ones are too noisy. Tier-gated channels should always have activity—if Diamond Lounge is empty, your program hasn't reached enough Diamond members yet.

Pitfall 5: Invisible Blockchain

Problem: Web3 complexity (wallet setup, gas fees, transaction signing) scares off mainstream users.

Solution: Abstract the blockchain layer completely. Members see "tokens" and "rewards"—not transactions, gas, or smart contracts. Use gasless meta-transactions (ERC-2771) so members never pay gas. Provide embedded wallets for members who don't have one.

Conclusion: Building Loyalty That Lasts in Web3

Web3 loyalty programs succeed when they transcend the transactional. Token rewards provide the economic incentive, but real-time community interaction—voice AMAs where members talk to founders, live events that create shared memories, and chat channels that become daily destinations—creates the emotional attachment that prevents churn.

The architecture presented in this guide combines:

• Smart contracts for transparent, trustless reward distribution
• TRTC voice rooms for high-engagement AMAs with tier-based priority
• TRTC live streaming for exclusive events that reward attendance
• TRTC chat for persistent community channels gated by loyalty tier
• Unified reward orchestrator connecting all touchpoints to on-chain rewards

The result is a web3 loyalty program where every interaction reinforces the next. Members attend a voice AMA → earn tokens → unlock a new chat channel → discover an upcoming live event → attend and earn more tokens → hit the next tier. The flywheel compounds.

Start with the smart contract and one community feature (voice AMAs are highest ROI). Prove engagement lift, then layer on chat channels and live events. Within 8 weeks, you'll have a complete loyalty ecosystem where members don't just earn—they belong.

Build your real-time community layer at trtc.io/solutions/web3. Explore voice chat rooms for AMAs, and chat infrastructure for member channels.