@anonympins/fingerprint 0.5.2 → 0.5.5

package/src/js/pow.solver.js

@@ -9,6 +9,15 @@
 
 'use strict';
 
+function secureRandom() {
+    if (typeof window !== 'undefined' && (window.crypto || window.msCrypto)) {
+        const array = new Uint32Array(1);
+        (window.crypto || window.msCrypto).getRandomValues(array);
+        return array[0] / 0x100000000;
+    }
+    return Math.random();
+}
+
 function cyrb53(str, seed = 0) {
     const safeStr = (typeof str === 'string' ? str : String(str || '')).slice(0, 10000);
     let h1 = 0xdeadbeef ^ seed,
@@ -269,15 +278,17 @@ export async function solveCpuTarget(message, target) {
  */
 export async function solveMemory(seed, difficulty) {
     const wasmModule = typeof window !== 'undefined' ? (window.wasmModule || (window.ClientLibrary && window.ClientLibrary.wasmModule)) : null;
+    let solution;
+    let useWasm = false;
     if (wasmModule && typeof wasmModule._solve_memory_challenge === 'function') {
         const encoder = new TextEncoder();
         const seedBytes = encoder.encode(seed);
         const ptr = wasmModule._malloc(seedBytes.length + 1);
         wasmModule.HEAPU8.set(seedBytes, ptr);
         wasmModule.HEAPU8[ptr + seedBytes.length] = 0; // Null-terminator
-        const solution = wasmModule._solve_memory_challenge(ptr, difficulty);
+        solution = wasmModule._solve_memory_challenge(ptr, difficulty);
         wasmModule._free(ptr);
-        return solution;
+        useWasm = true;
     }
 
     const size = difficulty * 1024 * 1024;
@@ -325,19 +336,21 @@ export async function solveMemory(seed, difficulty) {
     }
     const merkleRoot = tree[tree.length - 1][0];
 
-    function readBuffer(blocks, addr) {
-        const blockIdx = Math.floor(addr / 1024);
-        const elementIdx = addr % 1024;
-        return blocks[blockIdx][elementIdx];
-    }
+    if (!useWasm) {
+        function readBuffer(blocks, addr) {
+            const blockIdx = Math.floor(addr / 1024);
+            const elementIdx = addr % 1024;
+            return blocks[blockIdx][elementIdx];
+        }
 
-    const totalElements = numBlocks * 1024;
-    let addr = totalElements > 0 ? readBuffer(blocks, 0) % totalElements : 0;
-    let solution = 0;
-    const iterations = 1024;
-    for (let i = 0; i < iterations; i++) {
-        addr = readBuffer(blocks, addr) % totalElements;
-        solution ^= addr;
+        const totalElements = numBlocks * 1024;
+        let addr = totalElements > 0 ? readBuffer(blocks, 0) % totalElements : 0;
+        solution = 0;
+        const iterations = 1024;
+        for (let i = 0; i < iterations; i++) {
+            addr = readBuffer(blocks, addr) % totalElements;
+            solution ^= addr;
+        }
     }
 
     const challengedIndices = [];
@@ -430,6 +443,81 @@ export async function solveTsp(cities, targetMaxDistance) {
 
 // --- Fonctions d'optimisation copiées/adaptées de library.js pour le client ---
 
+function paretoDominates(objectivesA, objectivesB) {
+    let aIsBetterInOne = false;
+    for (let i = 0; i < objectivesA.length; i++) {
+        if (objectivesA[i] > objectivesB[i]) {
+            return false;
+        }
+        if (objectivesA[i] < objectivesB[i]) {
+            aIsBetterInOne = true;
+        }
+    }
+    return aIsBetterInOne;
+}
+
+function nonDominatedSort(populationWithObjectives) {
+    const fronts = [[]];
+    for (const p1 of populationWithObjectives) {
+        p1.dominationCount = 0;
+        p1.dominatedSolutions = [];
+        for (const p2 of populationWithObjectives) {
+            if (p1 === p2) continue;
+            if (paretoDominates(p1.objectives, p2.objectives)) {
+                p1.dominatedSolutions.push(p2);
+            } else if (paretoDominates(p2.objectives, p1.objectives)) {
+                p1.dominationCount++;
+            }
+        }
+        if (p1.dominationCount === 0) {
+            p1.rank = 0;
+            fronts[0].push(p1);
+        }
+    }
+
+    let i = 0;
+    while (fronts[i] && fronts[i].length > 0) {
+        const nextFront = [];
+        for (const p1 of fronts[i]) {
+            for (const p2 of p1.dominatedSolutions) {
+                p2.dominationCount--;
+                if (p2.dominationCount === 0) {
+                    p2.rank = i + 1;
+                    nextFront.push(p2);
+                }
+            }
+        }
+        i++;
+        if (nextFront.length > 0) {
+            fronts[i] = nextFront;
+        }
+    }
+    return fronts;
+}
+
+function calculateCrowdingDistance(front) {
+    if (front.length === 0) return;
+    front.forEach((p) => (p.crowdingDistance = 0));
+    const numObjectives = front[0].objectives.length;
+
+    for (let i = 0; i < numObjectives; i++) {
+        front.sort((a, b) => a.objectives[i] - b.objectives[i]);
+        const minObj = front[0].objectives[i];
+        const maxObj = front[front.length - 1].objectives[i];
+
+        front[0].crowdingDistance = Infinity;
+        front[front.length - 1].crowdingDistance = Infinity;
+
+        if (maxObj === minObj) continue;
+
+        for (let j = 1; j < front.length - 1; j++) {
+            front[j].crowdingDistance +=
+                (front[j + 1].objectives[i] - front[j - 1].objectives[i]) /
+                (maxObj - minObj);
+        }
+    }
+}
+
 const ClientOptimizers = {
     simulatedAnnealing(initialSolution, evaluator, neighbor, iterations, temp, cooling) {
         let currentSolution = initialSolution;
@@ -439,7 +527,7 @@ const ClientOptimizers = {
         for (let i = 0; i < iterations; i++) {
             const newSolution = neighbor(currentSolution);
             const newEnergy = evaluator(newSolution);
-            if (newEnergy < currentEnergy || Math.random() < Math.exp((currentEnergy - newEnergy) / temperature)) {
+            if (newEnergy < currentEnergy || secureRandom() < Math.exp((currentEnergy - newEnergy) / temperature)) {
                 currentSolution = newSolution;
                 currentEnergy = newEnergy;
             }
@@ -458,15 +546,245 @@ const ClientOptimizers = {
             population.sort((a, b) => a.fitness - b.fitness);
             const newPopulation = [population[0]]; // Elitism
             while (newPopulation.length < popSize) {
-                const p1 = population[Math.floor(Math.random() * (popSize / 2))];
-                const p2 = population[Math.floor(Math.random() * (popSize / 2))];
+                const p1 = population[Math.floor(secureRandom() * (popSize / 2))];
+                const p2 = population[Math.floor(secureRandom() * (popSize / 2))];
                 let offspring = crossover(p1.chromosome, p2.chromosome);
-                if (Math.random() < 0.1) offspring = mutate(offspring);
+                if (secureRandom() < 0.1) offspring = mutate(offspring);
                 newPopulation.push({ chromosome: offspring, fitness: fitness(offspring) });
             }
             population = newPopulation;
         }
         return population;
+    },
+
+    geneticAlgorithmMultiObjective(createIndividual, fitnessFunction, crossover, mutate, options = {}) {
+        const generations = options.generations || 50;
+        const populationSize = options.populationSize || 40;
+        const mutationRate = options.mutationRate !== undefined ? options.mutationRate : 0.1;
+
+        let population = Array.from({ length: populationSize }, () => ({
+            individual: createIndividual(),
+        }));
+        population.forEach((p) => (p.objectives = fitnessFunction(p.individual)));
+
+        for (let gen = 0; gen < generations; gen++) {
+            const offspring = [];
+            for (let i = 0; i < populationSize; i++) {
+                const parent1 = population[Math.floor(secureRandom() * population.length)];
+                const parent2 = population[Math.floor(secureRandom() * population.length)];
+                let childIndividual = crossover(parent1.individual, parent2.individual);
+                if (secureRandom() < mutationRate) {
+                    childIndividual = mutate(childIndividual);
+                }
+                const child = { individual: childIndividual };
+                child.objectives = fitnessFunction(child.individual);
+                offspring.push(child);
+            }
+
+            const combinedPopulation = [...population, ...offspring];
+            const fronts = nonDominatedSort(combinedPopulation);
+            const newPopulation = [];
+            for (const front of fronts) {
+                if (newPopulation.length + front.length <= populationSize) {
+                    newPopulation.push(...front);
+                } else {
+                    calculateCrowdingDistance(front);
+                    front.sort((a, b) => b.crowdingDistance - a.crowdingDistance);
+                    const remaining = populationSize - newPopulation.length;
+                    newPopulation.push(...front.slice(0, remaining));
+                    break;
+                }
+            }
+            population = newPopulation;
+        }
+
+        const finalFronts = nonDominatedSort(population);
+        const bestFront = finalFronts.length > 0 ? finalFronts[0] : [];
+        const uniqueSolutionsMap = new Map();
+        for (const p of bestFront) {
+            const key = JSON.stringify(p.objectives);
+            if (!uniqueSolutionsMap.has(key)) {
+                uniqueSolutionsMap.set(key, {
+                    solution: p.individual,
+                    objectives: p.objectives,
+                });
+            }
+        }
+        return Array.from(uniqueSolutionsMap.values());
+    },
+
+    'cpc.solve'(context, options = {}) {
+        const optimalBaseCommission = context.platformParams ? context.platformParams.optimalBaseCommission : 0.3;
+        const optimalBonusFactor = context.platformParams ? context.platformParams.optimalBonusFactor : 0.1;
+        const websiteQualityScore = ((context.website && context.website.relevanceScore) || 50) / 100;
+        const effectiveCommissionRate = Math.max(0, optimalBaseCommission - websiteQualityScore * optimalBonusFactor);
+
+        const advertiserDemand = (cpc) => {
+            if (cpc <= 0) return Infinity;
+            return (context.advertiser.credits || 0) / cpc;
+        };
+
+        const supply = context.estimatedImpressions || 1;
+        const competingAdsCount = context.competingAds ? context.competingAds.length : 0;
+        const competitionFactor = Math.min(2.5, 1 + competingAdsCount * 0.1);
+
+        const fitnessFunction = (cpcMultiplier) => {
+            const adjustedCPC = 1.0 * cpcMultiplier * competitionFactor;
+            if (adjustedCPC < 0.1) return [Infinity, Infinity, Infinity];
+
+            const demand = advertiserDemand(adjustedCPC);
+            const estimatedClicks = Math.min(demand, supply);
+            const platformRevenue = estimatedClicks * adjustedCPC * effectiveCommissionRate;
+            const advertiserValue = estimatedClicks;
+            const marketImbalance = Math.abs(demand - supply);
+
+            return [-platformRevenue, -advertiserValue, marketImbalance];
+        };
+
+        const createIndividual = () => 0.5 + secureRandom() * 4.5;
+        const crossover = (cpc1, cpc2) => (cpc1 + cpc2) / 2;
+        const mutate = (cpc) => Math.max(0.1, cpc + (secureRandom() - 0.5) * 0.5);
+
+        const gaOptions = {
+            generations: 50,
+            populationSize: 40,
+            ...options,
+        };
+
+        const paretoFront = ClientOptimizers.geneticAlgorithmMultiObjective(
+            createIndividual,
+            fitnessFunction,
+            crossover,
+            mutate,
+            gaOptions
+        );
+
+        return {
+            paretoFront: paretoFront.map((result) => {
+                const cpcMultiplier = result.solution;
+                const finalCpc = Math.max(0.1, 1.0 * cpcMultiplier * competitionFactor);
+                return {
+                    ...result,
+                    solution: finalCpc,
+                };
+            })
+        };
+    },
+
+    'fraud.solve'(context, options = {}) {
+        const legitimateClicks = context.legitimateClicks || [];
+        const fraudulentClicks = context.fraudulentClicks || [];
+
+        const fitnessFunction = (solution) => {
+            const [minTimeToClick, maxClickVariance, minMouseEntropy, minScrollEvents] = solution;
+            if (
+                minTimeToClick < 100 ||
+                minTimeToClick > 5000 ||
+                maxClickVariance < 1 ||
+                maxClickVariance > 10000 ||
+                minMouseEntropy < 0 ||
+                minMouseEntropy > 1 ||
+                minScrollEvents < 0
+            ) {
+                return [Infinity, Infinity];
+            }
+
+            const calculateClickVariance = (clicks) => {
+                if (!clicks || clicks.length < 2) return 0;
+                const meanX = clicks.reduce((sum, c) => sum + c.clickX, 0) / clicks.length;
+                const meanY = clicks.reduce((sum, c) => sum + c.clickY, 0) / clicks.length;
+                return clicks.reduce((sum, c) => sum + Math.pow(c.clickX - meanX, 2) + Math.pow(c.clickY - meanY, 2), 0) / clicks.length;
+            };
+
+            const getClicksByFingerprint = (clickData) => {
+                const grouped = {};
+                for (const click of clickData) {
+                    if (!grouped[click.fingerprint]) grouped[click.fingerprint] = [];
+                    grouped[click.fingerprint].push(click);
+                }
+                return grouped;
+            };
+
+            const legitimateGroups = getClicksByFingerprint(legitimateClicks);
+            const fraudulentGroups = getClicksByFingerprint(fraudulentClicks);
+
+            let truePositives = 0;
+            let falsePositives = 0;
+
+            for (const fingerprint in fraudulentGroups) {
+                const clicks = fraudulentGroups[fingerprint];
+                if (!clicks) continue;
+                const variance = calculateClickVariance(clicks);
+                const isTooFast = clicks.some((c) => c.timeToClick < minTimeToClick);
+                const isTooUniform = variance < maxClickVariance;
+                const hasLowEntropy = clicks.some((c) => c.mouseEntropy < minMouseEntropy);
+                const hasFewScrolls = clicks.some((c) => c.scrollEvents < minScrollEvents);
+
+                if (isTooFast || isTooUniform || hasLowEntropy || hasFewScrolls) {
+                    truePositives++;
+                }
+            }
+
+            for (const fingerprint in legitimateGroups) {
+                const clicks = legitimateGroups[fingerprint];
+                if (!clicks) continue;
+                const variance = calculateClickVariance(clicks);
+                if (
+                    clicks.some((c) => c.timeToClick < minTimeToClick || c.mouseEntropy < minMouseEntropy || c.scrollEvents < minScrollEvents) ||
+                    variance < maxClickVariance
+                ) {
+                    falsePositives++;
+                }
+            }
+
+            const totalFraudulent = Object.keys(fraudulentGroups).length || 1;
+            const totalLegitimate = Object.keys(legitimateGroups).length || 1;
+
+            const objective1 = 1 - truePositives / totalFraudulent;
+            const objective2 = falsePositives / totalLegitimate;
+
+            return [objective1, objective2];
+        };
+
+        const createIndividual = () => [
+            100 + secureRandom() * 4900,
+            1 + secureRandom() * 9999,
+            secureRandom() * 0.5,
+            Math.floor(secureRandom() * 10)
+        ];
+
+        const crossover = (s1, s2) => [
+            (s1[0] + s2[0]) / 2,
+            (s1[1] + s2[1]) / 2,
+            (s1[2] + s2[2]) / 2,
+            (s1[3] + s2[3]) / 2,
+        ];
+
+        const mutate = (solution) => {
+            const newSolution = [...solution];
+            const i = Math.floor(Math.random() * 4);
+            const mutationFactors = [500, 1000, 0.1, 2];
+            newSolution[i] += (secureRandom() - 0.5) * mutationFactors[i];
+            return newSolution;
+        };
+
+        const gaOptions = {
+            generations: 80,
+            populationSize: 60,
+            ...options,
+        };
+
+        const paretoFront = ClientOptimizers.geneticAlgorithmMultiObjective(
+            createIndividual,
+            fitnessFunction,
+            crossover,
+            mutate,
+            gaOptions
+        );
+
+        return {
+            paretoFront
+        };
     }
 };
 
@@ -500,16 +818,16 @@ async function solveUsefulWorkTask(task) {
                 };
                 const neighbor = (facilities) => {
                     const newFacilities = facilities.map((f) => ({ ...f }));
-                    const i = Math.floor(Math.random() * numFacilities);
-                    const moveX = (Math.random() - 0.5) * (bounds.maxX - bounds.minX) * 0.1;
-                    const moveY = (Math.random() - 0.5) * (bounds.maxY - bounds.minY) * 0.1;
+                    const i = Math.floor(secureRandom() * numFacilities);
+                    const moveX = (secureRandom() - 0.5) * (bounds.maxX - bounds.minX) * 0.1;
+                    const moveY = (secureRandom() - 0.5) * (bounds.maxY - bounds.minY) * 0.1;
                     newFacilities[i].x = Math.max(bounds.minX, Math.min(bounds.maxX, newFacilities[i].x + moveX));
                     newFacilities[i].y = Math.max(bounds.minY, Math.min(bounds.maxY, newFacilities[i].y + moveY));
                     return newFacilities;
                 };
                 const initialSolution = task.initialSolution || Array.from({ length: numFacilities }, () => ({
-                    x: bounds.minX + Math.random() * (bounds.maxX - bounds.minX),
-                    y: bounds.minY + Math.random() * (bounds.maxY - bounds.minY),
+                    x: bounds.minX + secureRandom() * (bounds.maxX - bounds.minX),
+                    y: bounds.minY + secureRandom() * (bounds.maxY - bounds.minY),
                 }));
                 return ClientOptimizers.simulatedAnnealing(initialSolution, evaluator, neighbor, task.iterations, task.payload.options.initialTemperature, task.payload.options.coolingRate);
             }
@@ -524,11 +842,11 @@ async function solveUsefulWorkTask(task) {
             };
             const neighbor = (path) => {
                 const newPath = [...path];
-                const [i, j] = [Math.floor(Math.random() * path.length), Math.floor(Math.random() * path.length)];
+                const [i, j] = [Math.floor(secureRandom() * path.length), Math.floor(secureRandom() * path.length)];
                 [newPath[i], newPath[j]] = [newPath[j], newPath[i]];
                 return newPath;
             };
-            const initialSolution = task.initialSolution || Array.from({ length: cities.length }, (_, i) => i).sort(() => 0.5 - Math.random());
+            const initialSolution = task.initialSolution || Array.from({ length: cities.length }, (_, i) => i).sort(() => 0.5 - secureRandom());
             
             return ClientOptimizers.simulatedAnnealing(initialSolution, evaluator, neighbor, task.iterations, task.payload.options.initialTemperature, task.payload.options.coolingRate);
         }
@@ -544,9 +862,9 @@ async function solveUsefulWorkTask(task) {
                 if (vol > maxVolatility) return 1000 + (vol - maxVolatility);
                 return -ret;
             };
-            const createIndividual = () => Array.from({ length: assets.length }, Math.random);
+            const createIndividual = () => Array.from({ length: assets.length }, secureRandom);
             const crossover = (p1, p2) => p1.map((w, i) => (w + p2[i]) / 2);
-            const mutate = p => { const n = [...p], i = Math.floor(Math.random() * n.length); n[i] += (Math.random() - 0.5) * 0.2; return n.map(v => Math.max(0, v)); };
+            const mutate = p => { const n = [...p], i = Math.floor(secureRandom() * n.length); n[i] += (secureRandom() - 0.5) * 0.2; return n.map(v => Math.max(0, v)); };
             
             // Le client doit recréer la population si elle n'est pas fournie
             const initialPopulation = task.initialPopulation || Array.from({ length: task.payload.options.populationSize }, () => ({ chromosome: createIndividual(), fitness: 0 }));
@@ -598,8 +916,8 @@ export async function solveOptimizationTask(initialPopulation, generations) {
     const crossover = (p1, p2) => p1.map((w, i) => (w + p2[i]) / 2);
     const mutate = (p) => {
         const newP = [...p];
-        const i = Math.floor(Math.random() * newP.length);
-        newP[i] += (Math.random() - 0.5) * 0.2;
+        const i = Math.floor(secureRandom() * newP.length);
+        newP[i] += (secureRandom() - 0.5) * 0.2;
         return newP;
     };
 
@@ -611,10 +929,10 @@ export async function solveOptimizationTask(initialPopulation, generations) {
         const newPopulation = [...parents]; // Élitisme
 
         while (newPopulation.length < population.length) {
-            const parent1 = parents[Math.floor(Math.random() * parents.length)];
-            const parent2 = parents[Math.floor(Math.random() * parents.length)];
+            const parent1 = parents[Math.floor(secureRandom() * parents.length)];
+            const parent2 = parents[Math.floor(secureRandom() * parents.length)];
             let offspring = crossover(parent1.chromosome, parent2.chromosome);
-            if (Math.random() < 0.1) offspring = mutate(offspring);
+            if (secureRandom() < 0.1) offspring = mutate(offspring);
             // La fitness sera recalculée côté serveur pour la vérification.
             newPopulation.push({ chromosome: offspring, fitness: -1 });
         }

package/src/js/problem-manager.js

@@ -586,7 +586,7 @@ let managerPromise = null;
  * @returns {Promise<ProblemManager>} The singleton instance.
  */
 export function getProblemManager(options = {}, store) {
-    const defaultPath = join(__dirname, '..', '..', 'problems.config.json');
+    const defaultPath = join(__dirname, '..', '..', 'config', 'problems.config.json');
     const { configPath = defaultPath, config } = options;
 
     const hasConfigChanged = problemManagerInstance && (

package/src/js/redis-store.js

@@ -1,43 +1,115 @@
-/**
- * @file Creates a store adapter for ioredis.
- * This adapter handles the serialization and deserialization of complex objects,
- * including the conversion of Set objects to arrays for storage in Redis.
- */
-
-/**
- * Creates a store adapter for an ioredis client.
- * @param {import('ioredis').Redis} redisClient - An instance of the ioredis client.
- * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
- */
-export function createRedisStore(redisClient) {
-  return {
-    async get(key) {
-      const value = await redisClient.get(key);
-      if (!value) return null;
-      // Use a reviver to convert arrays back to Sets for specific keys like 'ips'.
-      return JSON.parse(value, (k, v) => {
-        if (k === 'ips' && Array.isArray(v)) {
-          return new Set(v);
-        }
-        return v;
-      });
-    },
-    async set(key, value, ttl) {
-      // Use a replacer to convert Set objects into arrays before serialization.
-      const stringValue = JSON.stringify(value, (k, v) => {
-        if (v instanceof Set) {
-          return Array.from(v);
-        }
-        return v;
-      });
-
-      if (ttl && ttl > 0) {
-        await redisClient.set(key, stringValue, 'EX', ttl);
-      } else {
-        await redisClient.set(key, stringValue);
-      }
-    },
-    async has(key) { return (await redisClient.exists(key)) === 1; },
-    async delete(key) { await redisClient.del(key); },
-  };
+/**
+ * @file Creates a store adapter for ioredis.
+ * This adapter handles the serialization and deserialization of complex objects,
+ * including the conversion of Set objects to arrays for storage in Redis.
+ */
+
+/**
+ * Creates a store adapter for an ioredis client.
+ * @param {import('ioredis').Redis} redisClient - An instance of the ioredis client.
+ * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
+ */
+export function createRedisStore(redisClient) {
+  const replacer = (k, v) => (v instanceof Set ? Array.from(v) : v);
+  const reviver = (k, v) => (k === 'ips' && Array.isArray(v) ? new Set(v) : v);
+
+  const localStore = new Map();
+  const localTimeouts = new Map();
+  let isDown = false;
+  let reconnecting = false;
+
+  const triggerFallback = () => {
+    if (!isDown) {
+      isDown = true;
+      attemptReconnection();
+    }
+  };
+
+  const attemptReconnection = () => {
+    if (reconnecting) return;
+    reconnecting = true;
+    const interval = setInterval(async () => {
+      try {
+        await redisClient.ping();
+        isDown = false;
+        reconnecting = false;
+        clearInterval(interval);
+      } catch (err) {
+        // Continue de tenter la reconnexion toutes les 5 secondes
+      }
+    }, 5000);
+    if (interval.unref) interval.unref();
+  };
+
+  const setLocal = (key, value, ttl) => {
+    localStore.set(key, value);
+    if (localTimeouts.has(key)) {
+      clearTimeout(localTimeouts.get(key));
+    }
+    if (ttl && ttl > 0) {
+      const timeout = setTimeout(() => {
+        localStore.delete(key);
+        localTimeouts.delete(key);
+      }, ttl * 1000);
+      if (timeout.unref) timeout.unref();
+      localTimeouts.set(key, timeout);
+    }
+  };
+
+  return {
+    async get(key) {
+      if (isDown) {
+        return localStore.get(key) || null;
+      }
+      try {
+        const value = await redisClient.get(key);
+        if (!value) return null;
+        return JSON.parse(value, reviver);
+      } catch (e) {
+        triggerFallback();
+        return localStore.get(key) || null;
+      }
+    },
+    async set(key, value, ttl) {
+      if (isDown) {
+        setLocal(key, value, ttl);
+        return;
+      }
+      try {
+        const stringValue = JSON.stringify(value, replacer);
+        if (ttl && ttl > 0) {
+          await redisClient.set(key, stringValue, 'EX', ttl);
+        } else {
+          await redisClient.set(key, stringValue);
+        }
+      } catch (e) {
+        triggerFallback();
+        setLocal(key, value, ttl);
+      }
+    },
+    async has(key) {
+      if (isDown) {
+        return localStore.has(key);
+      }
+      try {
+        return (await redisClient.exists(key)) === 1;
+      } catch (e) {
+        triggerFallback();
+        return localStore.has(key);
+      }
+    },
+    async delete(key) {
+      if (localTimeouts.has(key)) {
+        clearTimeout(localTimeouts.get(key));
+        localTimeouts.delete(key);
+      }
+      localStore.delete(key);
+      if (isDown) return;
+      try {
+        await redisClient.del(key);
+      } catch (e) {
+        triggerFallback();
+      }
+    },
+  };
 }