311 lines
8.9 KiB
TypeScript
311 lines
8.9 KiB
TypeScript
import type { ProcessState } from '../../../pkg/sdk_client';
|
|
import Services from '../../services/service';
|
|
|
|
interface State {
|
|
file: File | null;
|
|
fileHash: string | null;
|
|
certificate: ProcessState | null;
|
|
commitmentHashes: string[];
|
|
}
|
|
|
|
export interface Vin {
|
|
txid: string; // The txid of the previous transaction (being spent)
|
|
vout: number; // The output index in the previous tx
|
|
prevout: {
|
|
scriptpubkey: string;
|
|
scriptpubkey_asm: string;
|
|
scriptpubkey_type: string;
|
|
scriptpubkey_address: string;
|
|
value: number;
|
|
};
|
|
scriptsig: string;
|
|
scriptsig_asm: string;
|
|
witness: string[];
|
|
is_coinbase: boolean;
|
|
sequence: number;
|
|
}
|
|
|
|
export interface TransactionInfo {
|
|
txid: string;
|
|
version: number;
|
|
locktime: number;
|
|
vin: Vin[];
|
|
vout: any[];
|
|
size: number;
|
|
weight: number;
|
|
fee: number;
|
|
status: {
|
|
confirmed: boolean;
|
|
block_height: number;
|
|
block_hash: string;
|
|
block_time: number;
|
|
};
|
|
}
|
|
|
|
export function getDocumentValidation(container: HTMLElement) {
|
|
const state: State = {
|
|
file: null,
|
|
fileHash: null,
|
|
certificate: null,
|
|
commitmentHashes: [],
|
|
};
|
|
|
|
container.innerHTML = '';
|
|
container.style.cssText = `
|
|
display: flex;
|
|
flex-direction: column;
|
|
justify-content: center;
|
|
align-items: center;
|
|
min-height: 100vh;
|
|
gap: 2rem;
|
|
`;
|
|
|
|
function createDropButton(label: string, onDrop: (file: File, updateVisuals: (file: File) => void) => void, accept: string = '*/*'): HTMLElement {
|
|
const wrapper = document.createElement('div');
|
|
wrapper.style.cssText = `
|
|
width: 200px;
|
|
height: 100px;
|
|
border: 2px dashed #888;
|
|
border-radius: 8px;
|
|
display: flex;
|
|
flex-direction: column;
|
|
align-items: center;
|
|
justify-content: center;
|
|
cursor: pointer;
|
|
font-weight: bold;
|
|
background: #f8f8f8;
|
|
text-align: center;
|
|
padding: 0.5rem;
|
|
box-sizing: border-box;
|
|
`;
|
|
|
|
const title = document.createElement('div');
|
|
title.textContent = label;
|
|
|
|
const filename = document.createElement('div');
|
|
filename.style.cssText = `
|
|
font-size: 0.85rem;
|
|
margin-top: 0.5rem;
|
|
color: #444;
|
|
word-break: break-word;
|
|
text-align: center;
|
|
`;
|
|
|
|
wrapper.appendChild(title);
|
|
wrapper.appendChild(filename);
|
|
|
|
const updateVisuals = (file: File) => {
|
|
wrapper.style.borderColor = 'green';
|
|
wrapper.style.background = '#e6ffed';
|
|
filename.textContent = file.name;
|
|
};
|
|
|
|
// === Hidden file input ===
|
|
const fileInput = document.createElement('input');
|
|
fileInput.type = 'file';
|
|
fileInput.accept = accept;
|
|
fileInput.style.display = 'none';
|
|
document.body.appendChild(fileInput);
|
|
|
|
fileInput.onchange = () => {
|
|
const file = fileInput.files?.[0];
|
|
if (file) {
|
|
onDrop(file, updateVisuals);
|
|
fileInput.value = ''; // reset so same file can be re-selected
|
|
}
|
|
};
|
|
|
|
// === Handle drag-and-drop ===
|
|
wrapper.ondragover = (e) => {
|
|
e.preventDefault();
|
|
wrapper.style.background = '#e0e0e0';
|
|
};
|
|
|
|
wrapper.ondragleave = () => {
|
|
wrapper.style.background = '#f8f8f8';
|
|
};
|
|
|
|
wrapper.ondrop = (e) => {
|
|
e.preventDefault();
|
|
wrapper.style.background = '#f8f8f8';
|
|
|
|
const file = e.dataTransfer?.files?.[0];
|
|
if (file) {
|
|
onDrop(file, updateVisuals);
|
|
}
|
|
};
|
|
|
|
// === Handle click to open file manager ===
|
|
wrapper.onclick = () => {
|
|
fileInput.click();
|
|
};
|
|
|
|
return wrapper;
|
|
}
|
|
|
|
const fileDropButton = createDropButton('Drop file', async (file, updateVisuals) => {
|
|
try {
|
|
state.file = file;
|
|
updateVisuals(file);
|
|
console.log('Loaded file:', state.file);
|
|
checkReady();
|
|
} catch (err) {
|
|
alert('Failed to drop the file.');
|
|
console.error(err);
|
|
}
|
|
});
|
|
|
|
const certDropButton = createDropButton('Drop certificate', async (file, updateVisuals) => {
|
|
try {
|
|
const text = await file.text();
|
|
const json = JSON.parse(text);
|
|
if (typeof json === 'object' && json !== null && typeof json.pcd_commitment === 'object' && typeof json.state_id === 'string') {
|
|
state.certificate = json as ProcessState;
|
|
|
|
state.commitmentHashes = Object.values(json.pcd_commitment).map((h: any) => (h as string).toLowerCase());
|
|
|
|
updateVisuals(file);
|
|
console.log('Loaded certificate, extracted hashes:', state.commitmentHashes);
|
|
checkReady();
|
|
} else {
|
|
alert('Invalid certificate structure.');
|
|
}
|
|
} catch (err) {
|
|
alert('Failed to parse certificate JSON.');
|
|
console.error(err);
|
|
}
|
|
});
|
|
|
|
const buttonRow = document.createElement('div');
|
|
buttonRow.style.display = 'flex';
|
|
buttonRow.style.gap = '2rem';
|
|
buttonRow.appendChild(fileDropButton);
|
|
buttonRow.appendChild(certDropButton);
|
|
|
|
container.appendChild(buttonRow);
|
|
|
|
async function checkReady() {
|
|
if (state.file && state.certificate && state.commitmentHashes.length > 0) {
|
|
// We take the commited_in and all pcd_commitment keys to reconstruct all the possible hash
|
|
const fileBlob = {
|
|
type: state.file.type,
|
|
data: new Uint8Array(await state.file.arrayBuffer()),
|
|
};
|
|
const service = await Services.getInstance();
|
|
const commitedIn = state.certificate.commited_in;
|
|
if (!commitedIn) return;
|
|
const [prevTxid, prevTxVout] = commitedIn.split(':');
|
|
const processId = state.certificate.commited_in;
|
|
const stateId = state.certificate.state_id;
|
|
const process = await service.getProcess(processId);
|
|
if (!process) return;
|
|
|
|
// Get the transaction that comes right after the commited_in
|
|
const nextState = service.getNextStateAfterId(process, stateId);
|
|
|
|
if (!nextState) {
|
|
alert(`❌ Validation failed: No next state, is the state you're trying to validate commited?`);
|
|
return;
|
|
}
|
|
|
|
const [outspentTxId, _] = nextState.commited_in.split(':');
|
|
console.log(outspentTxId);
|
|
|
|
// Check that the commitment transaction exists, and that it commits to the state id
|
|
|
|
const txInfo = await fetchTransaction(outspentTxId);
|
|
if (!txInfo) {
|
|
console.error(`Validation error: Can't fetch new state commitment transaction`);
|
|
alert(`❌ Validation failed: invalid or non existent commited_in for state ${stateId}.`);
|
|
return;
|
|
}
|
|
|
|
// We must check that this transaction indeed spend the commited_in we have in the certificate
|
|
let found = false;
|
|
for (const vin of txInfo.vin) {
|
|
if (vin.txid === prevTxid) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
console.error(`Validation error: new state doesn't spend previous state commitment transaction`);
|
|
alert('❌ Validation failed: Unconsistent commitment transactions history.');
|
|
return;
|
|
}
|
|
|
|
// set found back to false for next check
|
|
found = false;
|
|
|
|
// is the state_id commited in the transaction?
|
|
for (const vout of txInfo.vout) {
|
|
console.log(vout);
|
|
if (vout.scriptpubkey_type && vout.scriptpubkey_type === 'op_return') {
|
|
found = true;
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
if (vout.scriptpubkey_asm) {
|
|
const hash = extractHexFromScriptAsm(vout.scriptpubkey_asm);
|
|
if (hash) {
|
|
if (hash !== stateId) {
|
|
console.error(`Validation error: expected stateId ${stateId}, got ${hash}`);
|
|
alert('❌ Validation failed: Transaction does not commit to that state.');
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
alert('❌ Validation failed: Transaction does not contain data.');
|
|
return;
|
|
}
|
|
|
|
// set found back to false for next check
|
|
found = false;
|
|
|
|
for (const label of Object.keys(state.certificate.pcd_commitment)) {
|
|
// Compute the hash for this label
|
|
console.log(`Computing hash with label ${label}`);
|
|
const fileHex = service.getHashForFile(commitedIn, label, fileBlob);
|
|
console.log(`Found hash ${fileHex}`);
|
|
found = state.commitmentHashes.includes(fileHex);
|
|
if (found) break;
|
|
}
|
|
|
|
if (found) {
|
|
alert('✅ Validation successful: file hash found in pcd_commitment.');
|
|
} else {
|
|
alert('❌ Validation failed: file hash NOT found in pcd_commitment.');
|
|
}
|
|
}
|
|
}
|
|
|
|
async function fetchTransaction(txid: string): Promise<TransactionInfo> {
|
|
const url = `https://mempool.4nkweb.com/api/tx/${txid}`;
|
|
|
|
const response = await fetch(url);
|
|
if (!response.ok) {
|
|
throw new Error(`Failed to fetch outspend status: ${response.statusText}`);
|
|
}
|
|
|
|
const outspend: TransactionInfo = await response.json();
|
|
return outspend;
|
|
}
|
|
|
|
function extractHexFromScriptAsm(scriptAsm: string): string | null {
|
|
const parts = scriptAsm.trim().split(/\s+/);
|
|
const last = parts[parts.length - 1];
|
|
|
|
// Basic validation: must be 64-char hex (32 bytes)
|
|
if (/^[0-9a-fA-F]{64}$/.test(last)) {
|
|
return last.toLowerCase();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|