#!/usr/bin/env node

/**
 * Token Terminal Marketing Data Script
 *
 * This script fetches all projects from the Token Terminal API and provides:
 * 1. Total count of projects
 * 2. Total count of projects in blockchain-l1 and blockchain-l2 market sectors
 * 3. List of all blockchains (L1 and L2)
 */

const fs = require("fs");
const path = require("path");

// Load environment variables from .env file
function loadEnvFile() {
  const envPath = path.join(__dirname, ".env");

  if (fs.existsSync(envPath)) {
    const envContent = fs.readFileSync(envPath, "utf8");

    // Parse .env file line by line
    envContent.split("\n").forEach((line) => {
      // Skip empty lines and comments
      line = line.trim();
      if (!line || line.startsWith("#")) return;

      // Parse KEY=VALUE format
      const equalIndex = line.indexOf("=");
      if (equalIndex > 0) {
        const key = line.substring(0, equalIndex).trim();
        const value = line.substring(equalIndex + 1).trim();

        // Remove quotes if present
        const cleanValue = value.replace(/^["']|["']$/g, "");

        // Set environment variable if not already set
        if (!process.env[key]) {
          process.env[key] = cleanValue;
        }
      }
    });

    console.log("✅ Loaded environment variables from .env file");
  } else {
    console.log("ℹ️  No .env file found, using system environment variables");
  }
}

async function fetchAllProjects() {
  const apiUrl = "https://api.tokenterminal.com/v2/projects";
  const apiKey = process.env.TOKEN_TERMINAL_API_KEY;

  if (!apiKey) {
    throw new Error("TOKEN_TERMINAL_API_KEY environment variable is required");
  }

  try {
    const response = await fetch(apiUrl, {
      method: "GET",
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json",
      },
    });

    if (!response.ok) {
      throw new Error(
        `HTTP error! status: ${response.status} - ${response.statusText}`
      );
    }

    const data = await response.json();
    return data.data;
  } catch (error) {
    console.error("Error fetching projects:", error);
    throw error;
  }
}

async function fetchMarketSectorData(marketSectorId) {
  const apiUrl = `https://api.tokenterminal.com/v2/market-sectors/${marketSectorId}`;
  const apiKey = process.env.TOKEN_TERMINAL_API_KEY;

  if (!apiKey) {
    throw new Error("TOKEN_TERMINAL_API_KEY environment variable is required");
  }

  try {
    const response = await fetch(apiUrl, {
      method: "GET",
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json",
      },
    });

    if (!response.ok) {
      throw new Error(
        `HTTP error! status: ${response.status} - ${response.statusText} for market sector: ${marketSectorId}`
      );
    }

    const data = await response.json();
    return data.data;
  } catch (error) {
    console.error(`Error fetching market sector ${marketSectorId}:`, error);
    throw error;
  }
}

async function fetchAllMarketSectors() {
  const apiUrl = "https://api.tokenterminal.com/v2/market-sectors";
  const apiKey = process.env.TOKEN_TERMINAL_API_KEY;

  if (!apiKey) {
    throw new Error("TOKEN_TERMINAL_API_KEY environment variable is required");
  }

  try {
    const response = await fetch(apiUrl, {
      method: "GET",
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json",
      },
    });

    if (!response.ok) {
      throw new Error(
        `HTTP error! status: ${response.status} - ${response.statusText}`
      );
    }

    const data = await response.json();
    return data.data;
  } catch (error) {
    console.error("Error fetching market sectors list:", error);
    throw error;
  }
}

async function fetchAllMetrics() {
  const apiUrl = "https://api.tokenterminal.com/v2/metrics";
  const apiKey = process.env.TOKEN_TERMINAL_API_KEY;

  if (!apiKey) {
    throw new Error("TOKEN_TERMINAL_API_KEY environment variable is required");
  }

  try {
    console.log("📊 Fetching all metrics...");
    const response = await fetch(apiUrl, {
      method: "GET",
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json",
      },
    });

    if (!response.ok) {
      throw new Error(
        `HTTP error! status: ${response.status} - ${response.statusText}`
      );
    }

    const data = await response.json();
    console.log(`✅ Retrieved ${data.data?.length || 0} metrics`);
    return data.data;
  } catch (error) {
    console.error("Error fetching metrics:", error);
    throw error;
  }
}

async function fetchBlockchainProjects() {
  console.log("🔗 Fetching blockchain market sectors...");

  try {
    // First, get all available market sectors to find the correct blockchain sector IDs
    console.log("🔍 Getting list of all market sectors...");
    const allMarketSectors = await fetchAllMarketSectors();

    // Successfully discovered market sectors structure

    // Find blockchain-related market sectors by name (since ID field might be different)
    const blockchainSectors = allMarketSectors.filter(
      (sector) =>
        sector.name &&
        (sector.name.toLowerCase().includes("blockchain") ||
          sector.name.toLowerCase().includes("l1") ||
          sector.name.toLowerCase().includes("l2"))
    );

    console.log("📋 Available blockchain-related market sectors:");
    blockchainSectors.forEach((sector) => {
      console.log(
        `  - ID: ${sector.market_sector_id || sector.id || "unknown"}: ${
          sector.name || "N/A"
        }`
      );
    });

    // Find L1 and L2 sector IDs by name
    const l1Sector = blockchainSectors.find(
      (s) =>
        s.name &&
        (s.name.toLowerCase().includes("l1") ||
          s.name.toLowerCase().includes("layer-1") ||
          s.name.toLowerCase().includes("(l1)"))
    );
    const l2Sector = blockchainSectors.find(
      (s) =>
        s.name &&
        (s.name.toLowerCase().includes("l2") ||
          s.name.toLowerCase().includes("layer-2") ||
          s.name.toLowerCase().includes("(l2)"))
    );

    if (!l1Sector || !l2Sector) {
      console.log("❌ Could not find L1/L2 market sectors. Available sectors:");
      allMarketSectors.forEach((sector) => {
        console.log(`  - ${sector.market_sector_id}: ${sector.name || "N/A"}`);
      });
      throw new Error("Could not find L1 or L2 blockchain market sectors");
    }

    // Get the correct ID field
    const l1Id = l1Sector.market_sector_id || l1Sector.id;
    const l2Id = l2Sector.market_sector_id || l2Sector.id;

    console.log(`✅ Using L1 sector: ${l1Id} (${l1Sector.name})`);
    console.log(`✅ Using L2 sector: ${l2Id} (${l2Sector.name})`);

    // Fetch both L1 and L2 blockchain market sectors
    const [l1Data, l2Data] = await Promise.all([
      fetchMarketSectorData(l1Id),
      fetchMarketSectorData(l2Id),
    ]);

    console.log(
      `✅ Found ${l1Data.projects?.length || 0} L1 blockchain projects`
    );
    console.log(
      `✅ Found ${l2Data.projects?.length || 0} L2 blockchain projects`
    );

    // Combine projects from both market sectors
    const blockchainProjects = [
      ...(l1Data.projects || []),
      ...(l2Data.projects || []),
    ];

    return {
      l1Projects: l1Data.projects || [],
      l2Projects: l2Data.projects || [],
      allBlockchainProjects: blockchainProjects,
      l1Metadata: l1Data,
      l2Metadata: l2Data,
      l1SectorId: l1Id,
      l2SectorId: l2Id,
    };
  } catch (error) {
    console.error("Error fetching blockchain market sectors:", error);
    throw error;
  }
}

function isBlockchainProject(project) {
  if (!project.market_sectors) {
    return false;
  }

  const marketSectorValues = Object.values(project.market_sectors);
  return marketSectorValues.some(
    (sector) => sector === "blockchain-l1" || sector === "blockchain-l2"
  );
}

function extractBlockchainsFromProjects(projects) {
  const blockchainSet = new Set();

  projects.forEach((project) => {
    // For market sector data, projects don't have 'chains' field
    // but the project_id IS the blockchain identifier
    if (project.chains && Array.isArray(project.chains)) {
      // If chains field exists (from /v2/projects endpoint)
      project.chains.forEach((chain) => blockchainSet.add(chain));
    } else if (project.project_id) {
      // If no chains field, use project_id as blockchain name (from market sectors)
      blockchainSet.add(project.project_id);
    }
  });

  return Array.from(blockchainSet).sort();
}

function analyzeMarketingData(allProjects, blockchainData, metricsData) {
  // Use the market sector data for blockchain projects
  const blockchainProjects = blockchainData.allBlockchainProjects;
  const allBlockchains = extractBlockchainsFromProjects(blockchainProjects);

  // Analyze metrics data
  const metricsAnalysis = metricsData
    ? {
        totalMetrics: metricsData.length,
        metricsByCategory: metricsData.reduce((acc, metric) => {
          const category = metric.category || "uncategorized";
          if (!acc[category]) {
            acc[category] = [];
          }
          acc[category].push(metric);
          return acc;
        }, {}),
        metricsList: metricsData.map((metric) => ({
          metric_id: metric.metric_id,
          name: metric.name,
          category: metric.category,
          description: metric.description,
          units: metric.units,
          is_standardized: metric.is_standardized || false,
        })),
      }
    : null;

  return {
    totalProjects: allProjects.length,
    blockchainProjectsCount: blockchainProjects.length,
    l1ProjectsCount: blockchainData.l1Projects.length,
    l2ProjectsCount: blockchainData.l2Projects.length,
    allBlockchains,
    blockchainProjects,
    l1Projects: blockchainData.l1Projects,
    l2Projects: blockchainData.l2Projects,
    metrics: metricsAnalysis,
  };
}

function displayResults(data) {
  console.log("\n🚀 Token Terminal Marketing Data Analysis");
  console.log("==========================================\n");

  console.log(`📊 Total Projects: ${data.totalProjects}`);
  console.log(
    `⛓️  Blockchain Projects (L1 & L2): ${data.blockchainProjectsCount}`
  );
  console.log(`  ├─ L1 Blockchains: ${data.l1ProjectsCount}`);
  console.log(`  └─ L2 Blockchains: ${data.l2ProjectsCount}`);
  console.log(`🔗 Total Unique Blockchains: ${data.allBlockchains.length}`);

  // Display metrics information
  if (data.metrics) {
    console.log(`📈 Total Available Metrics: ${data.metrics.totalMetrics}`);

    console.log("\n📊 Metrics by Category:");
    console.log("-----------------------");
    Object.entries(data.metrics.metricsByCategory).forEach(
      ([category, metrics]) => {
        console.log(
          `  📁 ${category.charAt(0).toUpperCase() + category.slice(1)}: ${
            metrics.length
          } metrics`
        );
      }
    );
  }
  console.log("");

  console.log("📋 All Blockchains (L1 & L2):");
  console.log("------------------------------");
  data.allBlockchains.forEach((blockchain, index) => {
    console.log(`${(index + 1).toString().padStart(2, " ")}. ${blockchain}`);
  });

  if (data.l1Projects.length > 0) {
    console.log("\n🟦 L1 Blockchain Projects:");
    console.log("---------------------------");
    data.l1Projects.forEach((project, index) => {
      console.log(
        `${(index + 1).toString().padStart(2, " ")}. ${project.name}`
      );
      console.log(`    ID: ${project.project_id}`);
      if (project.url) console.log(`    URL: ${project.url}`);
    });
  }

  if (data.l2Projects.length > 0) {
    console.log("\n🟩 L2 Blockchain Projects:");
    console.log("---------------------------");
    data.l2Projects.forEach((project, index) => {
      console.log(
        `${(index + 1).toString().padStart(2, " ")}. ${project.name}`
      );
      console.log(`    ID: ${project.project_id}`);
      if (project.url) console.log(`    URL: ${project.url}`);
    });
  }

  // Display detailed metrics information
  if (data.metrics && data.metrics.metricsByCategory) {
    console.log("\n📊 Available Metrics Details:");
    console.log("==============================");
    Object.entries(data.metrics.metricsByCategory).forEach(
      ([category, metrics]) => {
        console.log(`\n📁 ${category.toUpperCase()}:`);
        metrics.slice(0, 5).forEach((metric, index) => {
          // Show first 5 metrics per category
          console.log(
            `  ${(index + 1).toString().padStart(2, " ")}. ${
              metric.name || metric.metric_id
            }`
          );
          if (metric.description) {
            console.log(
              `      ${metric.description.substring(0, 80)}${
                metric.description.length > 80 ? "..." : ""
              }`
            );
          }
        });
        if (metrics.length > 5) {
          console.log(`      ... and ${metrics.length - 5} more metrics`);
        }
      }
    );
  }
}

function saveToFile(data, filePath) {
  // Ensure directory exists
  const dir = path.dirname(filePath);
  if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir, { recursive: true });
  }

  // Write data to file
  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
  console.log(`💾 Data saved to: ${filePath}`);
}

function saveToMdxFile(data, filePath) {
  // Ensure directory exists
  const dir = path.dirname(filePath);
  if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir, { recursive: true });
  }

  // Create MDX content with exported JavaScript object
  const mdxContent = `export const marketData = ${JSON.stringify(
    data,
    null,
    2
  )};
`;

  // Write MDX data to file
  fs.writeFileSync(filePath, mdxContent, "utf8");
  console.log(`💾 Data saved to: ${filePath}`);
}

async function main() {
  try {
    // Load environment variables from .env file first
    loadEnvFile();

    console.log("🔄 Fetching data from Token Terminal API...");

    // Fetch all data in parallel: projects, blockchain market sectors, and metrics
    const [allProjects, blockchainData, metricsData] = await Promise.all([
      fetchAllProjects(),
      fetchBlockchainProjects(),
      fetchAllMetrics(),
    ]);

    console.log(`✅ Retrieved ${allProjects.length} total projects`);

    const marketingData = analyzeMarketingData(
      allProjects,
      blockchainData,
      metricsData
    );

    displayResults(marketingData);

    // Create comprehensive data export
    const exportData = {
      summary: {
        totalProjects: marketingData.totalProjects,
        blockchainProjectsCount: marketingData.blockchainProjectsCount,
        l1ProjectsCount: marketingData.l1ProjectsCount,
        l2ProjectsCount: marketingData.l2ProjectsCount,
        blockchainsList: marketingData.allBlockchains,
        totalBlockchains: marketingData.allBlockchains.length,
        totalMetrics: marketingData.metrics?.totalMetrics || 0,
        metricsCategories: marketingData.metrics
          ? Object.keys(marketingData.metrics.metricsByCategory)
          : [],
        timestamp: new Date().toISOString(),
      },
      l1Projects: marketingData.l1Projects.map((project) => ({
        name: project.name,
        project_id: project.project_id,
        url: project.url || null,
        type: "L1",
      })),
      l2Projects: marketingData.l2Projects.map((project) => ({
        name: project.name,
        project_id: project.project_id,
        url: project.url || null,
        type: "L2",
      })),
      allBlockchainProjects: marketingData.blockchainProjects.map(
        (project) => ({
          name: project.name,
          project_id: project.project_id,
          url: project.url || null,
          type: marketingData.l1Projects.some(
            (l1) => l1.project_id === project.project_id
          )
            ? "L1"
            : "L2",
        })
      ),
      allBlockchains: marketingData.allBlockchains,
      metrics: marketingData.metrics?.metricsList || [],
      metricsByCategory: marketingData.metrics?.metricsByCategory || {},
      metadata: {
        script_version: "2.1.0",
        api_endpoints: [
          "https://api.tokenterminal.com/v2/projects",
          "https://api.tokenterminal.com/v2/market-sectors/blockchain-l1",
          "https://api.tokenterminal.com/v2/market-sectors/blockchain-l2",
          "https://api.tokenterminal.com/v2/metrics",
        ],
        generated_at: new Date().toISOString(),
        total_l1_projects: marketingData.l1ProjectsCount,
        total_l2_projects: marketingData.l2ProjectsCount,
        total_l1_l2_projects: marketingData.blockchainProjectsCount,
        unique_blockchains_count: marketingData.allBlockchains.length,
        total_metrics: marketingData.metrics?.totalMetrics || 0,
        metrics_categories_count: marketingData.metrics
          ? Object.keys(marketingData.metrics.metricsByCategory).length
          : 0,
      },
    };

    // Save to snippets directory as MDX
    const outputPath = "../snippets/marketData.mdx";
    saveToMdxFile(exportData, outputPath);

    console.log("\n📄 Summary JSON:");
    console.log("================");
    console.log(JSON.stringify(exportData.summary, null, 2));

    console.log("\n✅ Marketing data analysis complete!");
    console.log("📁 Full data exported to: snippets/marketData.mdx");
  } catch (error) {
    console.error("❌ Script failed:", error);
    process.exit(1);
  }
}

// Check if script is being run directly
if (require.main === module) {
  main();
}

module.exports = {
  fetchAllProjects,
  fetchAllMarketSectors,
  fetchMarketSectorData,
  fetchBlockchainProjects,
  fetchAllMetrics,
  analyzeMarketingData,
};


Analyze top market sectors with dashboards and direct project comparisons

Market sectors

Token Terminal Docs

Token Terminal is a full stack onchain data platform focused on standardizing financial and alternative data for the most widely used blockchains and decentralized applications.

Introduction

We process and store over a petabyte of transaction-level onchain data every day directly from the source, to deliver accurate, auditable metrics you can trust.

Our data approach

Contact us directly, get your project listed, follow us and schedule a demo.

Contact

Frequently asked questions about Token Terminal.

General FAQ

Explore curated dashboards to discover insights and build your own

Discover

Explore all projects in a customizable data table

Projects

Understand every metric with clear definitions and project-specific context

Metrics

Create custom dashboards with charts, datasets, and text to track onchain activity

Dashboards

Create no-code custom charts with Token Terminal’s standardized data

Charts

Create custom datasets from ready-made templates

Datasets

Access Token Terminal's data in Google Sheets and Microsoft Excel

Access Token Terminal's data in Google Sheets

Google Sheets

Access Token Terminal's data in Microsoft Excel

Microsoft Excel

Syntax

Get access to Token Terminal's data via our API

Recommendations on how to best use the API

Best practices

Get direct access to high-fidelity blockchain and application-level data.