How to Add Time-Limited Functionality to Your JavaScript Code

/**
 * Date-based expiration check
 * @param {Date} expirationDate - The date when the code should expire
 * @returns {boolean} - True if code is still valid, false if expired
 */
function isCodeValid(expirationDate) {
  const currentDate = new Date();
  return currentDate < expirationDate;
}

// Usage example
const EXPIRATION_DATE = new Date('2025-12-31T23:59:59');

function initializeApp() {
  if (isCodeValid(EXPIRATION_DATE)) {
    // Code is still valid, initialize normally
    console.log('Application initialized successfully!');
    enableFeatures();
  } else {
    // Code has expired, disable functionality
    console.log('This version has expired. Please upgrade to continue using this feature.');
    showExpiredMessage();
  }
}

// Initialize the application
initializeApp();

/**
 * Usage-based expiration using localStorage
 * @param {number} maxUsage - Maximum number of allowed uses
 * @returns {boolean} - True if usage limit not exceeded, false otherwise
 */
function checkUsageLimit(maxUsage) {
  const storageKey = 'app_usage_count';
  
  // Get current usage count from storage
  let usageCount = parseInt(localStorage.getItem(storageKey) || '0');
  
  // Increment usage count
  usageCount++;
  
  // Store updated count
  localStorage.setItem(storageKey, usageCount.toString());
  
  // Check if usage is within limits
  return usageCount <= maxUsage;
}

// Usage example
const MAX_USAGE = 10; // Allow 10 uses

function initializeApp() {
  if (checkUsageLimit(MAX_USAGE)) {
    // Usage limit not exceeded
    const remainingUses = MAX_USAGE - parseInt(localStorage.getItem('app_usage_count'));
    console.log(`Application initialized successfully! Remaining uses: ${remainingUses}`);
    enableFeatures();
  } else {
    // Usage limit exceeded
    console.log('Usage limit exceeded. Please purchase the full version to continue.');
    showUpgradeMessage();
  }
}

// Initialize the application
initializeApp();

// Instead of a simple date comparison, make the expiration check more complex
function verifyLicense() {
  // Split the expiration timestamp into multiple parts
  const p1 = 1735;  // These values combine to form the expiration timestamp
  const p2 = 686;   // (Unix timestamp for December 31, 2025: 1735686000)
  const p3 = 000;
  
  // Create a decoy date to confuse analysis
  const decoyDate = new Date('2026-06-30T23:59:59');
  
  // Complex calculation to get the actual expiration timestamp
  const expirationTimestamp = (p1 * 1000000) + (p2 * 1000) + p3;
  
  // Get current timestamp with an obscured method
  const now = () => { 
    return new Date().getTime(); 
  };
  
  // Multiple checks to make static analysis harder
  if (decoyDate.getFullYear() !== 2026) return false;
  if (now() > expirationTimestamp) return false;
  if (Math.floor(now() / 1000) > Math.floor(expirationTimestamp / 1000)) return false;
  
  return true;
}

// Additional layer: Hide the usage of the verification function
const features = {
  initialize: function() {
    // Multiple function calls that include the verification
    this.setupEnvironment();
    this.checkCompatibility();
    this.prepareResources();
  },
  
  setupEnvironment: function() {
    // Normal setup code
    console.log('Setting up environment...');
  },
  
  checkCompatibility: function() {
    // Hide license check in a seemingly unrelated function
    console.log('Checking compatibility...');
    if (!verifyLicense()) {
      // Hide the true reason for disabling
      throw new Error('Compatibility check failed: Environment not supported');
    }
  },
  
  prepareResources: function() {
    console.log('Preparing resources...');
    // Normal initialization continues
  }
};

// Start application
features.initialize();

/**
 * Fetches time from multiple sources to prevent clock manipulation
 * @returns {Promise} - Promise resolving to the verified timestamp
 */
async function getVerifiedTime() {
  const sources = [
    'https://worldtimeapi.org/api/ip',
    'https://timeapi.io/api/Time/current/zone?timeZone=UTC',
    // Add more time API sources as backup
  ];
  
  const localTime = new Date().getTime();
  let timeResults = [localTime]; // Include local time as fallback
  
  // Fetch time from external sources
  const fetchPromises = sources.map(async (source) => {
    try {
      const response = await fetch(source);
      const data = await response.json();
      
      // Extract timestamp - adjust based on API response format
      let timestamp;
      if (source.includes('worldtimeapi')) {
        timestamp = new Date(data.utc_datetime).getTime();
      } else if (source.includes('timeapi')) {
        timestamp = new Date(data.dateTime).getTime();
      }
      
      return timestamp;
    } catch (error) {
      console.warn(`Failed to fetch time from ${source}`, error);
      return null;
    }
  });
  
  // Collect all successful time results
  const results = await Promise.allSettled(fetchPromises);
  results.forEach(result => {
    if (result.status === 'fulfilled' && result.value) {
      timeResults.push(result.value);
    }
  });
  
  // Use median time to avoid outliers
  timeResults.sort((a, b) => a - b);
  const medianTime = timeResults[Math.floor(timeResults.length / 2)];
  
  return medianTime;
}

/**
 * Checks if license is valid using verified time
 * @param {number} expirationTimestamp - Expiration timestamp
 * @returns {Promise} - Promise resolving to license validity
 */
async function verifyLicenseWithTime(expirationTimestamp) {
  try {
    const verifiedTime = await getVerifiedTime();
    return verifiedTime < expirationTimestamp;
  } catch (error) {
    console.error('Error during time verification:', error);
    // Fallback to local time if all time sources fail
    return new Date().getTime() < expirationTimestamp;
  }
}

// Usage example
const EXPIRATION_TIMESTAMP = 1735686000000; // Dec 31, 2025

async function initializeApp() {
  const isValid = await verifyLicenseWithTime(EXPIRATION_TIMESTAMP);
  
  if (isValid) {
    console.log('License valid, initializing application...');
    enableFeatures();
  } else {
    console.log('License expired, showing upgrade prompt...');
    showUpgradeMessage();
  }
}

// Initialize with time verification
initializeApp();

/**
 * Server-side license verification
 * @param {string} licenseKey - User's license key
 * @returns {Promise