# Stateless Blockchain Client Colibri addresses the structural limitations of current IoT architectures by enabling local, trustless verification on resource-constrained devices. Instead of delegating security-critical decisions to centralized services, **colibri.stateless** allows devices to independently validate external information using cryptographic proofs. This shifts trust from operators and intermediaries to verifiable system properties. The architecture is designed for environments where devices are long-lived, intermittently connected, and embedded into operational infrastructure. Stateless verification replaces persistent local state and trusted gateways with deterministic, proof-based validation, forming the foundation for secure interaction without centralized control. #### The colibri.stateless Blockchain-Client **colibri.stateless** is a fully verifying, stateless client designed for IoT, embedded, and mobile environments. It allows devices to validate blockchain-derived state and events without maintaining local blockchain state or relying on trusted RPC endpoints. The client verifies cryptographic proofs that attest to both consensus and execution correctness. As a result, devices can independently assess the validity of received data, commands, or state transitions, regardless of their source. External services may provide data and proofs, but correctness is established locally. By eliminating persistent state and trusted intermediaries, **colibri.stateless** decouples verification from availability and operator trust. Devices remain verifiable under intermittent connectivity and constrained resources, while security-critical decisions are enforced locally rather than delegated to external infrastructure. Detailed technical specifications of **colibri.stateless**, including proof formats, verification logic, and protocol interfaces, are defined in the [Whitepaper](https://corpus-core.gitbook.io/whitepaper-colibri-stateless) and the accompanying technical [Specification](https://corpus-core.gitbook.io/specification-colibri-stateless). #### Why blockchain enables trustless verification for IoT Blockchain provides a globally consistent state machine whose transitions are cryptographically verifiable. State changes are derived from agreed-upon rules and validated by a decentralized consensus process, producing proofs that can be checked independently by any party. Correctness is therefore a property of the system itself rather than of the entity distributing the data. For IoT devices, this property is decisive. Devices frequently consume information originating outside their trust domain, including configuration updates, access rights, payments, and coordination signals. Blockchain allows such information to be accompanied by compact proofs that attest to both state validity and authorization, enabling devices to verify correctness locally without trusting the source. Decentralization is essential to this model. A single operator or service cannot unilaterally define system state or revoke correctness guarantees. Trust is shifted away from service providers and intermediaries toward a shared, verifiable protocol. Devices interact with the blockchain through untrusted transport channels, while validation is performed locally. Beyond value transfer, blockchain supports programmable state transitions through smart contracts. This enables on-chain representation of rights, permissions, and conditional logic that can be verified by devices in the same manner as financial transactions. For IoT systems, this unifies payments, access control, and coordination under a single verifiable framework. In this context, blockchain serves as a verification substrate rather than as a runtime dependency. Devices do not execute contracts or maintain global state. They consume proofs of specific state transitions and validate them deterministically, making trustless interaction feasible under the resource and connectivity constraints of IoT environments. This model naturally extends to Layer‑2 systems. Stateless clients can validate state transitions originating from both Layer‑1 and Layer‑2 blockchains, as long as the corresponding proofs can be verified locally. This enables devices to interact with application‑specific or domain‑optimized execution environments while retaining security guarantees anchored in the underlying base layer. As a result, IoT deployments can leverage tailored scalability, cost, and latency characteristics without introducing new trust assumptions. --- # 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-blockchain-client.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.