linera-io/linera-protocol
Linera Protocol
Linera is a multi-chain smart contract platform designed for horizontal scalability through a microchain-based distributed ledger. By partitioning state into independent, parallel chains that share a common validator set, the protocol enables high-performance execution of modular applications. The system utilizes a WebAssembly-based runtime to ensure secure, platform-independent execution of contract logic across the network.
The platform distinguishes itself through an asynchronous messaging framework that coordinates state changes between chains by queuing messages for execution in subsequent block production cycles. Applications follow a dual-component model that separates state-modifying contract logic from gas-free, read-only service queries, facilitating efficient data access for frontends and AI agents. Furthermore, the protocol offers flexible governance, allowing individual chains to switch between single-owner and multi-leader consensus rounds to meet specific latency and contention requirements.
Developers can build and compose distributed applications that leverage cross-chain communication and atomic state updates. The ecosystem supports native integration with web browsers through WebAssembly client libraries, enabling responsive frontend development and direct interaction with on-chain state. Additionally, the platform provides standardized interfaces for AI agent integration and external wallet support, alongside a command-line interface for managing deployments, developer identities, and local testing environments.
Features
- State Sharding Architectures - A scaling mechanism that distributes application state across multiple microchains while maintaining atomic consistency through bundled message groups.
- Distributed Computing Frameworks - Interact with applications using operations for local chain execution and messages for cross-chain communication to ensure atomicity through bundled message groups.
- Smart Contract Development Frameworks - Utilize a decentralized network architecture that manages state across independent chains to enable scalable and asynchronous cross-chain computation.
- WebAssembly - A sandboxed execution environment runs compiled bytecode to ensure platform-independent, secure, and performant smart contract logic.
- Distributed Ledger Architectures - Implements a scalable microchain architecture to distribute state and computation across independent chains for high performance.
- Distributed Smart Contract Frameworks - Writing and deploying modular application logic that executes across a network of chains with built-in support for cross-application composition.
- Distributed Ledger Orchestration - Create and manage scalable chains that share validators and security to enable distributed application state with asynchronous cross-chain communication.
- Cross-Chain Communication Protocols - Enabling secure and reliable interaction between separate blockchain instances through message passing and atomic cross-chain state updates.
- Cross-Chain Messaging Protocols - A communication model where messages are queued in target chain inboxes to be processed during subsequent block production cycles.
- Runtime Environments - Deploy and run virtual machine bytecode within chains to allow for the migration of existing contracts and cross-chain messaging via compatibility libraries.
- Distributed Application Frameworks - Deploy and compose applications that distribute computation across chains using asynchronous messaging, shared data, and event streams.
- Multi-Chain Smart Contract Platforms - Provides a development environment for deploying and composing stateful applications across distributed microchains.
- Real-time Data Synchronization - Sync on-chain data in real-time using local clients to enable trustless, low-latency interactions for web frontends and AI agents without relying on third-party services.
- Developer Wallet Managers - Create developer identities and switch between multiple configurations to handle diverse network environments and storage paths within the command-line interface.
- Message Passing Protocols - Cross-chain communication occurs by queuing messages in target chain inboxes for execution during subsequent block production cycles.
- Authentication Strategies - Propagate the block signer's authority across chains to ensure consistent state management and secure operations on networks that do not support direct user ownership.
- Application Architectures - A design pattern separating state-modifying contract logic from gas-free, read-only service queries for efficient frontend data access.
- Blockchain Governance Models - Linera provides a flexible governance model allowing chains to switch between single-owner and multi-leader consensus rounds based on specific latency and contention requirements.
- Cross-Application Orchestration - Coordinate synchronous calls between applications on a single chain and propagate user authentication across different chains using bundled messages to maintain security and context.
- Blockchain AI Agent Integrations - Connecting autonomous AI agents to blockchain data and state through standardized interfaces to automate complex tasks and decision-making processes.
- Blockchain Infrastructure - Scalable, low-latency blockchain infrastructure.
- Database Sharding Strategies - State is partitioned into independent, parallel chains that share a common validator set to achieve horizontal scalability and performance.
- State Query Interfaces - Access application data through specific query endpoints to explore current state and execute operations via a browser-based interface for testing and management.
- Governance Frameworks - Chains utilize a flexible consensus model that allows switching between single-owner and multi-leader rounds based on specific requirements.
- State Management Patterns - Load data, execute operations, and persist results back to storage using standard lifecycle methods to manage state changes within the application binary.
- Testing Frameworks - Verify application behavior using unit tests with mock runtimes or integration tests with simulated validators to validate complex multi-chain interactions.
- Edge Inference Engines - Execute machine learning models on the edge by splitting logic between a consensus-backed contract and an off-chain service running in a virtual machine.
- Wallet Integrations - Sign transactions using external software or hardware wallets by implementing a standard interface that enables communication with various secure signing providers.
- Component Architectures - Organize application logic into a gas-metered contract for state-modifying operations and a non-metered service for read-only state queries and frontend data population.
- Web3 Frontend Frameworks - Building responsive browser-based applications that interact directly with blockchain state using low-latency queries and native WebAssembly client libraries.
- WebAssembly Interoperability - A compilation strategy that exposes native protocol libraries to web browsers by wrapping Rust code in JavaScript-compatible interfaces.
- AI Agent Interfaces - Configure the query service as a model context server to enable AI agents to interact with application data and automate tasks through standardized interfaces.
- Decentralized Data Query Services - Exposes structured application data to frontends and agents through a gas-free read-only query interface.
- Application Deployment Tools - Publish application bytecode to networks by configuring wallets and using command-line tools to instantiate applications on target chains.
- Binary Interfaces - Specify data structures, operations, and responses for contract and service components by implementing traits that define how different parts of an application communicate.
- System Query Interfaces - Retrieve system-level information and chain state using a query interface exposed by the node service for administrative tasks and general chain management.
- Web Assembly Bindings - Convert core logic into web-compatible formats by compiling code to binary modules and wrapping them with language-specific interfaces for integration into browser environments.
