@anonympins/fingerprint 0.5.0 → 0.5.2

package/src/js/gpu_pow.solver.js

@@ -0,0 +1,312 @@
+/**
+ * GPU Proof-of-Work Solver (WebGPU with WebGL2 Fallback)
+ * Forces massive parallel floats computation to exhaust CPU emulators (SwiftShader).
+ */
+export class GpuPowSolver {
+    /**
+     * Solve the GPU challenge.
+     * @param {string} seed - The hexadecimal/string challenge seed from the server.
+     * @param {number} iterations - Number of chaotic map iterations per thread.
+     * @returns {Promise<{solution: string, platform: string, duration: number}>}
+     */
+    static async solve(seed, iterations = 200000) {
+        const start = performance.now();
+        const numericSeed = this._hashSeedToFloat(seed);
+
+        try {
+            if (navigator.gpu) {
+                const result = await this._solveWebGPU(numericSeed, iterations);
+                return {
+                    solution: result,
+                    platform: 'webgpu',
+                    duration: performance.now() - start
+                };
+            }
+        } catch (e) {
+            console.warn('[GPU-PoW] WebGPU failed or disabled, falling back to WebGL2:', e);
+            // Fallthrough to WebGL2
+        }
+
+        // Fallback to WebGL2
+        try {
+            const result = await this._solveWebGL2(numericSeed, iterations);
+            return {
+                solution: result,
+                platform: 'webgl2',
+                duration: performance.now() - start
+            };
+        } catch (e) {
+            console.warn('[GPU-PoW] WebGL2 failed or disabled, falling back to WebGL1:', e);
+            // Fallthrough to WebGL1
+        }
+
+        // Fallback to WebGL1
+        try {
+            const result = await this._solveWebGL1(numericSeed, iterations);
+            return {
+                solution: result,
+                platform: 'webgl1',
+                duration: performance.now() - start
+            };
+        } catch (e) {
+            throw new Error(`[GPU-PoW] All GPU solvers (WebGPU, WebGL2, WebGL1) failed: ${e.message}`);
+        }
+    }
+
+    /**
+     * Verifies a GPU PoW solution.
+     * To prevent server-side DoS, it verifies a sample of the 64 channels.
+     * @param {string} seed - The challenge seed.
+     * @param {number} iterations - Number of iterations.
+     * @param {string} solution - The comma-separated solution string.
+     * @param {Array<number>} [sampleIndices=[0, 12, 35, 57]] - Indices to verify.
+     * @returns {boolean} True if the solution is valid.
+     */
+    static verify(seed, iterations, solution, sampleIndices = [0, 12, 35, 57]) {
+        if (!solution || typeof solution !== 'string') return false;
+        const values = solution.split(',');
+        if (values.length !== 64) return false;
+
+        const numericSeed = this._hashSeedToFloat(seed);
+        const r = 3.9999;
+
+        for (const idx of sampleIndices) {
+            if (idx < 0 || idx >= 64) return false;
+            let x = Math.fround(numericSeed + idx * 0.015);
+            const rFloat = Math.fround(r);
+            for (let i = 0; i < iterations; i++) {
+                x = Math.fround(rFloat * x * Math.fround(1.0 - x));
+            }
+            const clientVal = parseFloat(values[idx]);
+            if (isNaN(clientVal) || Math.abs(clientVal - x) > 1e-4) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    static _hashSeedToFloat(seed) {
+        let hash = 0;
+        for (let i = 0; i < seed.length; i++) {
+            hash = (hash << 5) - hash + seed.charCodeAt(i);
+            hash |= 0;
+        }
+        return Math.abs(hash % 1000000) / 1000000;
+    }
+
+    static async _solveWebGPU(seed, iterations) {
+        const adapter = await navigator.gpu.requestAdapter();
+        if (!adapter) throw new Error('No compatible GPU adapter found.');
+        const device = await adapter.requestDevice();
+
+        // Compute shader performing a chaotic logistic map iteration
+        const shaderCode = `
+            @group(0) @binding(0) var<storage, read_write> data: array<f32>;
+            @compute @workgroup_size(64)
+            fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+                let index = global_id.x;
+                if (index >= 64) { return; }
+                
+                var x: f32 = data[index];
+                let r: f32 = 3.9999; // Chaotic regime
+                
+                for (var i: u32 = 0u; i < ${iterations}u; i = i + 1u) {
+                    x = r * x * (1.0 - x);
+                }
+                data[index] = x;
+            }
+        `;
+
+        const shaderModule = device.createShaderModule({ code: shaderCode });
+        const pipeline = device.createComputePipeline({
+            layout: 'auto',
+            compute: { module: shaderModule, entryPoint: 'main' }
+        });
+
+        const inputData = new Float32Array(64);
+        for (let i = 0; i < 64; i++) {
+            inputData[i] = seed + (i * 0.015);
+        }
+
+        const gpuBuffer = device.createBuffer({
+            size: inputData.byteLength,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
+            mappedAtCreation: true
+        });
+        new Float32Array(gpuBuffer.getMappedRange()).set(inputData);
+        gpuBuffer.unmap();
+
+        const readBuffer = device.createBuffer({
+            size: inputData.byteLength,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+        });
+
+        const bindGroup = device.createBindGroup({
+            layout: pipeline.getBindGroupLayout(0),
+            entries: [{ binding: 0, resource: { buffer: gpuBuffer } }]
+        });
+
+        const commandEncoder = device.createCommandEncoder();
+        const passEncoder = commandEncoder.beginComputePass();
+        passEncoder.setPipeline(pipeline);
+        passEncoder.setBindGroup(0, bindGroup);
+        passEncoder.dispatchWorkgroups(1);
+        passEncoder.end();
+
+        commandEncoder.copyBufferToBuffer(gpuBuffer, 0, readBuffer, 0, inputData.byteLength);
+        device.queue.submit([commandEncoder.finish()]);
+
+        await readBuffer.mapAsync(GPUMapMode.READ);
+        const result = new Float32Array(readBuffer.getMappedRange());
+        const solutionHash = Array.from(result).map(v => v.toFixed(6)).join(',');
+        readBuffer.unmap();
+
+        return solutionHash;
+    }
+
+    static async _solveWebGL2(seed, iterations) {
+        const canvas = document.createElement('canvas');
+        canvas.width = 8;
+        canvas.height = 8; // 64 pixels total matching WebGPU size
+        const gl = canvas.getContext('webgl2');
+        if (!gl) throw new Error('WebGL2 context not supported.');
+
+        const vs = `#version 300 es\nin vec4 pos; void main() { gl_Position = pos; }`;
+        const fs = `#version 300 es
+            precision highp float;
+            out vec4 outColor;
+            uniform float uSeed;
+            uniform int uIterations;
+            void main() {
+                float index = gl_FragCoord.x + (gl_FragCoord.y * 8.0);
+                float x = uSeed + (index * 0.015);
+                float r = 3.9999;
+                for(int i = 0; i < uIterations; i++) {
+                    x = r * x * (1.0 - x);
+                }
+                outColor = vec4(x, 0.0, 0.0, 1.0);
+            }`;
+
+        // Setup programs, draw fullscreen quad, etc.
+        const program = this._createProgram(gl, vs, fs);
+        gl.useProgram(program);
+
+        const posAttr = gl.getAttribLocation(program, 'pos');
+        const buffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1,-1, 1,-1, -1,1, -1,1, 1,-1, 1,1]), gl.STATIC_DRAW);
+        gl.enableVertexAttribArray(posAttr);
+        gl.vertexAttribPointer(posAttr, 2, gl.FLOAT, false, 0, 0);
+
+        gl.uniform1f(gl.getUniformLocation(program, 'uSeed'), seed);
+        gl.uniform1i(gl.getUniformLocation(program, 'uIterations'), iterations);
+
+        gl.drawArrays(gl.TRIANGLES, 0, 6);
+
+        const pixels = new Float32Array(8 * 8 * 4);
+        gl.readPixels(0, 0, 8, 8, gl.RGBA, gl.FLOAT, pixels);
+
+        const result = [];
+        for (let i = 0; i < 64; i++) {
+            result.push(pixels[i * 4]);
+        }
+
+        return result.map(v => v.toFixed(6)).join(',');
+    }
+
+    static async _solveWebGL1(seed, iterations) {
+        const canvas = document.createElement('canvas');
+        canvas.width = 8;
+        canvas.height = 8; // 64 pixels total matching WebGPU size
+        const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl'); // Get WebGL1 context with legacy fallback
+        if (!gl) throw new Error('WebGL1 context not supported.');
+
+        // WebGL1 Vertex Shader
+        const vs = `
+            attribute vec4 pos;
+            void main() {
+                gl_Position = pos;
+            }`;
+        // WebGL1 Fragment Shader
+        const fs = `
+            precision highp float; // highp float is an extension in WebGL1, but generally available
+            uniform float uSeed;
+            uniform int uIterations;
+            void main() {
+                float index = gl_FragCoord.x + (gl_FragCoord.y * 8.0);
+                float x = uSeed + (index * 0.015);
+                float r = 3.9999;
+                for(int i = 0; i < uIterations; i++) {
+                    x = r * x * (1.0 - x);
+                }
+                gl_FragColor = vec4(x, 0.0, 0.0, 1.0); // Use gl_FragColor for WebGL1
+            }`;
+
+        const program = this._createProgram(gl, vs, fs);
+        gl.useProgram(program);
+
+        const posAttr = gl.getAttribLocation(program, 'pos');
+        const buffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1,-1, 1,-1, -1,1, -1,1, 1,-1, 1,1]), gl.STATIC_DRAW);
+        gl.enableVertexAttribArray(posAttr);
+        gl.vertexAttribPointer(posAttr, 2, gl.FLOAT, false, 0, 0);
+
+        gl.uniform1f(gl.getUniformLocation(program, 'uSeed'), seed);
+        gl.uniform1i(gl.getUniformLocation(program, 'uIterations'), iterations);
+
+        // Check for OES_texture_float and WEBGL_color_buffer_float extensions for float textures and readPixels
+        const floatTextureExt = gl.getExtension('OES_texture_float');
+        const floatColorBufferExt = gl.getExtension('WEBGL_color_buffer_float');
+
+        if (!floatTextureExt || !floatColorBufferExt) {
+            throw new Error('WebGL1 float texture/color buffer extensions not supported. Cannot read float pixels.');
+        }
+
+        // Create a framebuffer to render to a float texture
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, canvas.width, canvas.height, 0, gl.RGBA, gl.FLOAT, null);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+
+        const fb = gl.createFramebuffer();
+        gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+
+        const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
+        if (status !== gl.FRAMEBUFFER_COMPLETE) {
+            throw new Error('WebGL1 framebuffer not complete: ' + status);
+        }
+
+        gl.viewport(0, 0, canvas.width, canvas.height);
+        gl.drawArrays(gl.TRIANGLES, 0, 6);
+
+        const pixels = new Float32Array(canvas.width * canvas.height * 4);
+        gl.readPixels(0, 0, canvas.width, canvas.height, gl.RGBA, gl.FLOAT, pixels);
+
+        const result = [];
+        for (let i = 0; i < 64; i++) {
+            result.push(pixels[i * 4]); // Only take the R component
+        }
+
+        return result.map(v => v.toFixed(6)).join(',');
+    }
+
+    static _createProgram(gl, vsSource, fsSource) {
+        const vs = gl.createShader(gl.VERTEX_SHADER);
+        gl.shaderSource(vs, vsSource);
+        gl.compileShader(vs);
+        const fs = gl.createShader(gl.FRAGMENT_SHADER);
+        gl.shaderSource(fs, fsSource);
+        gl.compileShader(fs);
+        
+        const program = gl.createProgram();
+        gl.attachShader(program, vs);
+        gl.attachShader(program, fs);
+        gl.linkProgram(program);
+        return program;
+    }
+}

package/src/js/library.js

@@ -521,8 +521,8 @@ Optimization.geneticAlgorithmMultiObjective = function (
     const offspring = [];
     for (let i = 0; i < populationSize; i++) {
       // Sélection simple pour l'exemple
-      const parent1 = population[Math.floor(secureRandom() * population.length)];
-      const parent2 = population[Math.floor(secureRandom() * population.length)];
+        const parent1 = population[crypto.randomInt(0, population.length)];
+        const parent2 = population[crypto.randomInt(0, population.length)];
       let childIndividual = crossover(parent1.individual, parent2.individual);
       if (secureRandom() < mutationRate) {
         childIndividual = mutate(childIndividual, currentConfig); // mutate doit maintenant utiliser currentConfig
@@ -749,7 +749,7 @@ Optimization.Operators.createTournamentSelection = (options = {}) => {
 
     for (let i = 0; i < tournamentSize; i++) {
       const individual =
-        population[Math.floor(secureRandom() * population.length)];
+        population[crypto.randomInt(0, population.length)];
       if (!best || individual.fitness < best.fitness) {
         best = individual;
       }
@@ -757,7 +757,7 @@ Optimization.Operators.createTournamentSelection = (options = {}) => {
     // Retourne le meilleur trouvé. Dans le pire des cas (tous les scores sont Infinity),
     // on retourne le premier candidat sélectionné au lieu de null.
     if (!best) {
-      return population[Math.floor(secureRandom() * population.length)];
+      return population[crypto.randomInt(0, population.length)];
     }
     return best;
   };
@@ -911,9 +911,12 @@ Optimization.Operators.solveTSP = (cities, options = {}) => {
   // Voisinage : génère un chemin voisin en inversant une sous-séquence (heuristique 2-opt).
   const pathNeighbor = (path) => {
     const newPath = [...path];
-    let i = Math.floor(secureRandom() * newPath.length);
-    let j = Math.floor(secureRandom() * newPath.length);
-    if (i === j) j = (j + 1) % newPath.length;
+    if (newPath.length <= 1) return newPath;
+    let i = crypto.randomInt(0, newPath.length);
+    let j = crypto.randomInt(0, newPath.length);
+    while (i === j) {
+      j = crypto.randomInt(0, newPath.length);
+    }
     const [start, end] = [Math.min(i, j), Math.max(i, j)];
 
     const segment = newPath.slice(start, end + 1).reverse();
@@ -971,7 +974,7 @@ Optimization.Operators.solvePortfolio = (
 
   const mutate = (p) => {
     const newP = [...p];
-    const i = Math.floor(secureRandom() * newP.length);
+      const i = crypto.randomInt(0, newP.length);
     newP[i] += (secureRandom() - 0.5) * 0.2; // Mutation douce
     newP[i] = Math.max(0, newP[i]); // Les poids ne peuvent être négatifs
     return newP;
@@ -1105,7 +1108,7 @@ Optimization.Operators.solveFacilityLocation = (
   // Voisinage : déplace légèrement une infrastructure au hasard.
   const facilityNeighbor = (facilities) => {
     const newFacilities = facilities.map((f) => ({ ...f }));
-    const i = Math.floor(secureRandom() * numFacilities);
+      const i = crypto.randomInt(0, numFacilities);
     const moveX = (secureRandom() - 0.5) * (bounds.maxX - bounds.minX) * 0.1;
     const moveY = (secureRandom() - 0.5) * (bounds.maxY - bounds.minY) * 0.1;
 
@@ -1485,7 +1488,7 @@ Optimization.Operators.solveFraudDetection = (context, options = {}) => {
     const minTimeToClick = 100 + secureRandom() * 4900; // entre 100ms et 5s
     const maxClickVariance = 1 + secureRandom() * 9999; // entre 1 et 10000
     const minMouseEntropy = secureRandom() * 0.5; // entre 0 et 0.5
-    const minScrollEvents = Math.floor(secureRandom() * 10); // entre 0 et 10
+    const minScrollEvents = crypto.randomInt(0, 10); // entre 0 et 10
     return [minTimeToClick, maxClickVariance, minMouseEntropy, minScrollEvents];
   };
 
@@ -1502,7 +1505,7 @@ Optimization.Operators.solveFraudDetection = (context, options = {}) => {
   // Mutation : légère variation aléatoire d'un des seuils
   const mutate = (solution) => {
     const newSolution = [...solution];
-    const i = Math.floor(secureRandom() * 4);
+    const i = crypto.randomInt(0, 4);
     // Amplitudes de mutation différentes pour chaque seuil
     const mutationFactors = [500, 1000, 0.1, 2];
     const mutationFactor = mutationFactors[i];
@@ -1646,7 +1649,7 @@ Optimization.Operators.solveFullSecurityTuning = (context, options = {}) => {
             burstWeight: 20 + secureRandom() * 40,
             scrapeThreshold: 500 + secureRandom() * 1000,
             scrapeWeight: 15 + secureRandom() * 35,
-            sequenceLength: 3 + Math.floor(secureRandom() * 3),
+            sequenceLength: 3 + crypto.randomInt(0, 3),
             sequenceWeight: 20 + secureRandom() * 50,
             regularityThreshold: 50 + secureRandom() * 200,
             regularityWeight: 20 + secureRandom() * 40,
@@ -1696,7 +1699,7 @@ Optimization.Operators.solveFullSecurityTuning = (context, options = {}) => {
         }
 
         const keys = Object.keys(newConfig[sectionToMutate]);
-        const keyToMutate = keys[Math.floor(secureRandom() * keys.length)];
+        const keyToMutate = keys[crypto.randomInt(0, keys.length)];
 
         if (keyToMutate === 'honeypotScore') return newConfig; // Ne pas muter le poids du honeypot
 

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

@@ -7,10 +7,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);
     }
@@ -140,6 +141,53 @@ 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) {
@@ -165,8 +213,12 @@ 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);
         }
     }
@@ -215,41 +267,100 @@ async function solveCpuTarget(message, target) {
  * @returns {Promise<number>} La solution (nombre entier).
  */
 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;
     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);
-        }
-        wasmModule.HEAP8[seedPtr + seed.length] = 0;
-        const solution = wasmModule._solve_memory_challenge(seedPtr, difficulty);
-        wasmModule._free(seedPtr);
+        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);
+        wasmModule._free(ptr);
         return solution;
     }
 
-    let h = new TextEncoder().encode(seed).reduce((acc, v) => acc + v, 0);
-    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 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);
+        }
+        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];
+
+    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 = size / 16;
-    let addr = buffer.length > 0 ? buffer[0] % buffer.length : 0;
+    const iterations = 1024;
     for (let i = 0; i < iterations; i++) {
-        addr = buffer[addr] % buffer.length;
+        addr = readBuffer(blocks, addr) % totalElements;
         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 };
 }
 
 /**