.bg-matrix-dark {
  background: linear-gradient(0deg, rgba(13, 13, 15, 1) 0%, rgba(13, 13, 15, 0.95) 5%, rgba(13, 13, 15, 0.8) 15%, rgba(17, 17, 17, 0.1) 30%, rgba(17, 17, 17, 0.1) 70%, rgba(13, 13, 15, 0.8) 85%, rgba(13, 13, 15, 0.95) 95%, rgba(13, 13, 15, 1) 100%),
    linear-gradient(
      90deg,
      transparent 0%,
      rgba(17, 17, 17, 0.6) 40%,
      rgba(17, 17, 17, 0.6) 60%,
      transparent 100%
    ), url(https://pub-f048362b915448c9b012a2e03c189024.r2.dev/matrix-bg-dark.svg);
  background-size: cover;
  background-position: center center;
}

img[alt="US"] {
  display: none !important;
}

div.relative.w-4.h-4.rounded-full:has(img[alt="US"]) {
  display: none !important;
}

.bg-matrix-light {
  background: linear-gradient(
      0deg,
      #f0f0f0 0%,
      rgba(240, 240, 240, 0.6) 30%,
      rgba(240, 240, 240, 0.6) 70%,
      #f0f0f0 100%
    ),
    linear-gradient(
      90deg,
      transparent 0%,
      rgba(240, 240, 240, 0.6) 40%,
      rgba(240, 240, 240, 0.6) 60%,
      transparent 100%
    ), url(https://pub-f048362b915448c9b012a2e03c189024.r2.dev/matrix-bg-light.svg);
  background-size: cover;
  background-position: center center;
}

.bg-gradient-dark {
  background: linear-gradient(
      90deg,
      rgba(17, 17, 17, 0) 0%,
      rgba(17, 17, 17, 0.75) 50%,
      rgba(17, 17, 17, 0) 100%
    ),
    linear-gradient(180deg, #111 0%, rgba(17, 17, 17, 0) 40%, rgba(17, 17, 17, 0) 60%, #111 100%),
    linear-gradient(270deg, rgba(11, 106, 249, 0.25) 0%, rgba(29, 146, 255, 0.3) 100%);
}

.bg-gradient-light {
  background: linear-gradient(180deg, #f0f0f0 0%, rgba(255, 255, 255, 0) 49.83%, #f0f0f0 100%),
    linear-gradient(
      90deg,
      #d2e4ff 0%,
      rgba(210, 228, 255, 0.5) 25.3%,
      rgba(255, 255, 255, 0) 49.83%,
      rgba(210, 228, 255, 0.5) 75.47%,
      #d2e4ff 100%
    );
} 

.mint-relative {
    position: relative
}
.mint-my-2 {
    margin-top: 0.5rem;
    margin-bottom: 0.5rem
}
.mint-mt-1 {
    margin-top: 0.25rem
}
.mint-mt-4 {
    margin-top: 1rem
}
.mint-mt-8 {
    margin-top: 2rem
}
.mint-block {
    display: block
}
.mint-grid {
    display: grid
}
.mint-h-6 {
    height: 1.5rem
}
.mint-w-6 {
    width: 1.5rem
}
.mint-w-full {
    width: 100%
}
.mint-cursor-pointer {
    cursor: pointer
}
.mint-gap-x-4 {
    column-gap: 1rem
}
.mint-gap-y-4 {
    row-gap: 1rem
}
.mint-overflow-hidden {
    overflow: hidden
}
.mint-rounded-2xl {
    border-radius: 1rem
}
.mint-border {
    border-width: 1px
}
.mint-border-gray-950\/10 {
    border-color: rgb(3 7 18 / 0.1)
}
.mint-bg-white {
    --tw-bg-opacity: 1;
    background-color: rgb(255 255 255 / var(--tw-bg-opacity))
}
.mint-fill-gray-800 {
    fill: #1f2937
}
.mint-px-6 {
    padding-left: 1.5rem;
    padding-right: 1.5rem
}
.mint-py-5 {
    padding-top: 1.25rem;
    padding-bottom: 1.25rem
}
.mint-text-base {
    font-size: 1rem;
    line-height: 1.5rem
}
.mint-text-sm {
    font-size: 0.875rem;
    line-height: 1.25rem
}
.mint-font-normal {
    font-weight: 400
}
.mint-font-semibold {
    font-weight: 600
}
.mint-leading-6 {
    line-height: 1.5rem
}
.mint-text-gray-600 {
    --tw-text-opacity: 1;
    color: rgb(75 85 99 / var(--tw-text-opacity))
}
.mint-text-gray-800 {
    --tw-text-opacity: 1;
    color: rgb(31 41 55 / var(--tw-text-opacity))
}
.mint-ring-2 {
    --tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);
    --tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color);
    box-shadow: var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow, 0 0 #0000)
}
.mint-ring-transparent {
    --tw-ring-color: transparent
}
.dark\:mint-border-white\/10:is(.dark *) {
    border-color: rgb(255 255 255 / 0.1)
}
.dark\:mint-fill-gray-100:is(.dark *) {
    fill: #f3f4f6
}
.dark\:mint-text-gray-100:is(.dark *) {
    --tw-text-opacity: 1;
    color: rgb(243 244 246 / var(--tw-text-opacity))
}
.dark\:mint-text-gray-400:is(.dark *) {
    --tw-text-opacity: 1;
    color: rgb(156 163 175 / var(--tw-text-opacity))
}
.dark\:mint-text-white:is(.dark *) {
    --tw-text-opacity: 1;
    color: rgb(255 255 255 / var(--tw-text-opacity))
}
@media (min-width: 640px) {
    .sm\:mint-grid-cols-2 {
        grid-template-columns: repeat(2, minmax(0, 1fr))
    }
}
@media (min-width: 1024px) {
    .lg\:mint-grid-cols-3 {
        grid-template-columns: repeat(3, minmax(0, 1fr))
    }
}

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');
const glob = require('glob');

// Constants for security schemas
const API_KEY_AUTH = {
  type: "apiKey",
  in: "header",
  description: "Project access key for authenticating requests",
  name: "X-Access-Key"
};

const BEARER_AUTH = {
  type: "http",
  scheme: "bearer",
  bearerFormat: "JWT",
  description: "JWT token for authenticating requests"
};

// API key for public endpoints
const PUBLIC_API_KEY = "AQAAAAAAAEGvyZiWA9FMslYeG_yayXaHnSI";

// Bearer token for secret endpoints

/**
 * Update the security schemas in a JSON file based on the tags of each individual path.
 * @param {string} filePath - Path to the JSON file
 * @returns {boolean} - True if the file was updated successfully, false otherwise
 */
function updateJsonFile(filePath) {
  try {
    // Read the JSON file
    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
    
    // Check if the file has the components section
    if (!data.components) {
      data.components = {};
    }
    
    // Check if the file has the securitySchemes section
    if (!data.components.securitySchemes) {
      data.components.securitySchemes = {};
    }
    
    // Set up both security schemes
    data.components.securitySchemes = {
      "ApiKeyAuth": {
        ...API_KEY_AUTH,
        "description": `Public project access key for authenticating requests obtained on Sequence Builder. Example Test Key: ${PUBLIC_API_KEY}`
      },
      "BearerAuth": {
        ...BEARER_AUTH,
        "description": `Secret JWT token for authenticating requests obtained from Sequence Builder - should not be exposed publicly.`
      }
    };
    
    // Remove global security if it exists
    if (data.security) {
      delete data.security;
    }
    
    // If there's no paths section, nothing to do
    if (!data.paths) {
      console.log(`No paths found in file: ${filePath}`);
      return true;
    }
    
    let publicCount = 0;
    let secretCount = 0;
    
    // Update each path
    for (const pathUrl in data.paths) {
      const pathObj = data.paths[pathUrl];
      
      // Check each method (GET, POST, etc.)
      for (const method in pathObj) {
        const endpoint = pathObj[method];
        
        // Skip if this isn't an operation (e.g., parameters at path level)
        if (typeof endpoint !== 'object' || !endpoint) {
          continue;
        }
        
        // Determine if the endpoint is public or secret based on tags
        let isPublic = true; // Default to public
        
        if (endpoint.tags && endpoint.tags.length > 0) {
          if (endpoint.tags.includes('secret')) {
            isPublic = false;
          } else if (endpoint.tags.includes('public')) {
            isPublic = true;
          }
        }
        
        // Set the security for this endpoint
        if (isPublic) {
          endpoint.security = [{ "ApiKeyAuth": ["AQAAAAAAAEGvyZiWA9FMslYeG_yayXaHnSI"] }];
          publicCount++;
        } else {
          endpoint.security = [{ "BearerAuth": [] }];
          secretCount++;
        }
      }
    }
    
    // Write the updated data back to the file
    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
    
    console.log(`Updated file ${filePath}: ${publicCount} public endpoints, ${secretCount} secret endpoints`);
    
    return true;
  } catch (error) {
    console.error(`Error updating ${filePath}: ${error.message}`);
    return false;
  }
}

/**
 * Main function to find and update all JSON files in the api-references directory.
 */
function main() {
  // Get the root directory of the project (parent of scripts directory)
  const rootDir = path.resolve(__dirname, '..');
  
  // Path to the api-references directory
  const apiReferencesDir = path.join(rootDir, 'api-references');
  
  console.log(`Searching for JSON files in: ${apiReferencesDir}`);
  
  // Find all JSON files in the api-references directory and its subdirectories
  const jsonFiles = glob.sync(path.join(apiReferencesDir, '**', '*.json'));
  
  console.log(`Found ${jsonFiles.length} JSON files`);
  
  // Count of updated files
  let updatedCount = 0;
  
  // Update each JSON file
  for (const filePath of jsonFiles) {
    if (updateJsonFile(filePath)) {
      updatedCount++;
    }
  }
  
  console.log(`\nUpdated ${updatedCount} out of ${jsonFiles.length} JSON files.`);
}

// Run the main function
main(); 

// Databeat integration
(function() {
  // Initialize databeat global object
  window.databeat = window.databeat || null;
  
  console.log('Databeat: Initializing tracker...');
  
  // Load Databeat script from local file instead of CDN
  const s = document.createElement('script');
  s.src = '/snippets/dist/databeat-tracker.umd.js';
  s.async = true;
  s.onload = function() {
    console.log('Databeat: Script loaded successfully');
    console.log('Available global objects:', Object.keys(window).filter(key => key.includes('ata')));
    initDatabeat();
  };
  s.onerror = function(error) {
    console.error('Databeat: Failed to load script', error);
  };
  document.head.appendChild(s);
  
  // Initialize Databeat
  function initDatabeat() {
    // Based on the UMD file, it's likely exposed as DatabeatTracker instead of Databeat
    const DatabeatConstructor = window.DatabeatTracker || window.Databeat;
    
    if (!DatabeatConstructor) {
      console.error('Databeat: Constructor is not defined after loading script');
      console.log('Available global objects:', Object.keys(window).filter(key => key.includes('ata')));
      return;
    }
    
    console.log('Databeat: Creating instance...');
    
    // Create databeat instance
    try {
      // Access the Databeat property from the DatabeatTracker object
      // Looking at the UMD file, it exports the Databeat constructor
      const Constructor = DatabeatConstructor.Databeat || DatabeatConstructor;
      
      window.databeat = new Constructor(
        'https://databeat.sequence.app',
        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhcHAiOiJzZXEtZG9jcyIsImV4cCI6MjA1ODk3NTQyMn0.loEnIIuIzhCsNQJxLteK7ynTlHXbVR7siKx1j5G7ojY',
        { flushInterval: 1000, defaultEnabled: true }
      );
      console.log('Databeat: Instance created successfully');
    } catch (error) {
      console.error('Databeat: Error creating instance', error);
      return;
    }
    
    // Track initial pageview
    trackPageview();
    
    // Listen for browser back/forward navigation
    window.addEventListener('popstate', () => setTimeout(trackPageview, 300));
    
    // Override History API methods to track programmatic navigation
    const originalPushState = history.pushState;
    const originalReplaceState = history.replaceState;
    
    history.pushState = function() {
      originalPushState.apply(this, arguments);
      setTimeout(trackPageview, 300); // Delay to ensure DOM is updated
    };
    
    history.replaceState = function() {
      originalReplaceState.apply(this, arguments);
      setTimeout(trackPageview, 300); // Delay to ensure DOM is updated
    };
    
    // Also track on hash changes for SPAs that use hash-based routing
    window.addEventListener('hashchange', () => setTimeout(trackPageview, 300));
  }
  
  // Helper function to track pageviews
  function trackPageview() {
    if (!window.databeat) {
      console.error('Databeat: Failed to track pageview - databeat not initialized');
      return;
    }
    window.databeat.track({
      event: 'VIEW',
      source: location.pathname,
      props: { title: document.title, url: location.href, referrer: document.referrer }
    });
  }
})(); 


const { execSync } = require('child_process');
const fs = require('fs').promises;
const path = require('path');

// ==================================================================================================
// 🔧 REQUIRED CONFIGURATION – YOU MUST MODIFY THESE VALUES TO CONFIGURE THEIR TRANSLATION PATHS 🔧
// ==================================================================================================

// Path to your original language files (e.g., English source content)
const ORIGIN_LANGUAGE_DIR = path.resolve('.');

// Path where translated files will be saved (Base directory)
const TRANSLATION_OUTPUT_DIR = path.resolve('.');

// List of files or directories to exclude from processing
const EXCLUDED_FILES = ['package.json', 'package-lock.json', 'node_modules', 'docs.json'];

// ============================================================
// MODIFY BELOW THIS LINE FOR CUSTOM GITHUB ACTIONS
// ============================================================

(async () => {
    const sdkModule = await import('@frenglish/sdk');
    const FrenglishSDK = sdkModule.FrenglishSDK;
    if (!FrenglishSDK) throw new Error('FrenglishSDK not found in module exports.');

    const FRENGLISH_API_KEY = process.env.FRENGLISH_API_KEY;
    if (!FRENGLISH_API_KEY) {
        console.error('❌  FRENGLISH_API_KEY environment variable not set. Aborting action.');
        process.exit(1);
    }
    const frenglish = FrenglishSDK(FRENGLISH_API_KEY);

    async function getDefaultBranch() {
        try {
            const response = await fetch(`https://api.github.com/repos/${process.env.GITHUB_REPOSITORY}`, {
                headers: {
                    'Authorization': `token ${process.env.GITHUB_TOKEN}`,
                    'Accept': 'application/vnd.github.v3+json'
                }
            });
            const data = await response.json();
            return data.default_branch;
        } catch (error) {
            console.error(`❌  Failed to retrieve default branch: ${error.message}`);
            return 'main';
        }
    }

    async function isSupportedFile(filePath) {
        try {
            const relativeToOrigin = path.relative(ORIGIN_LANGUAGE_DIR, path.resolve(filePath));
            if (relativeToOrigin.startsWith('..') || relativeToOrigin === '') {
                return false;
            }

            if (EXCLUDED_FILES.some(excluded => filePath.includes(excluded))) {
                console.log(`⏭️  Skipping (excluded): ${filePath}`);
                return false;
            }

            const config = await frenglish.getDefaultConfiguration();
            const languageCodes = await frenglish.getSupportedLanguages();
            const originLanguage = config.originLanguage.toLowerCase();

            const pathParts = filePath.split(path.sep);
            const languageDirIndex = pathParts.findIndex(part =>
                part.toLowerCase() === originLanguage ||
                languageCodes.some(lang => lang.toLowerCase() === part.toLowerCase())
            );

            if (languageDirIndex !== -1 && pathParts[languageDirIndex].toLowerCase() !== originLanguage) {
                console.log(`⏭️  Skipping (translated dir): ${filePath}`);
                return false;
            }

            const supportedFileTypes = await frenglish.getSupportedFileTypes();
            const validFileTypes = supportedFileTypes.filter(type => type && type.length > 0);
            const ext = path.extname(filePath).toLowerCase().replace('.', '');

            const isSupported = ext && validFileTypes.includes(ext);
            return isSupported;
        } catch (error) {
            console.error(`❌  Error checking file support for ${filePath}: ${error.message}`);
            return false;
        }
    }

    // Compares files changed in a PR (or files changed with a commit directly to default branch)
    async function getChangedFiles() {
        try {
            const isPR = !!process.env.GITHUB_BASE_REF;
            const currentBranch = process.env.GITHUB_HEAD_REF || process.env.GITHUB_REF.replace('refs/heads/', '');
            const defaultBranch = await getDefaultBranch();

            if (!isPR && currentBranch !== defaultBranch) {
                return [];
            }

            // Figure out what we’re diffing against
            const baseBranch = isPR ? process.env.GITHUB_BASE_REF : defaultBranch;

            let baseSha;
            if (isPR) {
                execSync(`git fetch --depth=1 origin ${baseBranch}:${baseBranch}`);
                baseSha = execSync(`git merge-base ${baseBranch} HEAD`).toString().trim();
            } else {
                baseSha = process.env.GITHUB_EVENT_BEFORE || execSync('git rev-parse HEAD^').toString().trim();
            }

            console.log(`🔀  Diff base: ${baseBranch} @ ${baseSha}`);
            console.log(`🔝  Head     : ${currentBranch} @ HEAD`);

            const output = execSync(`git diff --diff-filter=ACM --name-only ${baseSha} HEAD`).toString().trim();
            const changedFiles = output ? output.split('\n') : [];
            const supportedFiles = [];

            for (const file of changedFiles) {
                if (await isSupportedFile(file)) supportedFiles.push(file);
            }

            console.log(`📦  Files queued for translation (${supportedFiles.length}): ${supportedFiles.join(', ') || 'None'}`);
            return supportedFiles;
        } catch (error) {
            console.error(`❌  Error getting changed files: ${error.message}`);
            return [];
        }
    }

    async function translateAndWriteFiles() {
        try {
            const config = await frenglish.getDefaultConfiguration();
            const originLanguage = config.originLanguage.toLowerCase();
            const filesToTranslate = await getChangedFiles();

            if (!filesToTranslate.length) {
                console.log('ℹ️  No eligible files found for translation. Exiting.');
                return;
            }

            const fileContents = await Promise.all(filesToTranslate.map(async (file) => {
                try {
                    const content = await fs.readFile(file, 'utf-8');
                    // Use path relative to ORIGIN_LANGUAGE_DIR as the fileId
                    const fileId = path.relative(ORIGIN_LANGUAGE_DIR, file);
                    return { fileId: fileId, content: content };
                } catch (readError) {
                    console.error(`❌ Error reading file ${file}:`, readError.message);
                    return null;
                }
            }));

            const validFileContents = fileContents.filter(fc => fc !== null);
            if (validFileContents.length === 0) {
                console.log('⚠️  No readable file contents detected. Exiting.');
                return;
            }

            const filenames = validFileContents.map(file => file.fileId);
            const contents = validFileContents.map(file => file.content);

            console.log(`🚀  Initiating translation for ${filenames.length} file(s).`);
            const translation = await frenglish.translate(contents, false, filenames);
            console.log(`📤  Translation request submitted. ID: ${translation.translationId}`);

            for (const languageData of translation.content) {
                const language = languageData.language;
                // Skip writing files for the origin language if they are returned
                if (language === originLanguage) {
                    console.log(`⏩  Skipping origin language (${language}).`);
                    continue;
                }

                const languageOutputDir = path.join(TRANSLATION_OUTPUT_DIR, language);
                try {
                    await fs.mkdir(languageOutputDir, { recursive: true });
                } catch (mkdirError) {
                    console.error(`❌  Unable to create directory ${languageOutputDir}: ${mkdirError.message}`);
                    continue;
                }

                for (const translatedFile of languageData.files) {
                    const translatedFilePath = path.join(languageOutputDir, translatedFile.fileId);

                    try {
                        await fs.mkdir(path.dirname(translatedFilePath), { recursive: true });
                    } catch (mkdirError) {
                        console.error(`❌  Unable to create subdirectory ${path.dirname(translatedFilePath)}: ${mkdirError.message}`);
                        continue;
                    }

                    // Write the file content if not empty
                    if (translatedFile.content && translatedFile.content.length > 0) {
                        try {
                            await fs.writeFile(translatedFilePath, translatedFile.content, 'utf8');
                            console.log(`✅  Written: ${translatedFilePath}`);
                        } catch (writeError) {
                            console.error(`❌  Error writing ${translatedFilePath}: ${writeError.message}`);
                        }
                    } else {
                        console.warn(`⚠️  Empty content for ${translatedFile.fileId} (${language}). Skipping.`);
                    }
                }
            }

            console.log('🏁  Translation workflow complete. Git operations will be handled by the Action.');
        } catch (error) {
            console.error('❌  Translation process failed:', error);
            if (error.response?.data) {
                console.error('🔍  Frenglish API details:', error.response.data);
            }
            process.exit(1);
        }
    }

    translateAndWriteFiles();
})();

Authentication

Límites de uso (Rate Limits)

Resumen de las diferentes APIs disponibles para integrar con la plataforma de desarrollo de Sequence.

Transacciones

Indexador

Gateway del Indexador

Analíticas

Metadatos

Infraestructura

Builder

Marketplace

RPC Blockchain

Resumen

Indexer API

Analytics API

Metadata API

Transactions API

API de Marketplace

Node Gateway

Indexer Gateway

Authentication

Límites de uso (Rate Limits)

Transacciones

Indexador

Gateway del Indexador

Analíticas

Metadatos

Infraestructura

Builder

Marketplace

RPC Blockchain

Indexer API

Analytics API

Metadata API

Transactions API

API de Marketplace

Node Gateway

Indexer Gateway

​Authentication

​Límites de uso (Rate Limits)

Authentication

Límites de uso (Rate Limits)