Is Spotify Ad Blocker - Blockify safe?

// bk_modules.js: A background alarm fires every 60 minutes (or on startup)
// and fetches the 'switches' config from blockify.b-cdn.net.
// The server response directly controls:
//   - forced_exclusions: domains exempt from ad blocking (merged into user's exception list)
//   - custom_dynamic_dnr: arbitrary declarativeNetRequest rules injected into the extension
//   - rules_json: enables/disables the main ad blocking ruleset
//   - cssjs, spotify_injection, yt_injection, hulu_injection: per-feature toggles
//
// There is no UI notification when any of these values change.
async function setSwitches() {
  const response = await fetch('https://blockify.b-cdn.net/switches190.json', { cache: 'no-cache' });
  const config = await response.json();
  // Store config and apply immediately:
  chrome.storage.local.set({ switches: config });
  self.switches = config;
  applyForcedExclusions(config.forced_exclusions); // updates your exception list
  applyCustomDNRRules(config.custom_dynamic_dnr);  // injects server-side network rules
  setAdBlockingToggles(config);                    // enables/disables features
}

// The custom_dynamic_dnr array from the server is passed directly to
// chrome.declarativeNetRequest.updateDynamicRules().
// Rules can have any action (allow, block, redirect, modifyHeaders) and
// any condition (urlFilter, resourceTypes, domains, etc.).
// There is no validation of rule contents before they are applied.
async function applyServerDNRRules(rules) {
  const existing = await chrome.declarativeNetRequest.getDynamicRules();
  const existingIds = new Set(existing.map(r => r.id));
  const newRules = rules.filter(r => !existingIds.has(r.id)); // skip duplicates by ID
  if (newRules.length > 0) {
    await chrome.declarativeNetRequest.updateDynamicRules({ addRules: newRules });
  }
}

// The extension creates a PageStatistics tracker with three hardcoded values:
// - API key: "Iengi0kiEi3eicae"
// - Encryption key: "ej0hie1MThoo8Ri2"  ← anyone with the source can decrypt traffic
// - Server: "https://insights.getblockify.com"
self.stat = new PageStatistics("Iengi0kiEi3eicae", "ej0hie1MThoo8Ri2", "https://insights.getblockify.com");
stat.init(); // registers all navigation event listeners

// Called by chrome.tabs.onUpdated for every completed navigation.
// Assembles a visit record with: the visited URL, referrer, persistent UUID,
// OS name/version, browser name/version, timezone, user-agent, and timestamp.
// The record is AES-128-GCM encrypted (key hardcoded above) and POSTed to /process.
async function reportAction(url, referrer) {
  const payload = [{
    fileDate: new Date().toISOString(),       // ISO timestamp
    deviceTimestamp: Date.now(),              // ms precision
    userId: this.data.uuid,                  // persistent UUID from chrome.storage.sync
    referrerUrl: referrer,                   // previous page URL
    targetUrl: url,                          // visited page URL
    requestType: 'GET',
    scheme: new URL(url).protocol,
    host: new URL(url).hostname,
    user_agent: navigator.userAgent,
    accept_language: navigator.language,
    os_name: getOSName(),
    browser_name: getBrowserName(),
    os_version: getOSVersion(),
    browser_version: getBrowserVersion(),
    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone
  }];
  const encrypted = await encryptData(JSON.stringify(payload));
  await fetch('https://insights.getblockify.com/process', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json;charset=utf-8' },
    body: JSON.stringify({ eventType: 1, request: { enRequest: encrypted } })
  });
}

chrome.runtime.onStartup.addListener(() => {
  setupAlarm();
  updateYouTubeBlockingScript();
  //createContextMenu();
  //updateRules();

});

chrome.alarms.onAlarm.addListener((alarm) => {
  if (alarm.name == 'getSwitches') {
    setSwitches();
  }
});

setSwitches();
setupAlarm();
//check_opt_eli();
updateYouTubeBlockingScript();
//createContextMenu();
//updateRules();

async function setSwitches() {
  var url = 'https://blockify.b-cdn.net/switches190.json';

  fetch(url, { cache: 'no-cache' })
    .then(response => {
      // Check if the response is ok (status in the range 200-299)
      if (!response.ok) {
        console.error(response); //throw new Error(`HTTP error! Status: ${response.status}`);
      }
      // Parse the JSON data
      return response.json();
    })
    .then(data => {
      // Handle successful data retrieval
      if (data && data["spotify_injection"] && data["cssjs"]) {
        chrome.storage.local.set({ "switches": data });
        self.switches = JSON.parse(JSON.stringify(data));
        recheck_exclusions();
        cssjs_set();
        check_ruleset();
        updateYouTubeBlockingScript();
      }
    })
    .catch(error => {
      // Handle any errors that occurred during fetch
      console.error('Fetch error:', error.message);
      reportErrorToSentry(6, false, error, "bk_modules.js", "setSwitches");
    });
};

function recheck_customDNR() {
  if (self.switches && self.switches["custom_dynamic_dnr"] && typeof self.switches["custom_dynamic_dnr"] == 'object' && self.switches["custom_dynamic_dnr"] != "" && self.switches["custom_dynamic_dnr"].length > 0) {
    //valid
    var rules = self.switches["custom_dynamic_dnr"];
    addRulesIfNotPresent(rules);
  }
};

async function addRulesIfNotPresent(rulesToAdd) {
  try {
    // 1. Retrieve the existing dynamic rules
    var existingRules = await chrome.declarativeNetRequest.getDynamicRules();
    var existingRuleIds = new Set(existingRules.map(rule => rule.id));

    // 2. Filter out any rules that have the same ID as an existing rule
    var filteredRules = rulesToAdd.filter(rule => !existingRuleIds.has(rule.id));

    // 3. If there are new, non-duplicate rules, add them
    if (filteredRules.length > 0) {
      await chrome.declarativeNetRequest.updateDynamicRules({ addRules: filteredRules });
    }
  }
  catch (err) {
    console.error('Error updating dynamic rules:', err);
  }
};

async function setupAlarm() {
  var existingAlarm = await chrome.alarms.get('getSwitches');
  if (!existingAlarm) {
    // Create an alarm that fires every 60 minutes
    chrome.alarms.create('getSwitches', {
      periodInMinutes: 60
    }); // Repeats every 60 minutes
  }
};