Computer Science Master's Student (HPC & Distributed Systems) USTHB (M1 HPC) • research at ENSIA • Algiers, Algeria

I work on the boundary between off-chain computation and on-chain verification: how much trust can be removed from a central operator, and what it costs in bandwidth, gas, and latency. My two main projects implement the two competing answers to that question — optimistic settlement with fraud proofs, and zero-knowledge validity proofs — both applied to public-sector systems where institutions must collaborate without a trusted coordinator.

• Verifiable off-chain computation — optimistic fraud-proof settlement versus ZK validity proofs: where each pattern's cost curve wins, and how cascading invalidation behaves when dispute windows overlap with ongoing computation.
• Byzantine-robust federated aggregation — trimmed-mean and median rules, the attribution gap between statistical outlier detection and provable misbehaviour, and commit-reveal integrity under adaptive adversaries.
• Privacy-preserving public-sector infrastructure — auditability and citizen- verifiable transparency without exposing personal data to database operators.
• High-performance computing — parallel algorithms, distributed training scalability, low-latency consensus integration.

Hardware-free verifiable and Byzantine-robust federated learning, settled on-chain via 32-byte Merkle checkpoints and an optimistic fraud-proof window

Replaces TEE hardware trust assumptions in federated learning with cryptographic and statistical guarantees. Deployed and measured on live testnet.

• Commit-reveal integrity — SHA-256 commitments bound to a per-round nonce and round number; catches tamper-after-commit deterministically and names the responsible client.
• Coordinate-wise β-trimmed mean aggregation — bounds data-poisoning damage while the malicious fraction stays under β. Measured breaking point: holds at 30% malicious, collapses at 50% (β = 0.2, n = 10), with the k = ⌊βn⌋ mechanism explaining exactly why.
• O(1) on-chain settlement — one 32-byte Merkle root per round regardless of client count, against O(n) for naive full-update logging: 32 bytes vs. 30 MB at 500 clients.
• Non-interactive fraud proofs — any party holding the true commitment set calls challenge(); the contract recomputes the root on-chain and marks the round disputed. Verified against a real dropped-commitment attack on Vana Moksha testnet (postRoot 68,147 gas · challenge 59,398 gas).
• Cross-language parity, enforced in CI — the Solidity and Python Merkle implementations are checked byte-for-byte on every push, so an off-chain root and an on-chain recomputation cannot silently diverge.
• Stack: Python, scikit-learn, Flower (flwr), Solidity, Hardhat 3, viem, TypeScript.

Technical report with full benchmark tables and an explicit limitations section — data-availability gap, Sybil exposure, per-coordinate attribution limits — in REPORT.md.

Algorithmic housing-allocation notary and zero-knowledge audit portal for national public programs

An end-to-end audit pipeline for public allocation programs: citizens can independently verify their queue position and eligibility scoring, while their personal financial data stays private from database operators.

• Zero-knowledge priority verification — a ZoKrates Groth16 circuit (priority_validator.zok) proves an applicant's eligibility score was computed correctly from age, marital status, dependants, income, and disability status, without revealing any of those inputs. Verified on-chain through a Groth16 verifier contract.
• Merkle batch notarization — applicant records are hashed into deterministic keccak-256 Merkle roots and anchored on-chain by BatchRegistry.sol, with O(log n) inclusion proofs so any citizen can prove their record was in a committed batch.
• Role-based access control — OpenZeppelin AccessControl for operator/admin separation on-chain, sliding-window rate limiting and admin auth at the API layer.
• Foundry test suite — unit tests covering access control, state transitions, custom error reverts, and ZK verifier routing.
• Full stack service — FastAPI backend over PostgreSQL with an async proof-generation path, a Web3.py notary client, a chain event indexer, and a bilingual Next.js frontend supporting both LTR (English) and RTL (Arabic) layouts. Containerized via Docker Compose.
• Stack: Solidity, Foundry, ZoKrates (Groth16), Python, FastAPI, PostgreSQL, Web3.py, TypeScript, Next.js, Docker.

• Email: oussama1elottri@gmail.com
• LinkedIn: linkedin.com/in/oussama1elottri