@anonympins/fingerprint 0.5.2 → 0.5.4

package/src/js/pow.solver.js

@@ -269,15 +269,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 +327,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 +434,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;
@@ -467,6 +546,236 @@ const ClientOptimizers = {
             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(Math.random() * population.length)];
+                const parent2 = population[Math.floor(Math.random() * population.length)];
+                let childIndividual = crossover(parent1.individual, parent2.individual);
+                if (Math.random() < 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 + Math.random() * 4.5;
+        const crossover = (cpc1, cpc2) => (cpc1 + cpc2) / 2;
+        const mutate = (cpc) => Math.max(0.1, cpc + (Math.random() - 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 + Math.random() * 4900,
+            1 + Math.random() * 9999,
+            Math.random() * 0.5,
+            Math.floor(Math.random() * 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] += (Math.random() - 0.5) * mutationFactors[i];
+            return newSolution;
+        };
+
+        const gaOptions = {
+            generations: 80,
+            populationSize: 60,
+            ...options,
+        };
+
+        const paretoFront = ClientOptimizers.geneticAlgorithmMultiObjective(
+            createIndividual,
+            fitnessFunction,
+            crossover,
+            mutate,
+            gaOptions
+        );
+
+        return {
+            paretoFront
+        };
     }
 };
 

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();
+      }
+    },
+  };
 }

package/src/js/tests/dns-circuit-breaker.test.js

@@ -0,0 +1,55 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import { __internal } from '../fingerprint.js';
+
+const { dnsCircuitBreaker, recordDnsSuccess, recordDnsFailure, canAttemptDns } = __internal;
+
+describe('DNS Circuit Breaker', () => {
+    beforeEach(() => {
+        dnsCircuitBreaker.state = 'CLOSED';
+        dnsCircuitBreaker.failureCount = 0;
+        dnsCircuitBreaker.lastStateChange = 0;
+        dnsCircuitBreaker.threshold = 5;
+        dnsCircuitBreaker.cooldownMs = 1000; // 1s de cooldown pour accélérer le test unitaire
+    });
+
+    it('devrait démarrer à l\'état CLOSED et autoriser les résolutions', () => {
+        expect(canAttemptDns()).toBe(true);
+        expect(dnsCircuitBreaker.state).toBe('CLOSED');
+    });
+
+    it('devrait s\'ouvrir après avoir atteint le seuil d\'échecs (5)', () => {
+        for (let i = 0; i < 4; i++) {
+            recordDnsFailure();
+            expect(canAttemptDns()).toBe(true);
+            expect(dnsCircuitBreaker.state).toBe('CLOSED');
+        }
+
+        recordDnsFailure();
+        expect(canAttemptDns()).toBe(false);
+        expect(dnsCircuitBreaker.state).toBe('OPEN');
+    });
+
+    it('devrait passer en HALF-OPEN après expiration du cooldown', async () => {
+        for (let i = 0; i < 5; i++) {
+            recordDnsFailure();
+        }
+        expect(canAttemptDns()).toBe(false);
+
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+
+        expect(canAttemptDns()).toBe(true);
+        expect(dnsCircuitBreaker.state).toBe('HALF-OPEN');
+    });
+
+    it('devrait se refermer (CLOSED) après un succès en HALF-OPEN', async () => {
+        for (let i = 0; i < 5; i++) {
+            recordDnsFailure();
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+        expect(canAttemptDns()).toBe(true); // Passage en HALF-OPEN
+
+        recordDnsSuccess();
+        expect(dnsCircuitBreaker.state).toBe('CLOSED');
+        expect(dnsCircuitBreaker.failureCount).toBe(0);
+    });
+});