Token Economy Design

This is a starter document outlining the MOOD MNKY token economy framework. Future iterations will include more detailed implementation guides and economic modeling.

Overview

The MOOD MNKY token economy creates a value-based ecosystem that incentivizes engagement, rewards contribution, and provides alternative access paths to premium products and experiences. This document outlines the economic principles, token mechanics, implementation guidelines, and management strategies for the platform’s token system.

Core Principles

The token economy is designed around these fundamental principles:

Value-Backed Currency: Tokens represent real value within the ecosystem
Balanced Economics: Sustainable token creation and consumption cycles
Meaningful Rewards: Incentives aligned with platform goals and user desires
Inclusive Access: Alternative pathways to premium experiences
Community Contribution: Rewards for platform enhancement and support

Token System Architecture

Economic Model

The MOOD MNKY token economy follows a circular flow model:

Token Types

Experience Tokens (XP)

Primary currency of the ecosystem

Earned through platform engagement
Spent on rewards and experiences
No expiration date
Non-transferable between users

Achievement Badges

Status markers and special capabilities

Earned through milestone achievements
Unlocks special features or capabilities
Displayed in user profiles
Permanent once earned

Token Ecosystem Components

Token Earning Mechanisms

Core Earning Activities

Learning Engagement

Educational participation rewards

Module completion: 25-100 XP
Environment mastery: 250 XP
Assessment completion: 15-50 XP
Daily learning streak: 5-25 XP

Community Contribution

Social and community rewards

Helpful responses: 10-50 XP
Content creation: 25-200 XP
Event participation: 25-75 XP
Mentorship activities: 50-150 XP

Platform Activities

General engagement rewards

Daily login: 5 XP
Profile completion: 50 XP
Feedback provision: 10-25 XP
Challenge completion: 25-100 XP

Earning Rules Implementation

Token earning rules are implemented through a rule-based engine:

export interface TokenRule {
  id: string;
  eventType: string;
  conditions: TokenCondition[];
  rewards: TokenReward[];
  limits: TokenLimit[];
  priority: number;
  isActive: boolean;
}

export interface TokenCondition {
  field: string;
  operator: 'equals' | 'notEquals' | 'contains' | 'greaterThan' | 'lessThan';
  value: any;
}

export interface TokenReward {
  type: 'XP' | 'BADGE';
  amount: number;
  itemId?: string; // For badges
}

export interface TokenLimit {
  type: 'daily' | 'weekly' | 'monthly' | 'lifetime' | 'perItem';
  maxCount: number;
  currentCount?: number;
}

// Example rule definitions
const tokenRules: TokenRule[] = [
  {
    id: 'module-completion',
    eventType: 'MODULE_COMPLETED',
    conditions: [
      { field: 'status', operator: 'equals', value: 'COMPLETED' }
    ],
    rewards: [
      { type: 'XP', amount: 50 }
    ],
    limits: [
      { type: 'perItem', maxCount: 1 }
    ],
    priority: 10,
    isActive: true
  },
  {
    id: 'helpful-response',
    eventType: 'POST_REACTION',
    conditions: [
      { field: 'reactionType', operator: 'equals', value: 'HELPFUL' },
      { field: 'uniqueUsers', operator: 'greaterThan', value: 2 }
    ],
    rewards: [
      { type: 'XP', amount: 10 }
    ],
    limits: [
      { type: 'daily', maxCount: 5 }
    ],
    priority: 5,
    isActive: true
  }
];

Reward Schedules

Token rewards follow strategic schedules to maximize engagement:

Fixed-Ratio Rewards: Predictable rewards for specific achievements
Variable-Ratio Rewards: Occasional surprise bonuses for sustained engagement
Progressive Rewards: Increasing rewards for consecutive actions
Milestone Bonuses: Significant rewards for major achievements
Community Multipliers: Enhanced rewards during community events

Example implementation of a progressive reward:

// Streak reward calculation
function calculateStreakReward(userId: string, activityType: string): number {
  const userStreaks = getUserStreakData(userId);
  const currentStreak = userStreaks[activityType] || 0;
  
  // Base reward
  let reward = 5;
  
  // Progressive multipliers
  if (currentStreak >= 30) {
    reward = 25; // 5x for 30+ day streak
  } else if (currentStreak >= 14) {
    reward = 15; // 3x for 14+ day streak
  } else if (currentStreak >= 7) {
    reward = 10; // 2x for 7+ day streak
  }
  
  // Apply any active event multipliers
  const eventMultiplier = getActiveEventMultiplier(activityType);
  reward = reward * eventMultiplier;
  
  return reward;
}

Token Spending Options

Redemption Categories

Product Benefits

E-commerce related rewards

Product discounts: 100-500 XP
Free shipping: 200 XP
Exclusive products: 500-2000 XP
Early access: 300-800 XP

Experience Access

Premium content and features

Premium environments: 200-800 XP
Expert sessions: 300-1000 XP
Advanced tools: 150-600 XP
Event access: 200-1500 XP

Community Status

Recognition and influence

Profile customization: 50-300 XP
Featured creator status: 1000 XP
Community moderator: 2000 XP
Custom badges: 300-800 XP

Redemption Implementation

The token redemption system is implemented through a marketplace:

export interface RedemptionItem {
  id: string;
  title: string;
  description: string;
  category: 'PRODUCT' | 'EXPERIENCE' | 'STATUS' | 'FEATURE';
  costXP: number;
  inventory: number | 'unlimited';
  startDate: Date;
  endDate: Date | null;
  isActive: boolean;
  redemptionProcess: RedemptionProcess;
  image?: string;
  tags: string[];
}

export type RedemptionProcess = 
  | { type: 'COUPON_CODE' }
  | { type: 'FEATURE_UNLOCK', featureId: string }
  | { type: 'ACCESS_GRANT', contentId: string }
  | { type: 'PROFILE_ENHANCEMENT', enhancementId: string }
  | { type: 'CUSTOM_FULFILLMENT', instructions: string };

// Example redemption marketplace
const redemptionItems: RedemptionItem[] = [
  {
    id: 'product-discount-10',
    title: '10% Off Your Next Purchase',
    description: 'Receive a 10% discount code for your next order',
    category: 'PRODUCT',
    costXP: 100,
    inventory: 'unlimited',
    startDate: new Date('2023-01-01'),
    endDate: null,
    isActive: true,
    redemptionProcess: { type: 'COUPON_CODE' },
    tags: ['discount', 'product']
  },
  {
    id: 'premium-environment-access',
    title: 'Master Blender Environment Access',
    description: 'Gain access to our advanced fragrance creation environment',
    category: 'EXPERIENCE',
    costXP: 500,
    inventory: 'unlimited',
    startDate: new Date('2023-01-01'),
    endDate: null,
    isActive: true,
    redemptionProcess: { 
      type: 'ACCESS_GRANT', 
      contentId: 'env-master-blender'
    },
    tags: ['premium', 'learning', 'fragrance']
  }
];

Redemption Process Flow

Token Economy Management

Economic Controls

The token economy includes controls to maintain economic health:

Supply Management

Controls on token creation

Daily earning caps
Velocity controls
Event-based token multipliers
Activity-specific limits

Sink Mechanisms

Token consumption methods

Redemption marketplace
Premium feature access
Time-limited opportunities
Special event entries

Analytical Monitoring

The token economy is monitored through comprehensive analytics:

// Example token economy health metrics
interface TokenEconomyHealth {
  // Supply Metrics
  totalTokensCreated: number;
  tokenCreationRate: number; // per day
  activeUserEarningRate: number; // avg per user per day
  earningDistribution: Distribution;
  
  // Demand Metrics
  totalTokensRedeemed: number;
  redemptionRate: number; // per day
  popularRedemptionItems: RankedItem[];
  redemptionDistribution: Distribution;
  
  // Balance Metrics
  currentCirculatingSupply: number;
  averageUserBalance: number;
  balanceDistribution: Distribution;
  
  // Activity Metrics
  earningActivityDistribution: Record<string, number>;
  userEngagementCorrelation: number; // correlation between token activity and overall engagement
  redemptionConversionRate: number; // % of users who redeem tokens
  
  // Health Indicators
  economyVelocity: number; // turnover rate
  inflationRate: number; // % change in purchasing power
  participationRate: number; // % of users engaging with token system
}

Administrative Controls

The token economy includes administrative tools:

Rules Management Console: Configure and adjust earning rules
Marketplace Administration: Manage redemption offerings
User Balance Management: Address issues and special cases
Reporting Dashboard: Monitor economy health
Simulation Tools: Test economic changes before implementation

Example administrative interface for rule configuration:

// Rule management service
export class TokenRuleManagementService {
  // Create a new token rule
  async createRule(rule: TokenRule): Promise<TokenRule> {
    this.validateRule(rule);
    
    // Check for conflicting rules
    const conflicts = await this.checkForConflicts(rule);
    if (conflicts.length > 0) {
      throw new Error(`Rule conflicts with existing rules: ${conflicts.map(r => r.id).join(', ')}`);
    }
    
    // Create the rule
    const createdRule = await this.ruleRepository.create(rule);
    
    // Log the creation
    await this.activityLog.logAdminAction({
      actionType: 'RULE_CREATED',
      adminId: this.currentAdmin.id,
      resourceId: createdRule.id,
      metadata: { ruleSummary: this.summarizeRule(createdRule) }
    });
    
    // Clear cache
    await this.cacheService.invalidate('token:rules');
    
    return createdRule;
  }
  
  // Update an existing rule
  async updateRule(id: string, updates: Partial<TokenRule>): Promise<TokenRule> {
    const existingRule = await this.ruleRepository.findById(id);
    if (!existingRule) {
      throw new Error(`Rule not found: ${id}`);
    }
    
    // Apply updates
    const updatedRule = { ...existingRule, ...updates };
    this.validateRule(updatedRule);
    
    // Check for conflicts
    const conflicts = await this.checkForConflicts(updatedRule);
    if (conflicts.length > 0) {
      throw new Error(`Rule conflicts with existing rules: ${conflicts.map(r => r.id).join(', ')}`);
    }
    
    // Save the updated rule
    const savedRule = await this.ruleRepository.update(id, updates);
    
    // Log the update
    await this.activityLog.logAdminAction({
      actionType: 'RULE_UPDATED',
      adminId: this.currentAdmin.id,
      resourceId: savedRule.id,
      metadata: { 
        beforeSummary: this.summarizeRule(existingRule),
        afterSummary: this.summarizeRule(savedRule)
      }
    });
    
    // Clear cache
    await this.cacheService.invalidate('token:rules');
    
    return savedRule;
  }
  
  // Other rule management methods...
}

Member Experience

Token Interface Design

The token system is presented through intuitive interfaces:

Token Dashboard

Personal token status

Current balance
Earning history
Redemption history
Progress toward goals

Earning Opportunities

Discover ways to earn tokens

Featured opportunities
Personalized suggestions
Available challenges
Special events

Redemption Marketplace

Browse and redeem rewards

Available rewards
Category filtering
Featured items
Limited-time offerings

Achievement Gallery

Showcase accomplishments

Earned badges
Milestone achievements
Progress tracking
Community recognition

User Feedback Integration

The token system includes embedded feedback mechanisms:

Satisfaction Ratings: Quick reactions to redemption experiences
Value Perception: Assessment of reward value relative to effort
Suggestion System: User input on new rewards and opportunities
Preference Tracking: Analysis of redemption patterns
A/B Testing: Controlled experiments for token system improvements

Example implementation of a redemption feedback component:

// Redemption feedback component
import { useState } from 'react';
import { StarRating } from '@/components/common/StarRating';
import { Button } from '@/components/ui/button';
import { useTokenService } from '@/hooks/useTokenService';

export function RedemptionFeedback({ redemptionId, itemTitle }: RedemptionFeedbackProps) {
  const [rating, setRating] = useState<number | null>(null);
  const [comment, setComment] = useState('');
  const [submitted, setSubmitted] = useState(false);
  const { submitRedemptionFeedback } = useTokenService();
  
  const handleSubmit = async () => {
    if (rating === null) return;
    
    await submitRedemptionFeedback({
      redemptionId,
      rating,
      comment,
      submittedAt: new Date()
    });
    
    setSubmitted(true);
    
    // Add token reward for providing feedback
    // This encourages feedback without biasing the rating
  };
  
  if (submitted) {
    return (
      <div className="p-4 bg-green-50 rounded-md">
        <p className="text-green-800 font-medium">
          Thank you for your feedback!
        </p>
        <p className="text-green-600 text-sm mt-1">
          Your input helps us improve our rewards.
        </p>
      </div>
    );
  }
  
  return (
    <div className="p-4 border rounded-md">
      <h4 className="font-medium mb-2">How was your experience with "{itemTitle}"?</h4>
      
      <div className="mb-4">
        <StarRating 
          value={rating} 
          onChange={setRating} 
          size="medium" 
        />
      </div>
      
      <div className="mb-4">
        <label className="block text-sm mb-1">
          Additional comments (optional)
        </label>
        <textarea
          className="w-full border rounded-md p-2 text-sm"
          rows={3}
          value={comment}
          onChange={e => setComment(e.target.value)}
          placeholder="Tell us more about your experience..."
        />
      </div>
      
      <Button
        onClick={handleSubmit}
        disabled={rating === null}
      >
        Submit Feedback
      </Button>
    </div>
  );
}

Integration With Other Systems

Learning System Integration

The token economy integrates with the Dojo learning platform:

E-commerce Integration

The token economy connects with the Shopify e-commerce system:

Community Integration

The token economy enhances community participation:

Implementation Examples

// Example learning achievement hook
export function useTrackLearningAchievements() {
  const { user } = useAuth();
  const { trackEvent } = useTokenEvents();
  
  // Track module completion
  const trackModuleCompletion = async (moduleId: string, environmentId: string) => {
    if (!user) return;
    
    await trackEvent({
      eventType: 'MODULE_COMPLETED',
      userId: user.id,
      metadata: {
        moduleId,
        environmentId,
        completedAt: new Date().toISOString()
      }
    });
  };
  
  // Track assessment completion
  const trackAssessmentCompletion = async (
    assessmentId: string, 
    score: number, 
    maxScore: number
  ) => {
    if (!user) return;
    
    await trackEvent({
      eventType: 'ASSESSMENT_COMPLETED',
      userId: user.id,
      metadata: {
        assessmentId,
        score,
        maxScore,
        percentage: (score / maxScore) * 100,
        completedAt: new Date().toISOString()
      }
    });
  };
  
  return {
    trackModuleCompletion,
    trackAssessmentCompletion
  };
}

Economic Modeling and Balancing

Economic Simulation

The token economy is balanced through simulation models:

Supply Simulation

Projecting token creation

User growth modeling
Activity pattern analysis
Seasonal variation effects
Promotional impact assessment

Demand Simulation

Projecting token consumption

Redemption preference modeling
Price sensitivity analysis
Limited-item demand spikes
Satisfaction correlation

Balance Adjustment Mechanisms

The token economy includes several adjustment levers:

Earning Rate Adjustments: Fine-tuning token creation rates
Dynamic Pricing: Adjusting redemption costs based on demand
Limited-Time Opportunities: Creating periodic demand spikes
Progressive Value Scale: Increasing reward value efficiency at scale
Seasonal Promotions: Scheduled variations in token creation/consumption

Example of a dynamic pricing implementation:

// Dynamic pricing service
export class DynamicPricingService {
  // Calculate the current price for a redemption item
  async calculateCurrentPrice(itemId: string): Promise<number> {
    const item = await this.itemRepository.findById(itemId);
    if (!item) {
      throw new Error(`Item not found: ${itemId}`);
    }
    
    // Start with base price
    let currentPrice = item.baseCostXP;
    
    // Apply demand adjustment if enabled
    if (item.dynamicPricing?.demandBased) {
      const demandFactor = await this.calculateDemandFactor(itemId);
      currentPrice = Math.round(currentPrice * demandFactor);
    }
    
    // Apply inventory adjustment if enabled and limited inventory
    if (item.dynamicPricing?.inventoryBased && typeof item.inventory === 'number') {
      const inventoryFactor = await this.calculateInventoryFactor(item.inventory, item.initialInventory);
      currentPrice = Math.round(currentPrice * inventoryFactor);
    }
    
    // Apply time-based adjustment if enabled
    if (item.dynamicPricing?.timeBased && item.endDate) {
      const timeFactor = this.calculateTimeFactor(item.startDate, item.endDate);
      currentPrice = Math.round(currentPrice * timeFactor);
    }
    
    // Apply global economic adjustment
    const economicFactor = await this.getEconomicAdjustmentFactor();
    currentPrice = Math.round(currentPrice * economicFactor);
    
    // Ensure price doesn't go below minimum
    const minPrice = item.dynamicPricing?.minimumPrice || item.baseCostXP * 0.5;
    currentPrice = Math.max(currentPrice, minPrice);
    
    // Ensure price doesn't exceed maximum
    const maxPrice = item.dynamicPricing?.maximumPrice || item.baseCostXP * 2;
    currentPrice = Math.min(currentPrice, maxPrice);
    
    return currentPrice;
  }
  
  // Calculate factor based on recent demand
  private async calculateDemandFactor(itemId: string): Promise<number> {
    const redemptionCount = await this.redemptionRepository.countRecent(itemId, 7); // Last 7 days
    const expectedRate = 10; // Expected redemptions per week
    
    // Calculate demand ratio (actual / expected)
    const demandRatio = redemptionCount / expectedRate;
    
    // Apply demand curve: price = base * (1 + log(demand ratio))
    // This creates a logarithmic price increase as demand increases
    const demandFactor = 1 + (Math.log(demandRatio + 0.1) / Math.log(10));
    
    // Constrain the factor within reasonable bounds
    return Math.max(0.8, Math.min(demandFactor, 1.5));
  }
  
  // Other pricing calculation methods...
}

Implementation Roadmap

Development Phases

The token economy will be implemented in phases:

Foundation (Q1)

Core token system implementation

Token ledger system
Basic earning rules
Simple redemption options
User interface foundations

Expansion (Q2)

Enhanced functionality and offerings

Additional earning opportunities
Expanded redemption marketplace
Badge achievement system
Basic analytics dashboard

Integration (Q3)

System connections and advanced features

E-commerce integration
Community integration
Advanced analytics
Dynamic pricing engine

Optimization (Q4)

Refinement and advanced economics

Economic modeling tools
Simulation capabilities
Personalized opportunities
Enhanced user experiences

Key Milestones

MVP Launch: Basic token earning and redemption
Marketplace Expansion: Diverse reward offerings
E-commerce Integration: Product discount redemption
Community Achievement System: Social recognition framework
Dynamic Economy: Automated balancing mechanisms

Ethical Considerations

Value Transparency

The token economy maintains clear value communication:

Clear Value Representation: Transparent correlation between effort and reward
Honest Pricing: Redemption costs aligned with actual value
Effort Respect: Appropriate rewards for user time and energy
Value Education: Helping users understand the economic system
Preference Accommodation: Multiple paths to rewards for different preferences

Inclusivity Design

The token economy is designed for all users:

Multiple Earning Pathways: Diverse ways to earn tokens
Accessibility Considerations: Earning opportunities for all ability levels
Time Flexibility: Options for different time commitment levels
Skill Diversity: Opportunities for various skill sets
Progressive Access: Entry points at multiple commitment levels

Resources and References

Implementation Guides

Technical guides for implementation

Rule Designer

Token rule creation tool

Economic Dashboard

Token economy analytics

Integration Samples

Code examples for system integration

Dojo Platform

User Experience

Community Features

Strategic Planning

​Token Economy Design

​Overview

​Core Principles

​Token System Architecture

​Economic Model

​Token Types

Experience Tokens (XP)

Achievement Badges

​Token Ecosystem Components

​Token Earning Mechanisms

​Core Earning Activities

Learning Engagement

Community Contribution

Platform Activities

​Earning Rules Implementation

​Reward Schedules

​Token Spending Options

​Redemption Categories

Product Benefits

Experience Access

Community Status

​Redemption Implementation

​Redemption Process Flow

​Token Economy Management

​Economic Controls

Supply Management

Sink Mechanisms

​Analytical Monitoring

​Administrative Controls

​Member Experience

​Token Interface Design

Token Dashboard

Earning Opportunities

Redemption Marketplace

Achievement Gallery

​User Feedback Integration

​Integration With Other Systems

​Learning System Integration

​E-commerce Integration

​Community Integration

​Implementation Examples

​Economic Modeling and Balancing

​Economic Simulation

Supply Simulation

Demand Simulation

​Balance Adjustment Mechanisms

​Implementation Roadmap

​Development Phases

​Key Milestones

​Ethical Considerations

​Value Transparency

​Inclusivity Design

​Resources and References

Implementation Guides

Rule Designer

Economic Dashboard

Integration Samples

Token Economy Design

Overview

Core Principles

Token System Architecture

Economic Model

Token Types

Token Ecosystem Components

Token Earning Mechanisms

Core Earning Activities

Earning Rules Implementation

Reward Schedules

Token Spending Options

Redemption Categories

Redemption Implementation

Redemption Process Flow

Token Economy Management

Economic Controls

Analytical Monitoring

Administrative Controls

Member Experience

Token Interface Design

User Feedback Integration

Integration With Other Systems

Learning System Integration

E-commerce Integration

Community Integration

Implementation Examples

Economic Modeling and Balancing

Economic Simulation

Balance Adjustment Mechanisms

Implementation Roadmap

Development Phases

Key Milestones

Ethical Considerations

Value Transparency

Inclusivity Design

Resources and References