List Achievements

{
  "success": true,
  "achievements": [
    {
      "id": "defi-pioneer",
      "title": "DeFi Pioneer",
      "description": "Interact with 50+ different DeFi protocols across multiple chains",
      "category": "defi",
      "rarity": "legendary",
      "points": 5000,
      "scoreBonus": 500,
      "requirements": {
        "uniqueProtocols": 50,
        "minimumChains": 3,
        "minimumVolume": "100000"
      },
      "icon": "https://cdn.onzks.com/achievements/defi-pioneer.png",
      "status": "active",
      "earnedBy": 47,
      "createdAt": "2024-01-01T00:00:00Z"
    },
    {
      "id": "whale-trader",
      "title": "Whale Trader",
      "description": "Execute a single transaction worth over $1M",
      "category": "trading",
      "rarity": "epic",
      "points": 3000,
      "scoreBonus": 300,
      "requirements": {
        "singleTransactionValue": "1000000"
      },
      "icon": "https://cdn.onzks.com/achievements/whale-trader.png",
      "status": "active",
      "earnedBy": 123,
      "createdAt": "2024-01-01T00:00:00Z"
    },
    {
      "id": "governance-guru",
      "title": "Governance Guru",
      "description": "Vote on 100+ DAO proposals",
      "category": "governance",
      "rarity": "rare",
      "points": 2000,
      "scoreBonus": 200,
      "requirements": {
        "proposalsVoted": 100,
        "minimumDaos": 5
      },
      "icon": "https://cdn.onzks.com/achievements/governance-guru.png",
      "status": "active",
      "earnedBy": 456,
      "createdAt": "2024-01-01T00:00:00Z"
    }
  ],
  "pagination": {
    "total": 127,
    "limit": 50,
    "offset": 0,
    "hasMore": true
  }
}

async function displayAchievementGallery() {
  const { achievements } = await listAchievements({ status: 'active' });

  // Group by category
  const byCategory = achievements.reduce((acc, achievement) => {
    if (!acc[achievement.category]) {
      acc[achievement.category] = [];
    }
    acc[achievement.category].push(achievement);
    return acc;
  }, {});

  // Render gallery
  Object.entries(byCategory).forEach(([category, items]) => {
    console.log(`\n${category.toUpperCase()}:`);
    items.forEach(achievement => {
      console.log(`  ${achievement.title} - ${achievement.points} points`);
    });
  });
}

async function getAchievementsByRarity(rarity) {
  const { achievements } = await listAchievements({ rarity });

  console.log(`${rarity.toUpperCase()} Achievements:`);
  achievements.forEach(achievement => {
    const percentage = (achievement.earnedBy / 125847 * 100).toFixed(2);
    console.log(`${achievement.title} - Earned by ${percentage}% of users`);
  });

  return achievements;
}

// Get legendary achievements
await getAchievementsByRarity('legendary');

async function getNewAchievements() {
  const { achievements } = await listAchievements({ status: 'active' });

  // Sort by creation date
  const recent = achievements
    .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
    .slice(0, 10);

  console.log('Recently Added Achievements:');
  recent.forEach(achievement => {
    console.log(`${achievement.title} - Added ${new Date(achievement.createdAt).toLocaleDateString()}`);
  });

  return recent;
}

async function getPaginatedAchievements(page = 1, pageSize = 20) {
  const offset = (page - 1) * pageSize;

  const data = await listAchievements({
    limit: pageSize,
    offset
  });

  return {
    achievements: data.achievements,
    currentPage: page,
    totalPages: Math.ceil(data.pagination.total / pageSize),
    hasNext: data.pagination.hasMore,
    hasPrevious: page > 1
  };
}

// Load first page
const page1 = await getPaginatedAchievements(1, 20);

let achievementCache = null;
let cacheTimestamp = null;
const CACHE_TTL = 60 * 60 * 1000; // 1 hour

async function getCachedAchievements(filters = {}) {
  const cacheKey = JSON.stringify(filters);

  if (achievementCache && cacheTimestamp) {
    if (Date.now() - cacheTimestamp < CACHE_TTL) {
      return achievementCache;
    }
  }

  const data = await listAchievements(filters);
  achievementCache = data;
  cacheTimestamp = Date.now();

  return data;
}

function groupAchievementsByCategory(achievements) {
  return achievements.reduce((groups, achievement) => {
    const category = achievement.category;
    if (!groups[category]) {
      groups[category] = {
        name: category,
        achievements: [],
        totalPoints: 0
      };
    }
    groups[category].achievements.push(achievement);
    groups[category].totalPoints += achievement.points;
    return groups;
  }, {});
}

const rarityOrder = {
  'common': 1,
  'uncommon': 2,
  'rare': 3,
  'epic': 4,
  'legendary': 5
};

function sortByDifficulty(achievements) {
  return achievements.sort((a, b) => {
    return rarityOrder[a.rarity] - rarityOrder[b.rarity];
  });
}

function calculateCompletionRates(achievements, totalUsers = 125847) {
  return achievements.map(achievement => ({
    ...achievement,
    completionRate: (achievement.earnedBy / totalUsers * 100).toFixed(2),
    rarity: achievement.earnedBy < 100 ? 'ultra-rare' :
            achievement.earnedBy < 1000 ? 'very-rare' :
            achievement.earnedBy < 10000 ? 'rare' : 'common'
  }));
}