# Stateless Verification The stateless verification model defines how IoT devices can independently validate blockchain-relevant information without maintaining persistent blockchain state. Verification relies solely on cryptographic proofs and deterministic rules, allowing correctness to be established locally regardless of data source or transport mechanism. Trusted intermediaries and long-lived local state are replaced by proof-based validation compatible with constrained, intermittently connected devices. ### Verification without Local State Stateless verification allows a device to validate blockchain-derived information without maintaining persistent local state. Instead of synchronizing headers, blocks, or execution data, verification is performed on demand using cryptographic proofs that attest to specific properties of the global system state. Two classes of proofs are fundamental to this model: **consensus proofs** and **execution proofs**. {% stepper %} {% step %} ### Consensus proofs establish that a given state or block root is finalized according to the rules of the underlying consensus protocol. They allow a device to verify that the referenced state is part of the canonical chain without tracking validator sets, forks, or historical transitions locally. {% endstep %} {% step %} ### Execution proofs attest to the correctness of state transitions and data derivation within that finalized state. They allow a device to verify that a particular value, event, or contract state follows from the execution of protocol-defined logic, without re-executing transactions or maintaining execution state. In practice, this includes proofs of account state, storage values, receipts, or application-specific outputs. {% endstep %} {% endstepper %} Together, consensus and execution proofs decouple verification from synchronization. Devices consume only the minimal information required to validate a specific claim, rather than the full chain history or ongoing state evolution. Verification cost becomes bounded and predictable, independent of chain age or activity. To further reduce verification overhead, proof systems can be compressed using zero-knowledge techniques. zk-proofs allow multiple consensus or execution statements to be aggregated into a single succinct proof with constant-size verification cost. This enables efficient validation even under strict constraints on bandwidth, memory, and computation, and allows stateless clients to scale across long time horizons without accumulating verification complexity. In this model, state is not stored but referenced, and correctness is not assumed but proven. Devices remain fully verifying participants with respect to the information they consume, while avoiding the operational and security costs associated with local state management. ### Separation of Transport, Data Source, and Verification Stateless verification separates the act of transporting data from the act of establishing its correctness. Devices accept inputs from arbitrary sources and over arbitrary channels, while verification is performed exclusively through locally checked proofs. Transport mechanisms provide availability; proofs provide correctness. This separation removes data sources from the trust boundary. RPC endpoints, gateways, caches, or peer devices may supply state references, proofs, and auxiliary data, but they do not participate in the security model. A device evaluates only whether the provided proofs are valid with respect to the protocol rules it enforces locally. Source identity and channel security are orthogonal to verification. As a consequence, multiple transport paths can be used interchangeably without affecting security properties. Data may be delivered via centralized services, decentralized networks, offline media, or intermittent links. Devices remain fully verifying as long as proofs are complete and valid, even when data is delayed, reordered, or replayed. This model also decouples security from availability. Temporary outages, provider failures, or service discontinuation do not compromise correctness guarantees. Devices may defer decisions until proofs are available, but they do not accept unverifiable information. Correctness is preserved independently of transport reliability. By enforcing verification as a local, deterministic step, stateless clients eliminate implicit trust in intermediaries. The separation of transport, data source, and verification forms the basis for robust operation across heterogeneous networks and long-lived IoT deployments. ### Resource Efficiency and Applicability to Constrained Devices Stateless verification constrains resource usage to the cost of verifying individual proofs. Computation, memory, and bandwidth requirements are bounded and independent of chain history. This enables trustless verification even on microcontroller-based and embedded devices with limited resources and intermittent connectivity, extending blockchain interaction to a class of systems previously excluded by resource constraints. --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://corpus-core.gitbook.io/iot-colibri-stateless/colibri-iot-architecture/stateless-verification.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.