396 lines
No EOL
16 KiB
JavaScript
396 lines
No EOL
16 KiB
JavaScript
// Web Worker Script for hash computation
|
|
function workerFunction() {
|
|
self.onmessage = function(e) {
|
|
const { type, data } = e.data;
|
|
|
|
if (type === 'pow') {
|
|
// PoW calculation
|
|
const { challenge, salt, startNonce, endNonce, target, batchId } = data;
|
|
let count = 0;
|
|
let solution = null;
|
|
|
|
processNextNonce(startNonce);
|
|
|
|
function processNextNonce(nonce) {
|
|
const input = String(challenge) + String(salt) + nonce.toString();
|
|
const msgBuffer = new TextEncoder().encode(input);
|
|
|
|
crypto.subtle.digest('SHA-256', msgBuffer)
|
|
.then(hashBuffer => {
|
|
const hashArray = Array.from(new Uint8Array(hashBuffer));
|
|
const result = hashArray.map(b =>
|
|
b.toString(16).padStart(2, '0')).join('');
|
|
|
|
count++;
|
|
|
|
if (result.startsWith(target)) {
|
|
solution = { nonce: nonce.toString(), found: true };
|
|
self.postMessage({
|
|
type: 'pow_result',
|
|
solution: solution,
|
|
count: count,
|
|
batchId: batchId
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (count % 1000 === 0) {
|
|
self.postMessage({
|
|
type: 'progress',
|
|
count: count,
|
|
batchId: batchId
|
|
});
|
|
}
|
|
|
|
if (nonce < endNonce && !solution) {
|
|
setTimeout(() => processNextNonce(nonce + 1), 0);
|
|
} else if (!solution) {
|
|
self.postMessage({
|
|
type: 'pow_result',
|
|
solution: null,
|
|
count: count,
|
|
batchId: batchId
|
|
});
|
|
}
|
|
})
|
|
.catch(err => {
|
|
self.postMessage({
|
|
type: 'error',
|
|
error: 'Crypto API error: ' + err.message
|
|
});
|
|
});
|
|
}
|
|
} else {
|
|
// Handle other message types if needed in the future
|
|
self.postMessage({ type: 'error', error: 'Unknown message type: ' + type });
|
|
}
|
|
};
|
|
}
|
|
const workerCode = "(" + workerFunction.toString() + ")()";
|
|
|
|
// Proof-of-Space Worker script with buffer pooling
|
|
function posWorkerFunction() {
|
|
self.onmessage = async function(e) {
|
|
const { type, seedHex, isDecoy } = e.data;
|
|
if (type === 'pos') {
|
|
const minMB = 48, maxMB = 160;
|
|
let seedInt = parseInt(seedHex.slice(0, 8), 16);
|
|
if (isNaN(seedInt)) seedInt = Math.floor(Math.random() * (maxMB - minMB + 1));
|
|
const CHUNK_MB = isDecoy
|
|
? (minMB + ((seedInt * 3 + 17) % (maxMB - minMB + 1)))
|
|
: (minMB + (seedInt % (maxMB - minMB + 1)));
|
|
const CHUNK_SIZE = CHUNK_MB * 1024 * 1024;
|
|
const chunkCount = 4 + (seedInt % 5);
|
|
const chunkSize = Math.floor(CHUNK_SIZE / chunkCount);
|
|
const FILL_STEP_4K = 4096, FILL_STEP_1K = 1024;
|
|
const FILL_STEP_SWITCH = 35 * 1024 * 1024;
|
|
const runs = 3;
|
|
|
|
// Pre-allocate buffers
|
|
// Removed baseBuf as cpuBase calculation is unused
|
|
const mainBuf = new ArrayBuffer(CHUNK_SIZE);
|
|
const view = new Uint8Array(mainBuf);
|
|
const pressureBuf = new ArrayBuffer(16 * 1024 * 1024);
|
|
const pressureView = new Uint8Array(pressureBuf);
|
|
|
|
// Removed CPU baseline calculation as it's unused upstream
|
|
|
|
const hashes = [];
|
|
const times = [];
|
|
for (let r = 0; r < runs; r++) {
|
|
const prng = seededPRNG(seedHex + r.toString(16));
|
|
// generate deterministic chunk order
|
|
const order = Array.from({ length: chunkCount }, (_, i) => i);
|
|
for (let i = order.length - 1; i > 0; i--) {
|
|
const j = prng() % (i + 1);
|
|
[order[i], order[j]] = [order[j], order[i]];
|
|
}
|
|
|
|
// fill view
|
|
const t0 = performance.now();
|
|
for (let c = 0; c < chunkCount; c++) {
|
|
const idx = order[c];
|
|
const start = idx * chunkSize;
|
|
const end = (idx === chunkCount - 1) ? CHUNK_SIZE : start + chunkSize;
|
|
const step = (start < FILL_STEP_SWITCH) ? FILL_STEP_4K : FILL_STEP_1K;
|
|
for (let i = start; i < end; i += step) view[i] = prng() & 0xFF;
|
|
}
|
|
const hashBuf = await crypto.subtle.digest('SHA-256', view);
|
|
const t2 = performance.now();
|
|
hashes.push(Array.from(new Uint8Array(hashBuf)).map(b => b.toString(16).padStart(2, '0')).join(''));
|
|
times.push(Math.round(t2 - t0));
|
|
|
|
// memory pressure
|
|
for (let i = 0; i < pressureView.length; i += 4096) pressureView[i] = prng() & 0xFF;
|
|
}
|
|
|
|
// Removed cpuBase from postMessage
|
|
self.postMessage({ type: 'pos_result', hashes, times });
|
|
}
|
|
};
|
|
function seededPRNG(seedHex) {
|
|
const s = [];
|
|
for (let i = 0; i < 4; i++) s[i] = parseInt(seedHex.substr(i * 8, 8), 16) >>> 0;
|
|
function rotl(x, k) { return ((x << k) | (x >>> (32 - k))) >>> 0; }
|
|
return function() {
|
|
const t = s[1] << 9;
|
|
let r = (s[0] * 5) >>> 0;
|
|
r = rotl(r, 7) * 9 >>> 0;
|
|
const tmp = s[0] ^ s[2];
|
|
s[2] ^= s[1]; s[1] ^= s[3]; s[0] ^= s[1];
|
|
s[3] ^= tmp; s[2] ^= t; s[3] = rotl(s[3], 11);
|
|
return r >>> 0;
|
|
};
|
|
}
|
|
}
|
|
const posWorkerCode = "(" + posWorkerFunction.toString() + ")()";
|
|
|
|
// Main verification script
|
|
document.addEventListener('DOMContentLoaded', function() {
|
|
setTimeout(initVerification, 650);
|
|
|
|
function initVerification() {
|
|
const dataEl = document.getElementById('verification-data');
|
|
const targetPath = dataEl.getAttribute('data-target');
|
|
const requestID = dataEl.getAttribute('data-request-id');
|
|
|
|
startVerification();
|
|
|
|
async function startVerification() {
|
|
try {
|
|
const challengeResponse = await fetch('/api/pow/challenge?id=' + encodeURIComponent(requestID), {
|
|
method: 'GET',
|
|
headers: { 'Accept': 'application/json' }
|
|
});
|
|
|
|
if (!challengeResponse.ok) {
|
|
throw new Error('Failed to get challenge parameters');
|
|
}
|
|
|
|
const challengeData = await challengeResponse.json();
|
|
|
|
// Extract real and decoy seeds using obfuscated keys
|
|
const realPosSeed = challengeData.d; // 'd' is pos_seed
|
|
const decoySeed = challengeData.e || (Math.random().toString(16).slice(2, 18)); // 'e' is decoy_seed
|
|
const decoyFields = challengeData.f || []; // 'f' is decoy_fields
|
|
|
|
const verifier = new Verifier(challengeData, targetPath, requestID, decoySeed, decoyFields);
|
|
verifier.start();
|
|
} catch (error) {
|
|
showError('Verification setup failed: ' + error.message);
|
|
}
|
|
}
|
|
|
|
function createWorker() {
|
|
const blob = new Blob([workerCode], { type: 'text/javascript' });
|
|
return new Worker(URL.createObjectURL(blob));
|
|
}
|
|
|
|
function createPosWorker() {
|
|
const blob = new Blob([posWorkerCode], { type: 'text/javascript' });
|
|
return new Worker(URL.createObjectURL(blob));
|
|
}
|
|
|
|
function showError(message) {
|
|
const container = document.querySelector('.container');
|
|
container.classList.add('error');
|
|
container.classList.remove('success');
|
|
|
|
// Let CSS pseudo-elements render the ring and X on the existing spinner
|
|
const spinnerEl = document.querySelector('.spinner');
|
|
|
|
const statusEl = document.getElementById('status');
|
|
statusEl.style.display = 'inline-block';
|
|
statusEl.textContent = ''; // Keep this behavior as original, even if odd
|
|
statusEl.classList.add('error');
|
|
statusEl.classList.remove('success');
|
|
|
|
const spinnerContainer = document.querySelector('.spinner-container');
|
|
let errorDetails = document.getElementById('error-details');
|
|
|
|
if (!errorDetails) {
|
|
errorDetails = document.createElement('div');
|
|
errorDetails.id = 'error-details';
|
|
errorDetails.className = 'error-details';
|
|
spinnerContainer.appendChild(errorDetails);
|
|
}
|
|
|
|
// Hide error details to match success state layout
|
|
errorDetails.style.display = 'none'; // Keep this behavior as original
|
|
}
|
|
|
|
function showSuccess() {
|
|
document.querySelector('.container').classList.add('success');
|
|
document.getElementById('status').textContent = 'Redirecting';
|
|
}
|
|
|
|
function Verifier(params, targetPath, requestID, decoySeed, decoyFields) {
|
|
const workers = [];
|
|
const activeBatches = {};
|
|
let powSolution = null;
|
|
let isRunning = false;
|
|
|
|
const cpuCount = navigator.hardwareConcurrency || 4;
|
|
const workerCount = Math.max(1, Math.floor(cpuCount * 0.8));
|
|
|
|
const REDIRECT_DELAY = 1488;
|
|
|
|
this.start = function() {
|
|
setTimeout(findProofOfWork, 100);
|
|
};
|
|
|
|
async function findProofOfWork() {
|
|
try {
|
|
isRunning = true;
|
|
|
|
let decodedChallenge, decodedSalt;
|
|
try {
|
|
decodedChallenge = atob(params.a);
|
|
decodedSalt = atob(params.b);
|
|
} catch (e) {
|
|
throw new Error(`Failed to decode challenge/salt: ${e.message}`);
|
|
}
|
|
const target = '0'.repeat(params.c);
|
|
|
|
for (let i = 0; i < workerCount; i++) {
|
|
const worker = createWorker();
|
|
// Pass only 'e.data' as workerId parameter was unused
|
|
worker.onmessage = e => handleWorkerMessage(e.data);
|
|
worker.onerror = error => {
|
|
// Silently handle worker errors
|
|
};
|
|
workers.push(worker);
|
|
}
|
|
|
|
const totalRange = Number.MAX_SAFE_INTEGER;
|
|
const rangePerWorker = Math.floor(totalRange / workerCount);
|
|
|
|
for (let i = 0; i < workers.length; i++) {
|
|
const startNonce = i * rangePerWorker;
|
|
const endNonce = (i === workers.length - 1) ?
|
|
totalRange : (i + 1) * rangePerWorker - 1;
|
|
|
|
const workerId = `pow-worker-${i}`;
|
|
|
|
activeBatches[workerId] = {
|
|
// Keep workerId here as it's used as key in activeBatches
|
|
workerId: i,
|
|
startNonce,
|
|
endNonce
|
|
};
|
|
|
|
workers[i].postMessage({
|
|
type: 'pow',
|
|
data: {
|
|
challenge: decodedChallenge,
|
|
salt: decodedSalt,
|
|
startNonce,
|
|
endNonce,
|
|
target,
|
|
batchId: workerId
|
|
}
|
|
});
|
|
}
|
|
|
|
} catch (error) {
|
|
terminateWorkers();
|
|
showError(error.message);
|
|
}
|
|
}
|
|
|
|
// Removed unused 'workerId' parameter
|
|
function handleWorkerMessage(data) {
|
|
if (!isRunning) return;
|
|
|
|
if (data.type === 'pow_result') {
|
|
if (activeBatches[data.batchId]) {
|
|
delete activeBatches[data.batchId];
|
|
|
|
if (data.solution && data.solution.found) {
|
|
if (!powSolution) {
|
|
powSolution = data.solution;
|
|
proofOfWorkFound(powSolution);
|
|
}
|
|
}
|
|
}
|
|
} else if (data.type === 'error') {
|
|
showError('Compatibility error: ' + data.error);
|
|
terminateWorkers();
|
|
}
|
|
}
|
|
|
|
async function proofOfWorkFound(solution) {
|
|
isRunning = false;
|
|
terminateWorkers();
|
|
try {
|
|
// PoS via Worker
|
|
const posResult = await new Promise(res => {
|
|
const w = createPosWorker();
|
|
w.onmessage = e => { if (e.data.type==='pos_result') { res(e.data); w.terminate(); }};
|
|
w.postMessage({ type:'pos', seedHex: params.d, isDecoy:false });
|
|
});
|
|
const decoyResult = await new Promise(res => {
|
|
const w = createPosWorker();
|
|
w.onmessage = e => { if (e.data.type==='pos_result') { res(e.data); w.terminate(); }};
|
|
w.postMessage({ type:'pos', seedHex: decoySeed, isDecoy:true });
|
|
});
|
|
// Submit results
|
|
await submitSolution({ requestID, g: solution.nonce,
|
|
h: posResult.hashes, i: posResult.times,
|
|
j: decoyResult.hashes, k: decoyResult.times,
|
|
l: decoyFields });
|
|
} catch (error) {
|
|
showError(error.message);
|
|
}
|
|
}
|
|
|
|
function terminateWorkers() {
|
|
workers.forEach(worker => worker.terminate());
|
|
}
|
|
|
|
async function submitSolution(solutionData) {
|
|
try {
|
|
const response = await fetch('/api/pow/verify', {
|
|
method: 'POST',
|
|
headers: {
|
|
'Content-Type': 'application/json'
|
|
},
|
|
body: JSON.stringify({
|
|
request_id: solutionData.requestID, // Keep descriptive
|
|
g: solutionData.g, // Nonce
|
|
h: solutionData.h, // Real PoS Hashes
|
|
i: solutionData.i, // Real PoS Times
|
|
j: solutionData.j, // Decoy Hashes
|
|
k: solutionData.k, // Decoy Times
|
|
l: solutionData.l // Decoy Fields
|
|
})
|
|
});
|
|
|
|
if (!response.ok) {
|
|
let errorMsg = `Verification failed: ${response.statusText}`;
|
|
try {
|
|
const errorData = await response.json();
|
|
if (errorData && errorData.error) {
|
|
errorMsg += ` - ${errorData.error}`;
|
|
} else {
|
|
const text = await response.text();
|
|
errorMsg += ` - Response: ${text}`;
|
|
}
|
|
} catch (parseError) {
|
|
// Silent catch
|
|
}
|
|
showError(errorMsg);
|
|
return;
|
|
}
|
|
|
|
showSuccess();
|
|
setTimeout(() => {
|
|
window.location.href = targetPath;
|
|
}, REDIRECT_DELAY);
|
|
} catch (error) {
|
|
showError('Verification failed. Please refresh the page.');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}); |