@anonympins/fingerprint 0.4.2 → 0.4.4

package/src/js/tests/pow.solver.test.js

@@ -1,198 +1,234 @@
-import {describe, expect, it, vi, beforeEach, afterEach} from 'vitest';
-import {createHash} from 'node:crypto';
-// Import the functions to be tested.
-// Since the inline file doesn't use exports, we can't directly import.
-// Instead, we'll test the ES module version which shares the same logic.
-import {solveChallenge, solveCpuTargetInline, solveMemory, solveTsp} from '../pow.solver.js';
-
-describe('Proof-of-Work Solvers', () => {
-
-    describe('solveCpuTargetInline', () => {
-        const nonce = 'test-nonce';
-        // A relatively easy target for quick tests (first 16 bits must be zero)
-        const targetHex = '0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
-        const targetBigInt = BigInt('0x' + targetHex);
-
-        it('should find a valid CPU solution with a simple base block', async () => {
-            // Le `baseBlock` est maintenant un Uint8Array.
-            // Le client et le serveur doivent s'accorder sur sa construction.
-            // Ici, on simule un challenge simple avec juste le nonce.
-            const baseBlock = new TextEncoder().encode(`${nonce}:`);
-            const solution = await solveCpuTargetInline(baseBlock, targetHex);
-
-            // Verification: re-hash the solution and check against the target
-            const finalBlock = new Uint8Array([...baseBlock, ...new TextEncoder().encode(String(solution))]);
-            const hash = createHash('sha256').update(finalBlock).digest('hex');
-            const hashBigInt = BigInt('0x' + hash);
-
-            expect(hashBigInt).toBeLessThan(targetBigInt);
-        }, 20000);
-
-        it('should find a valid CPU solution with a client secret', async () => {
-            const clientSecret = 'my-secret';
-            const fingerprint = 'test-fp-string';
-            // Le `baseBlock` est maintenant un Uint8Array qui inclut toutes les informations.
-            const baseBlock = new TextEncoder().encode(`${nonce}:${clientSecret}:${fingerprint}:`);
-            const solution = await solveCpuTargetInline(baseBlock, targetHex);
-
-            // Verification: re-hash the solution and check against the target
-            const finalBlock = new Uint8Array([...baseBlock, ...new TextEncoder().encode(String(solution))]);
-            const hash = createHash('sha256').update(finalBlock).digest('hex');
-            const hashBigInt = BigInt('0x' + hash);
-            expect(hashBigInt).toBeLessThan(targetBigInt);
-        }, 20000);
-
-        it('should call the progress callback', async () => {
-            const progressCallback = vi.fn();
-            const baseBlock = new TextEncoder().encode(`${nonce}:`);
-            // Use a much harder target to ensure the loop runs long enough
-            const hardTarget = '0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
-            await solveCpuTargetInline(baseBlock, hardTarget, progressCallback);
-
-            // Check if the callback was called with a number
-            expect(progressCallback).toHaveBeenCalled();
-            expect(progressCallback).toHaveBeenCalledWith(expect.any(Number));
-        }, 40000); // Increase timeout for harder challenge
-    });
-
-    describe('solveMemory', () => {
-        it('should produce a deterministic result for a given seed and difficulty', async () => {
-            const seed = 'test-seed';
-            const difficulty = 1; // 1MB
-
-            const solution1 = await solveMemory(seed, difficulty);
-            const solution2 = await solveMemory(seed, difficulty);
-
-            expect(solution1).toBe(solution2);
-            expect(solution1).not.toBe(await solveMemory('different-seed', difficulty));
-        });
-    });
-
-    describe('solveTsp', () => {
-        it('should solve a simple TSP problem', async () => {
-            const cities = [{ x: 10, y: 10 }, { x: 90, y: 90 }, { x: 10, y: 90 }, { x: 90, y: 10 }];
-            const result = await solveTsp(cities, 400);
-
-            expect(result.path).toBeInstanceOf(Array);
-            expect(result.path.length).toBe(4);
-            // The optimal path for a square is ~324. The nearest neighbor should find this.
-            expect(result.distance).toBeLessThan(330);
-        });
-    });
-
-    describe('solveChallenge', () => {
-        const nonce = 'challenge-nonce';
-        const clientSecret = 'challenge-secret';
-        const cpuTarget = '0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
-
-        it('should solve a "cpu_target" challenge', async () => {
-            // The 'cpu_target' case in solveChallenge uses Web Workers, which are not available in Node.js test env.
-            // We will test the 'cpu_mem' case which uses the same underlying `solveCpuTargetInline` function.
-            // This test is effectively covered by the 'cpu_mem' test below.
-            expect(true).toBe(true);
-        });
-
-        it('should solve a "cpu_mem" challenge for an API client', async () => {
-            const challenge = {
-                type: 'cpu_mem',
-                nonce,
-                clientSecret,
-                cpuTarget,
-                memDifficulty: 1,
-                // Pour les appels API, le serveur pré-calcule le baseBlock
-                // sans l'IP du client, mais avec l'empreinte digitale.
-                baseBlock: [...new TextEncoder().encode(`${nonce}:${clientSecret}:`)]
-            };
-
-            const solutions = await solveChallenge(challenge, ''); // Le fingerprint est passé en 2e arg
-            expect(solutions.rawSolution).toHaveProperty('cpu', expect.any(Number));
-            expect(solutions.rawSolution).toHaveProperty('mem', expect.any(Number));
-        }, 20000);
-
-        it('should solve a "cpu_mem_inline" challenge for a browser', async () => {
-            const challenge = {
-                type: 'cpu_mem_inline',
-                nonce,
-                clientSecret,
-                cpuTarget,
-                memDifficulty: 1,
-                // Pour le challenge inline, le serveur inclut l'IP dans le baseBlock.
-                baseBlock: [...new TextEncoder().encode(`${nonce}:${clientSecret}:`)]
-            };
-
-            const solutions = await solveChallenge(challenge, '');
-            expect(solutions.rawSolution).toHaveProperty('cpu', expect.any(Number));
-            expect(solutions.rawSolution).toHaveProperty('mem', expect.any(Number));
-        }, 20000);
-
-        it('should solve a "tsp" challenge', async () => {
-            const challenge = {
-                type: 'tsp',
-                cities: [{ x: 0, y: 0 }, { x: 100, y: 100 }],
-                targetMaxDistance: 300
-            };
-            const solutions = await solveChallenge(challenge);
-            // Pour le TSP, la solution brute est directement le chemin
-            expect(solutions.rawSolution).toEqual([0, 1]);
-        });
-
-        it('should throw an error for an unknown challenge type', async () => {
-            const challenge = { type: 'unknown' };
-            await expect(solveChallenge(challenge)).rejects.toThrow('Unknown challenge type: unknown');
-        });
-    });
-
-    describe('WASM Solver Path Integration (Mocked)', () => {
-        let mockWasmModule;
-
-        beforeEach(() => {
-            mockWasmModule = {
-                _malloc: vi.fn().mockImplementation(() => 1234), // Simule un pointeur mémoire
-                _free: vi.fn(),
-                HEAPU8: new Uint8Array(10000),
-                HEAP8: new Int8Array(10000),
-                _solve_cpu_target: vi.fn().mockReturnValue(1337),
-                _solve_memory_challenge: vi.fn().mockReturnValue(777)
-            };
-
-            // Injecter le module WASM globalement pour simuler le comportement du navigateur
-            global.window = {
-                wasmModule: mockWasmModule
-            };
-        });
-
-        afterEach(() => {
-            // Nettoyer l'environnement global après chaque test
-            delete global.window;
-        });
-
-        it('should redirect solveCpuTargetInline to WASM and manage heap memory safely', async () => {
-            const baseBlock = new Uint8Array([1, 2, 3, 4]);
-            const target = '0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
-
-            const solution = await solveCpuTargetInline(baseBlock, target);
-
-            // 1. Vérification du résultat natif retourné par le mock
-            expect(solution).toBe(1337);
-
-            // 2. Vérification des allocations et libérations mémoire pour le bloc de base et la cible hexadécimale
-            expect(mockWasmModule._malloc).toHaveBeenCalledTimes(2);
-            expect(mockWasmModule._free).toHaveBeenCalledTimes(2);
-
-            // 3. Vérification de l'appel à la fonction C++ exportée
-            expect(mockWasmModule._solve_cpu_target).toHaveBeenCalledWith(1234, baseBlock.length, 1234);
-        });
-
-        it('should redirect solveMemory to WASM and manage heap memory safely', async () => {
-            const seed = 'test-wasm-seed';
-            const difficulty = 4; // 4 MB
-
-            const solution = await solveMemory(seed, difficulty);
-
-            expect(solution).toBe(777);
-            expect(mockWasmModule._malloc).toHaveBeenCalledTimes(1);
-            expect(mockWasmModule._free).toHaveBeenCalledTimes(1);
-            expect(mockWasmModule._solve_memory_challenge).toHaveBeenCalledWith(1234, difficulty);
-        });
-    });
+import {describe, expect, it, vi, beforeEach, afterEach} from 'vitest';
+import {createHash} from 'node:crypto';
+// Import the functions to be tested.
+// Since the inline file doesn't use exports, we can't directly import.
+// Instead, we'll test the ES module version which shares the same logic.
+import {solveChallenge, solveCpuTargetInline, solveMemory, solveTsp} from '../pow.solver.js';
+
+describe('Proof-of-Work Solvers', () => {
+
+    describe('solveCpuTargetInline', () => {
+        const nonce = 'test-nonce';
+        // A relatively easy target for quick tests (first 16 bits must be zero)
+        const targetHex = '0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
+        const targetBigInt = BigInt('0x' + targetHex);
+
+        it('should find a valid CPU solution with a simple base block', async () => {
+            // Le `baseBlock` est maintenant un Uint8Array.
+            // Le client et le serveur doivent s'accorder sur sa construction.
+            // Ici, on simule un challenge simple avec juste le nonce.
+            const baseBlock = new TextEncoder().encode(`${nonce}:`);
+            const solution = await solveCpuTargetInline(baseBlock, targetHex);
+
+            // Verification: re-hash the solution and check against the target
+            const finalBlock = new Uint8Array([...baseBlock, ...new TextEncoder().encode(String(solution))]);
+            const hash = createHash('sha256').update(finalBlock).digest('hex');
+            const hashBigInt = BigInt('0x' + hash);
+
+            expect(hashBigInt).toBeLessThan(targetBigInt);
+        }, 20000);
+
+        it('should find a valid CPU solution with a client secret', async () => {
+            const clientSecret = 'my-secret';
+            const fingerprint = 'test-fp-string';
+            // Le `baseBlock` est maintenant un Uint8Array qui inclut toutes les informations.
+            const baseBlock = new TextEncoder().encode(`${nonce}:${clientSecret}:${fingerprint}:`);
+            const solution = await solveCpuTargetInline(baseBlock, targetHex);
+
+            // Verification: re-hash the solution and check against the target
+            const finalBlock = new Uint8Array([...baseBlock, ...new TextEncoder().encode(String(solution))]);
+            const hash = createHash('sha256').update(finalBlock).digest('hex');
+            const hashBigInt = BigInt('0x' + hash);
+            expect(hashBigInt).toBeLessThan(targetBigInt);
+        }, 20000);
+
+        it('should call the progress callback', async () => {
+            const progressCallback = vi.fn();
+            const baseBlock = new TextEncoder().encode(`${nonce}:`);
+            // Use a much harder target to ensure the loop runs long enough
+            const hardTarget = '0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
+            await solveCpuTargetInline(baseBlock, hardTarget, progressCallback);
+
+            // Check if the callback was called with a number
+            expect(progressCallback).toHaveBeenCalled();
+            expect(progressCallback).toHaveBeenCalledWith(expect.any(Number));
+        }, 40000); // Increase timeout for harder challenge
+    });
+
+    describe('solveMemory', () => {
+        it('should produce a deterministic result for a given seed and difficulty', async () => {
+            const seed = 'test-seed';
+            const difficulty = 1; // 1MB
+
+            const solution1 = await solveMemory(seed, difficulty);
+            const solution2 = await solveMemory(seed, difficulty);
+
+            expect(solution1).toBe(solution2);
+            expect(solution1).not.toBe(await solveMemory('different-seed', difficulty));
+        });
+    });
+
+    describe('solveTsp', () => {
+        it('should solve a simple TSP problem', async () => {
+            const cities = [{ x: 10, y: 10 }, { x: 90, y: 90 }, { x: 10, y: 90 }, { x: 90, y: 10 }];
+            const result = await solveTsp(cities, 400);
+
+            expect(result.path).toBeInstanceOf(Array);
+            expect(result.path.length).toBe(4);
+            // The optimal path for a square is ~324. The nearest neighbor should find this.
+            expect(result.distance).toBeLessThan(330);
+        });
+    });
+
+    describe('solveChallenge', () => {
+        const nonce = 'challenge-nonce';
+        const clientSecret = 'challenge-secret';
+        const cpuTarget = '0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
+
+        it('should solve a "cpu_target" challenge', async () => {
+            // The 'cpu_target' case in solveChallenge uses Web Workers, which are not available in Node.js test env.
+            // We will test the 'cpu_mem' case which uses the same underlying `solveCpuTargetInline` function.
+            // This test is effectively covered by the 'cpu_mem' test below.
+            expect(true).toBe(true);
+        });
+
+        it('should solve a "cpu_mem" challenge for an API client', async () => {
+            const challenge = {
+                type: 'cpu_mem',
+                nonce,
+                clientSecret,
+                cpuTarget,
+                memDifficulty: 1,
+                // Pour les appels API, le serveur pré-calcule le baseBlock
+                // sans l'IP du client, mais avec l'empreinte digitale.
+                baseBlock: [...new TextEncoder().encode(`${nonce}:${clientSecret}:`)]
+            };
+
+            const solutions = await solveChallenge(challenge, ''); // Le fingerprint est passé en 2e arg
+            expect(solutions.rawSolution).toHaveProperty('cpu', expect.any(Number));
+            expect(solutions.rawSolution).toHaveProperty('mem', expect.any(Number));
+        }, 20000);
+
+        it('should solve a "cpu_mem_inline" challenge for a browser', async () => {
+            const challenge = {
+                type: 'cpu_mem_inline',
+                nonce,
+                clientSecret,
+                cpuTarget,
+                memDifficulty: 1,
+                // Pour le challenge inline, le serveur inclut l'IP dans le baseBlock.
+                baseBlock: [...new TextEncoder().encode(`${nonce}:${clientSecret}:`)]
+            };
+
+            const solutions = await solveChallenge(challenge, '');
+            expect(solutions.rawSolution).toHaveProperty('cpu', expect.any(Number));
+            expect(solutions.rawSolution).toHaveProperty('mem', expect.any(Number));
+        }, 20000);
+
+        it('should solve a "tsp" challenge', async () => {
+            const challenge = {
+                type: 'tsp',
+                cities: [{ x: 0, y: 0 }, { x: 100, y: 100 }],
+                targetMaxDistance: 300
+            };
+            const solutions = await solveChallenge(challenge);
+            // Pour le TSP, la solution brute est directement le chemin
+            expect(solutions.rawSolution).toEqual([0, 1]);
+        });
+
+        it('should solve a "useful_work_task" with facility location challenge', async () => {
+            const challenge = {
+                type: 'useful_work_task',
+                nonce: 'test-nonce-useful-work',
+                usefulWorkTask: {
+                    problemId: 'facility_location_challenge',
+                    task: {
+                        type: 'simulated_annealing_iterations',
+                        iterations: 10,
+                        payload: {
+                            customers: [
+                                { x: 100, y: 100 },
+                                { x: 200, y: 200 }
+                            ],
+                            numFacilities: 2,
+                            bounds: { minX: 0, maxX: 500, minY: 0, maxY: 500 },
+                            options: {
+                                fixedCostPerFacility: 1500,
+                                initialTemperature: 150000,
+                                coolingRate: 0.99
+                            }
+                        }
+                    }
+                }
+            };
+
+            const solutions = await solveChallenge(challenge);
+            expect(solutions.type).toBe('useful_work_task');
+            expect(solutions.nonce).toBe('test-nonce-useful-work');
+            expect(solutions.rawSolution.problem_id).toBe('facility_location_challenge');
+            expect(solutions.rawSolution.work_result).toBeDefined();
+            expect(solutions.rawSolution.work_result.solution).toBeInstanceOf(Array);
+            expect(solutions.rawSolution.work_result.solution.length).toBe(2);
+            expect(solutions.rawSolution.work_result.energy).toBeLessThan(Infinity);
+        });
+
+        it('should throw an error for an unknown challenge type', async () => {
+            const challenge = { type: 'unknown' };
+            await expect(solveChallenge(challenge)).rejects.toThrow('Unknown challenge type: unknown');
+        });
+    });
+
+    describe('WASM Solver Path Integration (Mocked)', () => {
+        let mockWasmModule;
+
+        beforeEach(() => {
+            mockWasmModule = {
+                _malloc: vi.fn().mockImplementation(() => 1234), // Simule un pointeur mémoire
+                _free: vi.fn(),
+                HEAPU8: new Uint8Array(10000),
+                HEAP8: new Int8Array(10000),
+                _solve_cpu_target: vi.fn().mockReturnValue(1337),
+                _solve_memory_challenge: vi.fn().mockReturnValue(777)
+            };
+
+            // Injecter le module WASM globalement pour simuler le comportement du navigateur
+            global.window = {
+                wasmModule: mockWasmModule
+            };
+        });
+
+        afterEach(() => {
+            // Nettoyer l'environnement global après chaque test
+            delete global.window;
+        });
+
+        it('should redirect solveCpuTargetInline to WASM and manage heap memory safely', async () => {
+            const baseBlock = new Uint8Array([1, 2, 3, 4]);
+            const target = '0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
+
+            const solution = await solveCpuTargetInline(baseBlock, target);
+
+            // 1. Vérification du résultat natif retourné par le mock
+            expect(solution).toBe(1337);
+
+            // 2. Vérification des allocations et libérations mémoire pour le bloc de base et la cible hexadécimale
+            expect(mockWasmModule._malloc).toHaveBeenCalledTimes(2);
+            expect(mockWasmModule._free).toHaveBeenCalledTimes(2);
+
+            // 3. Vérification de l'appel à la fonction C++ exportée
+            expect(mockWasmModule._solve_cpu_target).toHaveBeenCalledWith(1234, baseBlock.length, 1234);
+        });
+
+        it('should redirect solveMemory to WASM and manage heap memory safely', async () => {
+            const seed = 'test-wasm-seed';
+            const difficulty = 4; // 4 MB
+
+            const solution = await solveMemory(seed, difficulty);
+
+            expect(solution).toBe(777);
+            expect(mockWasmModule._malloc).toHaveBeenCalledTimes(1);
+            expect(mockWasmModule._free).toHaveBeenCalledTimes(1);
+            expect(mockWasmModule._solve_memory_challenge).toHaveBeenCalledWith(1234, difficulty);
+        });
+    });
 });