@anonympins/fingerprint 0.5.1 → 0.5.4

package/src/js/pow.solver.js

@@ -10,10 +10,11 @@
 'use strict';
 
 function cyrb53(str, seed = 0) {
+    const safeStr = (typeof str === 'string' ? str : String(str || '')).slice(0, 10000);
     let h1 = 0xdeadbeef ^ seed,
         h2 = 0x41c6ce57 ^ seed;
-    for (let i = 0, ch; i < str.length; i++) {
-        ch = str.charCodeAt(i);
+    for (let i = 0, ch; i < safeStr.length; i++) {
+        ch = safeStr.charCodeAt(i);
         h1 = Math.imul(h1 ^ ch, 2654435761);
         h2 = Math.imul(h2 ^ ch, 1597334677);
     }
@@ -143,6 +144,53 @@ export async function solveCpuTargetInline(baseBlock, target, progressCallback)
         return solution;
     }
 
+        // Try Web Worker execution first if supported and not blocked by CSP
+        if (typeof window !== 'undefined' && typeof Worker !== 'undefined') {
+            try {
+                return await new Promise((resolve, reject) => {
+                    const workerCode = `
+                        self.onmessage = async (e) => {
+                            const { baseBlock, target } = e.data;
+                            const cpuTarget = BigInt(target);
+                            const encoder = new TextEncoder();
+                            let cpuSolution = 0;
+                            while (true) {
+                                const solutionBytes = encoder.encode(String(cpuSolution));
+                                const finalBlock = new Uint8Array(baseBlock.length + solutionBytes.length);
+                                finalBlock.set(baseBlock);
+                                finalBlock.set(solutionBytes, baseBlock.length);
+                                const buf = await crypto.subtle.digest("SHA-256", finalBlock);
+                                const hashHex = Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
+                                if (BigInt('0x' + hashHex) < cpuTarget) break;
+                                cpuSolution++;
+                                if (cpuSolution % 25000 === 0) {
+                                    self.postMessage({ type: 'progress', solution: cpuSolution });
+                                }
+                            }
+                            self.postMessage({ type: 'success', solution: cpuSolution });
+                        };
+                    `;
+                    const blob = new Blob([workerCode], { type: 'application/javascript' });
+                    const worker = new Worker(URL.createObjectURL(blob));
+                    worker.onmessage = (event) => {
+                        if (event.data.type === 'progress') {
+                            if (progressCallback) progressCallback(event.data.solution);
+                        } else if (event.data.type === 'success') {
+                            resolve(event.data.solution);
+                            worker.terminate();
+                        }
+                    };
+                    worker.onerror = (err) => {
+                        worker.terminate();
+                        reject(err);
+                    };
+                    worker.postMessage({ baseBlock, target: cpuTarget.toString() });
+                });
+            } catch (workerError) {
+                console.warn("Web Worker creation failed (possibly due to CSP). Falling back to main thread with scheduler/setTimeout yielding.");
+            }
+        }
+
     let cpuSolution = 0;
 
     while (true) {
@@ -166,8 +214,12 @@ export async function solveCpuTargetInline(baseBlock, target, progressCallback)
         // --- FIN DES LOGS ---
         if (BigInt('0x' + hashHex) < cpuTarget) break;
         cpuSolution++;
-        if (cpuSolution % 100000 === 0) {
-            await new Promise(r => setTimeout(r, 0));
+            if (cpuSolution % 50000 === 0) {
+                if (typeof scheduler !== 'undefined' && typeof scheduler.yield === 'function') {
+                    await scheduler.yield();
+                } else {
+                    await new Promise(r => setTimeout(r, 0));
+                }
             if (progressCallback) progressCallback(cpuSolution);
         }
     }
@@ -216,43 +268,104 @@ export async function solveCpuTarget(message, target) {
  * @returns {Promise<number>} La solution (nombre entier).
  */
 export async function solveMemory(seed, difficulty) {
-    // On définit un seuil pour savoir quand faire une pause, afin de ne pas bloquer le thread UI.
-    const YIELD_THRESHOLD = 100000;
-    const size = difficulty * 1024 * 1024;
-    const buffer = new Uint32Array(size / 4);
-
     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 seedPtr = wasmModule._malloc(seed.length + 1);
-        for (let i = 0; i < seed.length; i++) {
-            wasmModule.HEAP8[seedPtr + i] = seed.charCodeAt(i);
+        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
+        solution = wasmModule._solve_memory_challenge(ptr, difficulty);
+        wasmModule._free(ptr);
+        useWasm = true;
+    }
+
+    const size = difficulty * 1024 * 1024;
+    const numBlocks = difficulty * 256;
+    if (numBlocks === 0) return { solution: 0, merkleRoot: '', proofs: {} };
+
+    async function hashBlock(block) {
+        const buf = await crypto.subtle.digest("SHA-256", block.buffer);
+        return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+
+    function hexToBytes(hex) {
+        const bytes = new Uint8Array(hex.length / 2);
+        for (let i = 0; i < hex.length; i += 2) {
+            bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
         }
-        wasmModule.HEAP8[seedPtr + seed.length] = 0;
-        const solution = wasmModule._solve_memory_challenge(seedPtr, difficulty);
-        wasmModule._free(seedPtr);
-        return solution;
+        return bytes;
+    }
+
+    const leaves = [];
+    const blocks = [];
+    for (let b = 0; b < numBlocks; b++) {
+        const block = new Uint32Array(1024);
+        let h = cyrb53(seed + ":" + b);
+        for (let i = 0; i < 1024; i++) {
+            block[i] = (h = Math.imul(h ^ i, 1597334677));
+        }
+        blocks.push(block);
+        leaves.push(await hashBlock(block));
+    }
+
+    const tree = [leaves];
+    while (tree[tree.length - 1].length > 1) {
+        const currentLayer = tree[tree.length - 1];
+        const nextLayer = [];
+        for (let i = 0; i < currentLayer.length; i += 2) {
+            const left = currentLayer[i];
+            const right = currentLayer[i + 1] || left;
+            const combined = hexToBytes(left + right);
+            const hashBuf = await crypto.subtle.digest("SHA-256", combined);
+            const hashHex = Array.from(new Uint8Array(hashBuf)).map(b => b.toString(16).padStart(2, '0')).join('');
+            nextLayer.push(hashHex);
+        }
+        tree.push(nextLayer);
     }
+    const merkleRoot = tree[tree.length - 1][0];
 
-    let h = new TextEncoder().encode(seed).reduce((acc, v) => acc + v, 0);
+    if (!useWasm) {
+        function readBuffer(blocks, addr) {
+            const blockIdx = Math.floor(addr / 1024);
+            const elementIdx = addr % 1024;
+            return blocks[blockIdx][elementIdx];
+        }
 
-    for (let i = 0; i < buffer.length; i++) {
-        buffer[i] = (h = Math.imul(h ^ i, 1597334677));
-        if (i % YIELD_THRESHOLD === 0) {
-            await new Promise(r => setTimeout(r, 0)); // Respiration pour ne pas geler l'UI
+        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;
         }
     }
 
-    let solution = 0;
-    const iterations = size / 16;
-    let addr = buffer.length > 0 ? buffer[0] % buffer.length : 0;
-    for (let i = 0; i < iterations; i++) {
-        addr = buffer[addr] % buffer.length;
-        solution ^= addr;
-        if (i % YIELD_THRESHOLD === 0) {
-            await new Promise(r => setTimeout(r, 0)); // Respiration pour ne pas geler l'UI
+    const challengedIndices = [];
+    let h_idx = cyrb53(seed + ":" + solution);
+    for (let i = 0; i < 4; i++) {
+        h_idx = Math.imul(h_idx ^ i, 1597334677);
+        challengedIndices.push(Math.abs(h_idx) % numBlocks);
+    }
+
+    const proofs = {};
+    for (const index of challengedIndices) {
+        const proof = [];
+        let idx = index;
+        for (let layer = 0; layer < tree.length - 1; layer++) {
+            const isRight = idx % 2 === 1;
+            const siblingIdx = isRight ? idx - 1 : idx + 1;
+            const sibling = tree[layer][siblingIdx] || tree[layer][idx];
+            proof.push(sibling);
+            idx = Math.floor(idx / 2);
         }
+        proofs[index] = proof;
     }
-    return solution;
+
+    return { solution, merkleRoot, proofs };
 }
 
 /**
@@ -321,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;
@@ -358,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
+        };
     }
 };
 
@@ -539,7 +957,11 @@ class ChallengeSolution {
         // Logique de formatage spécifique à chaque type de challenge
         if (this.type === 'cpu_mem' || this.type === 'cpu_mem_inline' || this.type === 'cpu_target') {
             Object.entries(this.rawSolution).forEach(([key, value]) => {
-                url.searchParams.set(`pow_solution_${key}`, String(value));
+                if (typeof value === 'object' && value !== null) {
+                    url.searchParams.set(`pow_solution_${key}`, JSON.stringify(value));
+                } else {
+                    url.searchParams.set(`pow_solution_${key}`, String(value));
+                }
             });
         } else if (this.type === 'useful_work_task') {
             url.searchParams.set('pow_solution_work_result', JSON.stringify(this.rawSolution.work_result));

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 && (