// vault.jsx — «خزنة الابتكار» Innovation Vault: owner-only sealed registry for patent disclosures // DB-A (confidential): the disclosure payload, stored encoded at rest. // DB-B (registry): fingerprint + SHA-256 + trusted timestamp + PoAS metrics — what the owner manages. const VAULT_KEY_STORE = 'ibtikar_vault_key_v1'; const VAULT_OPEN = 'ibtikar_vault_open'; /* ---------- crypto helpers ---------- */ async function sha256Hex(str) { try { const buf = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(str)); return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join(''); } catch (e) { // deterministic fallback (non-secure contexts) — FNV-1a x4 lanes let out = ''; for (let lane = 0; lane < 8; lane++) { let h = 2166136261 ^ lane; for (let i = 0; i < str.length; i++) { h ^= str.charCodeAt(i); h = Math.imul(h, 16777619); } out += (h >>> 0).toString(16).padStart(8, '0'); } return out; } } function b64enc(str) { const bytes = new TextEncoder().encode(str); let bin = ''; for (let i = 0; i < bytes.length; i += 4096) bin += String.fromCharCode.apply(null, bytes.subarray(i, i + 4096)); return btoa(bin); } function b64dec(b64) { const bin = atob(b64); const bytes = new Uint8Array(bin.length); for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i); return new TextDecoder().decode(bytes); } /* ---------- PoAS metrics derived deterministically from the sealed hash (owner can override) ---------- */ function metricsFromHash(hex) { const n = (i) => parseInt(hex.slice(i, i + 2), 16) / 255; return { INV: +(7 + n(0) * 2.8).toFixed(1), INN: +(7.5 + n(2) * 2).toFixed(1) }; } function synergyScore(INV, INN) { return +(((INV + INN) / 2)).toFixed(2); } /* ---------- seal a disclosure → vault entry ---------- */ async function sealDisclosure(rec, override, prev) { const pick = (v) => (v == null ? '' : (typeof v === 'object' ? (v.ar || v.en || '') : v)); const concept = { kind: rec.kind || 'idea', title: rec.title || '', author: rec.inventors || rec.name || '', field: pick(rec.field) || pick(rec.category) || pick(rec.dept), abstract: rec.abstract || rec.solution || '', novelty: rec.novelty || rec.impact || '', problem: rec.challenge || '', stage: pick(rec.stage), files: (rec.files || []).map(f => f.name || ''), }; const conceptJson = JSON.stringify(concept, Object.keys(concept).sort()); const preHash = await sha256Hex(conceptJson); const base = override || (prev && prev.metrics) || metricsFromHash(preHash); const score = synergyScore(base.INV, base.INN); const full = await sha256Hex(JSON.stringify({ inventor: concept.author, idea: conceptJson, score })); const ver = prev ? +(prev.version + 0.1).toFixed(1) : 1.0; return { ref: rec.ref, kind: rec.kind || 'idea', fingerprint: `PoAS-v1::${full.slice(0, 10).toUpperCase()}::Score:${score}`, hash: full, conceptHash: preHash, sealedAt: new Date().toISOString(), version: ver, metrics: base, score, cipher: b64enc(conceptJson), prevHash: prev ? prev.hash : null, }; } async function verifySeal(entry) { const conceptJson = b64dec(entry.cipher); const preHash = await sha256Hex(conceptJson); const concept = JSON.parse(conceptJson); const full = await sha256Hex(JSON.stringify({ inventor: concept.author || concept.inventors || '', idea: conceptJson, score: entry.score })); return preHash === entry.conceptHash && full === entry.hash; } /* ---------- the vault panel (rendered inside the owners' admin only) ---------- */ function InnovationVault({ t, L, data, save, auth }) { const toast = useToast(); const hasKey = !!localStorage.getItem(VAULT_KEY_STORE); const [unlocked, setUnlocked] = React.useState(() => sessionStorage.getItem(VAULT_OPEN) === '1'); const [sel, setSel] = React.useState(null); const [tab, setTab] = React.useState('all'); const [showLog, setShowLog] = React.useState(false); const patents = (data.submissions && data.submissions.patents) || []; const ideas = (data.submissions && data.submissions.ideas) || []; const all = [...patents.map(p => ({ ...p, kind: 'patent' })), ...ideas.map(i => ({ ...i, kind: 'idea' }))]; const vault = data.vault || {}; const log = data.vaultLog || []; const who = (auth && auth.user) ? L(auth.user.name) : '—'; const writeVault = React.useCallback((mutate) => { const next = structuredClone(data); next.vault = { ...(next.vault || {}) }; next.vaultLog = (next.vaultLog || []).slice(); mutate(next); save(next); }, [data, save]); const addLog = (next, action, ref) => { next.vaultLog.unshift({ at: new Date().toISOString(), who, action, ref: ref || '—' }); next.vaultLog = next.vaultLog.slice(0, 60); }; // auto-seal any disclosure that arrived without a seal React.useEffect(() => { if (!unlocked) return; const missing = patents.filter(p => !vault[p.ref]); if (!missing.length) return; let dead = false; (async () => { const entries = []; for (const p of missing) entries.push(await sealDisclosure({ ...p, kind: 'patent' })); if (dead) return; writeVault(next => { entries.forEach(e => { next.vault[e.ref] = e; }); addLog(next, 'seal', entries.map(e => e.ref).join(', ')); }); })(); return () => { dead = true; }; }, [unlocked, patents.length]); // convert any submission (idea or patent) into a sealed fingerprint on demand const sealNow = React.useCallback(async (subs) => { const list = Array.isArray(subs) ? subs : [subs]; const entries = []; for (const s of list) entries.push(await sealDisclosure(s, null, vault[s.ref] || null)); writeVault(next => { entries.forEach(e => { next.vault[e.ref] = e; }); addLog(next, 'seal', entries.map(e => e.ref).join(', ')); }); toast(t('vlt_sealed_ok')); return entries[0]; }, [vault, writeVault]); const sealedRows = all.map(p => ({ p, s: vault[p.ref] })).filter(x => x.s) .filter(x => tab === 'all' || x.p.kind === tab) .sort((a, b) => b.s.score - a.s.score); const unsealed = all.filter(p => !vault[p.ref]).filter(x => tab === 'all' || x.kind === tab); const rows = sealedRows; const top = rows[0]; const last = rows.reduce((m, r) => (!m || r.s.sealedAt > m ? r.s.sealedAt : m), null); const exportRegistry = (withCipher) => { const payload = { exportedAt: new Date().toISOString(), by: who, db: withCipher ? 'A · confidential' : 'B · registry', entries: rows.map(({ p, s }) => withCipher ? s : { ref: s.ref, fingerprint: s.fingerprint, hash: s.hash, sealedAt: s.sealedAt, version: s.version, metrics: s.metrics, score: s.score, inventor: p.inventors }), }; const a = document.createElement('a'); a.href = URL.createObjectURL(new Blob([JSON.stringify(payload, null, 2)], { type: 'application/json' })); a.download = `innovation-vault-${withCipher ? 'A' : 'B'}-${new Date().toISOString().slice(0, 10)}.json`; a.click(); URL.revokeObjectURL(a.href); writeVault(next => addLog(next, withCipher ? 'export-A' : 'export-B')); toast(t('vlt_exported')); }; if (!unlocked) return { sessionStorage.setItem(VAULT_OPEN, '1'); setUnlocked(true); }} />; return (
{t('vlt_title')}

{t('vlt_sub')}

{[[rows.length, t('vlt_assets')], [top ? top.s.score : '—', t('vlt_top')], [last ? new Date(last).toISOString().slice(0, 10) : '—', t('vlt_last')]].map(([v, k], i) => (
{v}{k}
))}
{/* filter by kind */}
{[['all', t('vlt_tab_all')], ['idea', t('vault_ideas')], ['patent', t('vault_patents')]].map(([k, lbl]) => ( ))}
{/* not-yet-sealed submissions — one click turns any of them into a fingerprint */} {unsealed.length > 0 && (
{t('vlt_unsealed')} · {unsealed.length}
{unsealed.map(u => (
{u.ref} {u.title || '—'}
))}
)} {rows.length === 0 ? (

{t('vlt_empty')}

) : (
{rows.map(({ p, s }, i) => ( ))}
)}
setSel(null)} max={660}> {sel && setSel(null)} onLog={(action) => writeVault(next => addLog(next, action, sel.s.ref))} onReseal={async (m) => { const fresh = await sealDisclosure(sel.p, m, sel.s); writeVault(next => { next.vault[fresh.ref] = fresh; addLog(next, 'reseal v' + fresh.version.toFixed(1), fresh.ref); }); setSel({ p: sel.p, s: fresh }); toast(t('vlt_resealed')); }} />} setShowLog(false)} max={560}>
{t('vlt_log')}
{log.length === 0 ?

{t('vlt_log_empty')}

: (
{log.map((l, i) => (
{l.who} · {l.action}{l.ref !== '—' ? ` · ${l.ref}` : ''} {new Date(l.at).toISOString().replace('T', ' ').slice(0, 16)}
))}
)}
); } /* ---------- lock screen: create or enter the vault key ---------- */ function VaultLock({ t, L, hasKey, onOpen }) { const [k1, setK1] = React.useState(''); const [k2, setK2] = React.useState(''); const [err, setErr] = React.useState(null); const submit = async (e) => { e.preventDefault(); if (!hasKey) { if (k1.length < 6) return setErr(t('vlt_err_short')); if (k1 !== k2) return setErr(t('vlt_err_match')); localStorage.setItem(VAULT_KEY_STORE, await sha256Hex('ibtikar::' + k1)); return onOpen(); } const h = await sha256Hex('ibtikar::' + k1); if (h !== localStorage.getItem(VAULT_KEY_STORE)) return setErr(t('vlt_err_key')); onOpen(); }; return (
{t('vlt_title')}

{hasKey ? t('vlt_locked') : t('vlt_setup')}

{hasKey ? t('vlt_locked_d') : t('vlt_setup_d')}

{ setK1(e.target.value); setErr(null); }} placeholder={t('vlt_key')} autoComplete="new-password" /> {!hasKey && { setK2(e.target.value); setErr(null); }} placeholder={t('vlt_key2')} autoComplete="new-password" />} {err &&
{err}
} {hasKey && }
); } /* ---------- one sealed asset ---------- */ function VaultEntry({ t, L, entry, onClose, onLog, onReseal }) { const { p, s } = entry; const [plain, setPlain] = React.useState(null); const [check, setCheck] = React.useState(null); const [m, setM] = React.useState(s.metrics); const [copied, setCopied] = React.useState(false); React.useEffect(() => { setPlain(null); setCheck(null); setM(s.metrics); }, [s.hash]); const reveal = () => { setPlain(JSON.parse(b64dec(s.cipher))); onLog('decrypt'); }; const verify = async () => { setCheck(await verifySeal(s) ? 'ok' : 'bad'); onLog('verify'); }; const copy = () => { copyText(s.fingerprint); setCopied(true); setTimeout(() => setCopied(false), 1600); }; const dirty = m.INV !== s.metrics.INV || m.INN !== s.metrics.INN; const meta = [ [t('vlt_f_hash'), s.hash], [t('vlt_f_time'), new Date(s.sealedAt).toISOString().replace('T', ' ').slice(0, 19) + ' UTC'], [t('vlt_f_ver'), 'v' + s.version.toFixed(1) + (s.prevHash ? ` · ${t('vlt_prev')} ${s.prevHash.slice(0, 8)}` : '')], ]; return (
{s.ref}

{p.title || '—'}

{p.inventors || p.name || '—'}
{t('vlt_f_fp')}
{s.fingerprint}
{check &&
{check === 'ok' ? <> {t('vlt_ok')} : <> {t('vlt_bad')}}
}
{meta.map(([k, v], i) => (
{k}
{v}
))}

{t('vlt_pdf_d')}

{t('vlt_metrics')}
{[['INV', t('vlt_inv')], ['INN', t('vlt_inn')]].map(([k, lbl]) => ( ))}
{t('vlt_score')} {synergyScore(m.INV, m.INN)}
{t('vlt_cipher')}
{!plain ? ( <> 
{s.cipher}
) : (
{[[t('pf_field'), plain.field], [t('f_challenge'), plain.problem], [t('pf_abstract'), plain.abstract], [t('pf_novel'), plain.novelty], [t('pf_stage'), plain.stage]].filter(([, v]) => v).map(([k, v], i) => (
{k}
{v}
))}
)}
); } Object.assign(window, { InnovationVault, VaultLock, VaultEntry, sealDisclosure, verifySeal, sha256Hex, b64enc, b64dec, synergyScore, metricsFromHash });