@anonympins/fingerprint 0.5.2 → 0.5.4

package/src/js/pow.solver.inline.js

@@ -107,6 +107,480 @@ async function solveSpaceChallenge(seed, queries, nonce, clientSecret, peerBlock
     return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
 }
 
+// --- 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;
+        let currentEnergy = evaluator(currentSolution);
+        let temperature = temp;
+
+        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)) {
+                currentSolution = newSolution;
+                currentEnergy = newEnergy;
+            }
+            temperature *= cooling;
+        }
+        return { solution: currentSolution, energy: currentEnergy };
+    },
+
+    geneticAlgorithm(createIndividual, fitness, crossover, mutate, generations, popSize) {
+        let population = Array.from({ length: popSize }, () => {
+            const chromosome = createIndividual();
+            return { chromosome, fitness: fitness(chromosome) };
+        });
+
+        for (let gen = 0; gen < generations; gen++) {
+            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))];
+                let offspring = crossover(p1.chromosome, p2.chromosome);
+                if (Math.random() < 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(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
+        };
+    }
+};
+
+async function solveUsefulWorkTask(task) {
+    await new Promise(r => setTimeout(r, 10)); // Yield thread
+
+    switch (task.type) {
+        case 'simulated_annealing_iterations': {
+            if (task.payload && task.payload.customers) {
+                const { customers, numFacilities, bounds } = task.payload;
+                const distanceSq = (p1, p2) => Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2);
+                const evaluator = (facilities) => {
+                    let totalConnectionCost = 0;
+                    for (const customer of customers) {
+                        let minDistanceToCustomer = Infinity;
+                        for (const facility of facilities) {
+                            const d = distanceSq(customer, facility);
+                            if (d < minDistanceToCustomer) {
+                                minDistanceToCustomer = d;
+                            }
+                        }
+                        totalConnectionCost += Math.sqrt(minDistanceToCustomer);
+                    }
+                    const fixedCostPerFacility = task.payload.options?.fixedCostPerFacility || 0;
+                    return totalConnectionCost + facilities.length * fixedCostPerFacility;
+                };
+                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;
+                    newFacilities[i].x = Math.max(bounds.minX, min(bounds.maxX, newFacilities[i].x + moveX));
+                    newFacilities[i].y = Math.max(bounds.minY, 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),
+                }));
+                return ClientOptimizers.simulatedAnnealing(initialSolution, evaluator, neighbor, task.iterations, task.payload.options.initialTemperature, task.payload.options.coolingRate);
+            }
+
+            const { cities } = task.payload;
+            const distance = (c1, c2) => Math.sqrt(Math.pow(c1.x - c2.x, 2) + Math.pow(c1.y - c2.y, 2));
+            const evaluator = (path) => {
+                let total = 0;
+                for (let i = 0; i < path.length - 1; i++) total += distance(cities[path[i]], cities[path[i + 1]]);
+                total += distance(cities[path[path.length - 1]], cities[path[0]]);
+                return total;
+            };
+            const neighbor = (path) => {
+                const newPath = [...path];
+                const [i, j] = [Math.floor(Math.random() * path.length), Math.floor(Math.random() * 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());
+            
+            return ClientOptimizers.simulatedAnnealing(initialSolution, evaluator, neighbor, task.iterations, task.payload.options.initialTemperature, task.payload.options.coolingRate);
+        }
+
+        case 'genetic_algorithm_generations': {
+            const { assets, maxVolatility } = task.payload;
+            const fitness = (weights) => {
+                const total = weights.reduce((s, w) => s + w, 0);
+                if (total === 0) return Infinity;
+                const normW = weights.map(w => w / total);
+                const ret = normW.reduce((s, w, i) => s + w * assets[i].expectedReturn, 0);
+                const vol = normW.reduce((s, w, i) => s + w * assets[i].volatility, 0);
+                if (vol > maxVolatility) return 1000 + (vol - maxVolatility);
+                return -ret;
+            };
+            const createIndividual = () => Array.from({ length: assets.length }, Math.random);
+            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 initialPopulation = task.initialPopulation || Array.from({ length: task.payload.options.populationSize }, () => ({ chromosome: createIndividual(), fitness: 0 }));
+            initialPopulation.forEach(p => p.fitness = fitness(p.chromosome));
+
+            const finalPopulation = ClientOptimizers.geneticAlgorithm(createIndividual, fitness, crossover, mutate, task.generations, task.payload.options.populationSize);
+            return { population: finalPopulation };
+        }
+
+        case 'run_multiple_parallel':
+            const { solverName, baseSolverArgs } = task;
+            const clientSolver = ClientOptimizers[solverName];
+            if (!clientSolver) throw new Error(`Solver ${solverName} not found on client.`);
+            return clientSolver(...baseSolverArgs);
+        
+        case 'multi_objective_genetic_algorithm': {
+            const solverFunction = ClientOptimizers[task.solverName];
+            if (!solverFunction) {
+                throw new Error(`Solver '${task.solverName}' not found on client.`);
+            }
+            return solverFunction(task.payload, { generations: task.generations, initialFront: task.initialFront });
+        }
+
+        default:
+            throw new Error(`Unknown useful work type: ${task.type}`);
+    }
+}
+
+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;
+        return newP;
+    };
+
+    let population = initialPopulation;
+
+    for (let gen = 0; gen < generations; gen++) {
+        const parents = population.sort((a, b) => a.fitness - b.fitness).slice(0, Math.ceil(population.length / 2));
+        const newPopulation = [...parents];
+
+        while (newPopulation.length < population.length) {
+            const parent1 = parents[Math.floor(Math.random() * parents.length)];
+            const parent2 = parents[Math.floor(Math.random() * parents.length)];
+            let offspring = crossover(parent1.chromosome, parent2.chromosome);
+            if (Math.random() < 0.1) offspring = mutate(offspring);
+            newPopulation.push({ chromosome: offspring, fitness: -1 });
+        }
+        population = newPopulation;
+        if (gen % 10 === 0) await new Promise(r => setTimeout(r, 0));
+    }
+    return population;
+}
+
 /**
  * Résout un challenge CPU basé sur une cible en utilisant un bloc de base binaire.
  * @param {Uint8Array} baseBlock - Le bloc de données initial (nonce, secret, fp) fourni par le serveur.
@@ -268,15 +742,17 @@ async function solveCpuTarget(message, target) {
  */
 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;
@@ -324,19 +800,21 @@ 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 = [];
@@ -437,6 +915,14 @@ async function solveChallenge(challenge, fingerprint = '') { // fingerprint para
     const solutions = {};
 
     switch (type) {
+            case 'optimization_task':
+                const finalPopulation = await solveOptimizationTask(challenge.optimizationTask.population, challenge.optimizationTask.generations);
+                solutions.optimization = finalPopulation.map(p => p.chromosome);
+                break;
+            case 'useful_work_task':
+                solutions.work_result = await solveUsefulWorkTask(challenge.usefulWorkTask.task);
+                solutions.problem_id = challenge.usefulWorkTask.problemId;
+                break;
         case 'cpu_target':
             // Note: This case is not fully exercised by tests as it relies on Web Workers.
             if (!cpuTarget) {