papers/lux-tee-computing-mesh/sections/02-system-architecture.tex

\section{System Architecture}


\subsection{Threat Model}

We operate under the following assumptions:

\begin{itemize}
  \item \textbf{Hardware TEEs are trusted}: We assume Intel SGX/TDX, AMD SEV-SNP, and NVIDIA Hopper TEEs provide memory encryption and attestation as specified. Known side-channel attacks (e.g., Spectre, LVI) are mitigated through microcode patches \cite{sgx-attacks}.

  \item \textbf{L1 blockchain is Byzantine fault-tolerant}: The base layer (Lux Appchain or equivalent) achieves consensus correctly under $f < n/3$ adversarial validators \cite{avalanche-consensus}.

  \item \textbf{Workers are rational}: Worker nodes maximize profit but will act maliciously if rewards exceed slashing penalties.

  \item \textbf{Attestation root certificates are authentic}: Intel, AMD, and NVIDIA root CA certificates are distributed via secure channels.
\end{itemize}

We \textit{do not} assume:
\begin{itemize}
  \item Workers run on trusted hardware platforms (cloud operators can be adversarial)
  \item Network-level anonymity (Tor/VPN usage is orthogonal)
  \item Protection against quantum attacks (post-quantum upgrade path is future work)
\end{itemize}

\subsection{System Roles}

The Lux TEE Mesh consists of four primary actors:

\begin{enumerate}
  \item \textbf{Job Submitter}: A smart contract or externally owned account (EOA) that encrypts workload data, posts a \texttt{Lux.submit()} transaction, and pays computation fees.

  \item \textbf{Worker Node}: A server running TEE hardware (SGX/TDX/SEV-SNP/GPU) that pulls jobs from the gossip network, executes them inside enclaves, and submits attestation receipts to the L1.

  \item \textbf{Verifier Contract}: An on-chain smart contract that validates TEE attestation quotes, checks Merkle roots, credits workers, and emits results to job submitters.

  \item \textbf{Scheduler Mesh}: A peer-to-peer gossip network using ZAP gossip where workers subscribe to job announcements. No centralized coordinator exists.
\end{enumerate}

\subsection{Data Flow}

Figure \ref{fig:dataflow} illustrates the six-packet data flow:

\begin{figure}[h]
\centering
\begin{verbatim}
(1) tx Lux.submit()  ------------------+
                                       v
(2) job envelope  --gossip--$\blacktriangleright$ worker (SGX/SEV/GPU)
                                       |
(3) enclave decrypts, runs, emits proof
                                       v
(4) attestation + result  --tx--$\blacktriangleright$ L1.Verifier
                                       |
(5) contract verifies quote & root   |
                                       v
(6) emits JobCompleted(event) -> caller
\end{verbatim}
\caption{Lux TEE Mesh data flow}
\label{fig:dataflow}
\end{figure}

\textbf{Step 1}: Job submitter encrypts code and inputs using the worker's public key, then posts \texttt{Lux.submit()} with IPFS CID, gas limit, and payment.

\textbf{Step 2}: Transaction is included in an L1 block. Workers subscribed to the gossip channel receive the job envelope.

\textbf{Step 3}: A chosen worker (via auction or random selection) decrypts the payload inside the TEE, executes the code, and generates an attestation quote binding the code hash, input hash, and Merkle root of the execution trace.

\textbf{Step 4}: Worker submits \texttt{submitResult()} transaction containing the encrypted result, attestation quote, and Merkle root.

\textbf{Step 5}: The verifier contract parses the quote, validates the signature chain to the vendor's root CA, checks that the payload hash matches, and verifies the Merkle root integrity.

\textbf{Step 6}: If verification succeeds, the contract emits \texttt{JobCompleted} event with the result, pays the worker, and optionally invokes a callback on the submitter contract.