linera-io/linera-protocol

This system is the Linera protocol, a blockchain infrastructure that enables the creation and execution of decentralized applications via WebAssembly contracts and an integrated EVM runtime. It provides a comprehensive SDK for building Rust-based applications, including examples for fungible tokens, NFTs, and cross-chain bridges, alongside robust tooling for local development, testing, and deployment. The platform features a formalized consensus mechanism with mathematical safety proofs, a modular architecture supporting multiple database backends, and extensive observability through Prometheus metrics and OpenTelemetry tracing.

83 changes.

This period established the foundational structure of the Linera protocol, introducing the core Rust crates for the blockchain engine, storage abstractions, and RPC layer. It also delivered the initial Linera SDK for Rust application development, complete with WIT-based WebAssembly interop and a suite of example applications to demonstrate usage.

85 changes.

This period focused on integrating Ethereum Virtual Machine (EVM) support through new execution modules, Solidity bindings, and secp256k1 crypto compatibility. It also expanded the platform's infrastructure with a shared gRPC storage service, a new blockchain indexer, and a comprehensive WebAssembly client API for browser environments.

38 changes.

This period focused on building a comprehensive cross-chain bridge between Linera and EVM-compatible networks, including the development of light client contracts, deposit proof generation, and wrapped token examples. Concurrently, the team established a rigorous formal verification framework, adding mathematical proofs for consensus safety, liveness, and accountability to ensure the protocol's correctness.

A new example application, Counter No GraphQL, has been added to demonstrate a simple counter contract that operates without GraphQL. The application allows users to initialize a counter with a \u64\ value and increment it via operations, with the service layer exposing query and increment capabilities. This example serves as a reference for building Linera applications that do not rely on GraphQL for interaction.

examples/counter-no-graphql · high confidence

The \linera-bridge/src/proof\ module now provides the cryptographic infrastructure for bridging deposits from EVM chains (such as Base L2) to Linera. It introduces an off-chain \HttpDepositProofClient\ that queries standard Ethereum JSON-RPC endpoints to construct Merkle Patricia Trie (MPT) inclusion proofs for \DepositInitiated\ events. On the Linera side, the module implements the corresponding verification pipeline—decoding block headers, verifying receipt inclusion, and parsing deposit logs—allowing the bridge application to securely mint wrapped tokens upon proof validation.

linera-bridge/src/proof · high confidence

Introduces a new React-based web interface for the Gen-NFT example application. The frontend allows users to mint generative NFTs by providing text prompts, view their owned NFTs, and transfer them to other accounts. It connects to the backend via GraphQL, using Apollo Client to handle HTTP queries for data retrieval and WebSocket subscriptions for real-time notifications, with configuration driven by URL parameters for chain ID, application ID, and owner address.

examples/gen-nft/web-frontend · high confidence

This change introduces the GraphQL interface for the Linera indexer by adding schema definitions and client query files. The schema defines types for chain operations, block heights, and cryptographic hashes (specifically Keccak256), exposing queries to retrieve plugin lists, current chain state, and detailed operation history (including keys, content, and block references). These files provide the contract for the indexer's GraphQL API, enabling clients to query indexed blockchain data.

linera-indexer/graphql-client/gql · high confidence

A new example application demonstrating an LLM-based agent that interacts with the Linera blockchain. The agent uses an OpenAI model to generate GraphQL queries by introspecting the Linera Node Service schema and submits them via a custom tool, allowing users to query chain state through natural language.

examples/agent · high confidence

A new React-based web application called 'Linera Stories' has been added to the examples directory. This frontend provides a chat interface that connects to a deployed Linera application via GraphQL (using Apollo Client) over HTTP and WebSocket links. It allows users to interact with the 'Linera Stories' service to generate collaborative stories, featuring a chat UI with typing indicators and message history. The application is configured to run on port 3000 and requires a backend Node Service running on port 8080.

examples/llm/web-frontend · high confidence

A new demo application has been added under examples/native-fungible/metamask that showcases personal chains, real-time transfers, and trustless user interfaces in Linera, with transactions signed by MetaMask. The entry point is index.html, which provides a UI for viewing account details, balances, and initiating transfers, while requiring MetaMask to be installed and connected. The application uses Vite for building, configured in vite.config.ts to enforce specific environment variables (LINERA\_FAUCET\_URL, LINERA\_APPLICATION\_ID) and set cross-origin headers. Supporting assets like style.css, icon.png, and arrow.svg are included as symlinks to shared resources.

examples/native-fungible/metamask · high confidence

A new Nix expression (nix/symbolicator.nix) has been added to build the Symbolicator native symbolication service, specifically version 26.3.0 from the getsentry repository. This build configuration includes necessary dependencies such as OpenSSL, Zstd, and Bzip2, and sets environment variables to identify the build version. This change supports the broader effort to make built artifacts compatible with Sentry's Wasm integration by ensuring the symbolicator component is correctly packaged within the Nix build pipeline.

nix · high confidence

Introduces a new example application in \examples/rfq\ that demonstrates atomic swaps on the Linera protocol. The application allows users to request, provide, accept, and finalize quotes for exchanging fungible tokens across different chains, utilizing temporary chains for secure, atomic settlement. It includes the contract logic (\contract.rs\), service layer (\service.rs\), state management (\state.rs\), and ABI definitions (\lib.rs\), along with a comprehensive \README.md\ detailing setup and usage via the GraphiQL interface.

examples/rfq · high confidence

This change introduces the Task Processor example application, which demonstrates off-chain task processing capabilities. The application allows users to request tasks from external operators via GraphQL mutations (\request\_task\, \request\_task\_on\) and stores the results in the application state. It manages a queue of pending tasks and handles task outcomes independently, ensuring that successful results are stored even if earlier tasks in the queue are still pending or failing. The implementation includes the contract logic for state management, a service layer for GraphQL queries and task scheduling, and format tests to verify ABI serialization.

examples/call-evm-counter, examples/task-processor · high confidence

The linera-witty library now includes a new wit\_generation module that allows users to programmatically generate WIT (WebAssembly Interface Types) files. This feature introduces the WitInterface trait for defining interface snippets, along with WitInterfaceWriter and WitWorldWriter helpers to serialize these definitions into standard WIT format. To support compile-time type checking without requiring runtime execution, a StubInstance type is provided, implementing the necessary instance traits with unimplemented stubs.

_linera-witty/src/wit\generation · high confidence

Witty now supports the Wasmtime runtime alongside Wasmer, allowing host applications to execute guest WebAssembly modules using Wasmtime. This change introduces the necessary infrastructure to export host functions to Wasmtime instances, call guest functions, and manage memory access within the Wasmtime environment, enabling developers to choose Wasmtime as their execution backend.

linera-witty/src/runtime/wasmtime · high confidence

The linera-service module now includes a README.md describing its role in providing executables for operating a Linera service, including a placeholder wallet acting as a GraphQL service. Additionally, a build.rs script has been added to define conditional compilation flags (cfg\_aliases) for features such as revm, testing, and metrics, ensuring these capabilities are correctly enabled or disabled based on the build configuration.

linera-service · high confidence

The \linera-witty\ library now includes a new \util\ module providing helper traits for manipulating heterogeneous lists at compile time. This adds a \Merge\ trait to combine two heterogeneous lists into one containing \Either\ variants, a \Split\ trait to divide a list at a specific point, and a \ZeroExtend\ trait for safe zero-extension of integer types (specifically \i32\ to \i64\). These utilities support internal type-level operations within the library.

linera-witty/src/util · high confidence

The linera-cache crate is introduced with a README.md explaining its caching utilities for the Linera protocol, including hash-consing and the 'one allocation per content' invariant, and a build.rs file configuring target-specific aliases for web, metrics, and testing features.

linera-cache · high confidence

A new test utility module has been introduced in \linera-ethereum/src/test\_utils\ to facilitate testing Ethereum interactions. This includes an \EthereumClient\ wrapper around the \alloy\ provider, an \AnvilTest\ struct that manages a local Anvil node instance, and helper structs (\SimpleTokenContractFunction\, \EventNumericsContractFunction\) for deploying and interacting with sample smart contracts. These utilities allow tests to spin up a local Ethereum environment, deploy contracts, and execute operations like \balanceOf\ and \transfer\ against a controlled node.

_linera-ethereum/src/test\utils · high confidence

The linera-core module now includes a README.md file that describes the module's purpose as defining the core Linera protocol and points to contributing and license information. Additionally, a build.rs script has been added to configure build-time aliases for target architectures and features, specifically defining cfg flags for web, testing, metrics, and getrandom availability to support conditional compilation across different environments.

linera-core · high confidence

A new command-line tool, \wit\_generator\, has been added to the \linera-execution\ crate. This utility generates WebAssembly Interface Types (WIT) files that define the interfaces between Linera applications (contracts and services) and the node runtime. It supports writing these files to a specified base directory (defaulting to \linera-sdk/wit\) or checking existing files for correctness, ensuring the generated interface definitions match the current Rust API definitions.

linera-execution/src/bin · high confidence

The Witty framework now includes a new Wasmer runtime implementation, enabling host applications to export functions to and import functions from WebAssembly modules executed by Wasmer. This addition introduces core infrastructure for managing the Wasmer execution environment, including instance building, memory access (read/write operations), and function call handling for signatures with up to 17 parameters. It also provides type conversions for function parameters and results to ensure compatibility with Wasmer's native types, allowing developers to leverage Wasmer as a backend for their Witty-based Wasm interactions.

linera-witty/src/runtime/wasmer · high confidence

The linera-storage crate now includes a README.md file that describes the module's purpose as defining storage abstractions for individual chains and certificates, along with contributing and licensing information. Additionally, a build.rs script has been added to configure conditional compilation flags for testing, metrics, WASM runtimes (Wasmer and Wasmtime), and the REVM runtime, ensuring the correct features are enabled based on the target architecture and selected features.

linera-storage · high confidence

The counter example application is now available in the examples directory, providing a simple on-chain counter that can be initialized with a u64 value and incremented via operations. The implementation includes a Rust contract and service using the new SDK traits (Contract, Service) with associated types for ABI, state management via RootView, and GraphQL query/mutation support. A web frontend is included with Vite configuration, Playwright testing setup, and integration with the Linera client SDK for real-time state updates and transaction submission.

examples/counter · high confidence

The faucet functionality has been extracted into a new \linera-faucet\ crate, organized into client and server modules with corresponding README documentation. The server component now includes a build script that enables optional metrics collection via a feature flag, allowing users to monitor faucet operations when the metrics feature is enabled.

linera-faucet · high confidence

The Linera faucet server now uses an SQLite database to persistently track which users have been assigned chains and to enforce daily claim limits. This change adds a new \FaucetDatabase\ module that manages a \chains\ table (mapping owners to chain IDs) and a \daily\_claims\ table (tracking the last claim period per owner). The server synchronizes this local state with the blockchain history to ensure consistency, and exposes GraphQL mutations and metrics for claim requests, batch processing, and database operations. Tests have been added to verify the new database-backed claim flow.

linera-faucet/server · high confidence

The \linera-core\ crate now includes a formal proof specification for the liveness and availability properties of the microchain consensus protocol. This new \proof\ module documents the assumptions required for progress (such as eventual synchrony, correct validator availability, and the presence of an active client driver) and proves that certified blocks and their dependencies are retrievable by any node, ensuring that recovering or joining validators can catch up. It also defines the scope of liveness guarantees, clarifying that progress depends on a client actively proposing blocks and that the notification channel is lossy but self-repairing.

linera-core/src/proof · high confidence

Added formal specification and safety proofs for the microchain consensus protocol in \linera-chain/src/data\_types/proof\. This new module defines the core protocol vocabulary (votes, proposals, certificates) and establishes quorum properties, providing a rigorous mathematical foundation for the consensus logic that the chain manager can cite for safety guarantees.

_linera-chain/src/data\types/proof · high confidence

The \mdbook\ directory now contains the complete configuration and assets required to build the Linera documentation site, including \book.toml\ (pointing to the \docs/\ source), custom themes, and preprocessor plugins (\mdbook-mermaid\, \mdbook-admonish\). This change introduces a new \.gitignore\ for IDE and build artifacts, adds Google Analytics tracking via \custom.js\ (disabled for local development), and configures Mermaid diagrams with a specific dark-mode color palette. It also establishes local testing procedures for the documentation build.

mdbook · high confidence

The \linera-chain\ module now exposes structured GraphQL metadata representations for system operations (such as transfers, claims, and chain management) and chain configuration settings (including timeout, ownership, and application permissions). This enables clients to query detailed, typed information about block transactions and chain state via the GraphQL API, improving visibility into system-level actions and configuration parameters.

_linera-chain/src/data\types · high confidence

This change introduces the core infrastructure for executing Ethereum Virtual Machine (EVM) smart contracts on Linera chains. It adds the \linera-execution/src/evm\ module, which integrates the Revm runtime to bridge Linera's storage and runtime layers with EVM execution. Key additions include \data\_types.rs\ for handling EVM-specific data serialization (such as \AmountU256\), \database.rs\ implementing Revm's \Database\ traits to manage state and storage, \inputs.rs\ defining precompile addresses and selectors for Linera-specific functionalities (like stream processing and account info), and \revm.rs\ providing the main execution logic, inspector patterns, and contract/service module handling. This enables EVM-based user applications to run natively within the Linera execution environment.

linera-execution/src/evm · high confidence

The \linera-ethereum\ crate is introduced, providing the foundational module for accessing an Ethereum blockchain node. This change adds the necessary build configuration (\build.rs\) and includes pre-compiled JSON artifacts for two Solidity contracts—\EventNumerics\ and \SimpleToken\—which define the ABI and bytecode required for interacting with these smart contracts within the Linera ecosystem.

linera-ethereum/src · high confidence

The \linera-service-graphql-client/gql\ directory now contains the foundational GraphQL schema (\service\_schema.graphql\) and service request queries (\service\_requests.graphql\) for the Linera service. This introduces the core data model for users to interact with the chain, including types for \Account\, \ApplicationPermissions\, \Block\, \Blob\, and \Chain\, along with queries to retrieve chain state, inbox/outbox contents, and block details.

linera-service-graphql-client/gql · high confidence

The linera-rpc module now includes the initial gRPC implementation, enabling remote procedure calls via Protocol Buffers. This change introduces a build script that compiles rpc.proto and generates a self-signed TLS certificate and private key to enable secure communication for the proxy. It also adds feature flags (server, simple-network, metrics, web) to control which network abstractions and components are compiled, and includes a README and binary format symlink for discoverability.

linera-rpc · high confidence

The \linera-rpc/proto/rpc.proto\ file introduces the initial gRPC service definitions that govern how validators and clients communicate. It defines three core services: \NotifierService\ for pushing chain update notifications, \ValidatorRelay\ for proxying requests between shards and other validators, and \ValidatorWorker\ for internal shard operations like handling block proposals and cross-chain requests. The \ValidatorNode\ service exposes the public API for clients, including methods to propose blocks, handle certificates (lite, confirmed, validated, timeout), query chain info, download blobs and certificates (including batched and raw downloads), and retrieve version and network descriptions. This establishes the foundational contract for the RPC layer.

linera-rpc/proto · high confidence

This change introduces the linera-execution crate, which manages the execution of system and user applications on a Linera chain. It establishes a build configuration (build.rs) that conditionally compiles features based on the target architecture (e.g., wasm32 vs. native) and enabled features like 'web', 'fs', 'metrics', and specific Wasm runtimes (Wasmer, Wasmtime). Additionally, it adds a script to update Wasm bytecode fixtures for testing by building example applications and copying the resulting .wasm files into the test fixtures directory.

linera-execution · high confidence

The linera-storage-service module is introduced, providing a shared key-value store server backed by RocksDB and an in-memory store, along with a client implementing the KeyValueStore and KeyValueDatabase traits. The service includes conditional compilation support for RocksDB and metrics (via cfg\_aliases), and integrates with tonic for protocol buffer compilation. A README is added to document the module's purpose and licensing.

linera-storage-service · high confidence

The linera-views crate now includes its foundational documentation and build setup. The new DESIGN.md and README.md files explain the module's core concepts, including the KeyValueStore abstraction, various view containers (such as RegisterView, MapView, and LogView), and the strategy for splitting large values across multiple keys. Additionally, the build.rs script configures compile-time feature flags to conditionally enable support for specific storage backends like RocksDB, ScyllaDB, and IndexedDB, as well as WebAssembly and metrics.

linera-views · high confidence

This change introduces the WebAssembly Interface Types (WIT) files that define the contract and service interfaces for Linera applications. The new files (\contract.wit\, \service.wit\, and their associated runtime APIs) establish the standard contract for WebAssembly modules, specifying entrypoints like \instantiate\ and \handle-query\, as well as runtime capabilities for chain management, event streaming, HTTP requests, and resource accounting. These definitions serve as the foundational API contract for application developers and are generated by the \wit-generator\ tool.

linera-sdk/wit · high confidence

The linera-base crate is introduced as a new module providing common types and library functions shared between the Linera protocol (compiled to native code) and Linera applications (compiled to Wasm). The crate includes a build script that configures target-specific compilation flags for Web, Chain, metrics, reqwest, testing, and REVM features, along with a README documenting its purpose and licensing under Apache 2.0.

linera-base · high confidence

The linera-sdk crate is introduced, providing the foundational tools for building Linera applications in Rust. It defines the Contract and Service traits, along with their respective runtime contexts (ContractRuntime and ServiceRuntime), which allow developers to create WebAssembly binaries that interact with persistent, lazily-loaded application state via linera-views. The SDK includes build-time configuration via build.rs to enable testing and Wasm runtime features, and documentation references the examples directory for sample applications.

linera-sdk · high confidence

The \linera-sdk\ crate is introduced, providing the foundational framework for building Linera applications in Rust. It defines the core \Contract\ and \Service\ traits that applications must implement, along with the \contract!\ and \service!\ macros to export their implementations. The SDK exposes runtime interfaces via \ContractRuntime\ and \ServiceRuntime\, allowing applications to interact with the chain state, handle operations, messages, and queries. It includes support for binary serialization formats (BCS) and GraphQL interfaces, as well as specific utilities for Ethereum integration (\ethereum.rs\) and logging (\log.rs\). This change establishes the basic API surface for application development, including the necessary types for state management, system API calls, and event handling.

linera-sdk/src · high confidence

This change introduces a new React-based web application for interacting with Non-Fungible Tokens (NFTs) on the Linera network. The frontend allows users to view their owned NFTs, mint new ones by uploading images as data blobs, and transfer NFTs to other accounts. It is built using Create React App, styled with Ant Design components, and connects to the Linera node service and application via GraphQL (Apollo Client) for both HTTP queries and WebSocket subscriptions.

examples/non-fungible/web-frontend · high confidence

This change establishes the foundational structure for the Linera protocol repository. It introduces a Nix flake (\flake.nix\, \flake.lock\, \default.nix\) and a \Makefile\ to automate building, testing, and deploying example applications (such as the counter and fungible token apps) to public demo infrastructure. It also adds essential developer tooling configurations, including \.editorconfig\, \rustfmt.toml\, \clippy.toml\, and \.taplo.toml\ for consistent code formatting and linting, alongside \.dockerignore\ and \.gcloudignore\ to optimize build contexts. Documentation is standardized with new \CLI.md\, \CONTRIBUTING.md\, and \INSTALL.md\ files, and the repository is initialized with a \packages.txt\ listing the crates intended for publication.

(repo-wide) · high confidence

This change introduces the foundational structure for the Linera Explorer, a web-based block explorer. It adds configuration files for the Vite build system and TypeScript, sets up Vitest for testing, and defines GraphQL code generation scripts to create TypeScript types from Linera service and indexer schemas. The entry also includes the main HTML entry point, a README with build instructions, and a .gitignore file to manage build artifacts.

linera-explorer · high confidence

Added new CLI wrapper modules (\local\_net\, \remote\_net\, \wallet\) in \linera-service/src/cli\_wrappers\ to provide structured, programmatic control over Linera test environments. The \local\_net\ module enables end-to-end tests to spin up and manage local validator networks with configurable storage backends (Service, ScyllaDB, Dual RocksDB/ScyllaDB) and network protocols (gRPC, gRPCs, TCP, UDP). The \remote\_net\ module allows tests to connect to external networks via a configurable faucet URL. The \wallet\ module exposes a \ClientWrapper\ that automates client interactions, including wallet initialization, chain creation, and application publishing, with configurable options for chain lifecycle management on drop and extra CLI arguments.

_linera-service/src/cli\wrappers · high confidence

The \examples/controller\ directory now contains a new Linera application that manages the orchestration of distributed services across multiple worker nodes. This application provides a centralized registry for workers and services, enabling dynamic assignment and coordination. It includes the contract logic (\contract.rs\) for handling worker registration, service assignment, and a two-phase handoff protocol for reassigning services between workers to ensure no gap in ownership. The service layer (\service.rs\) exposes GraphQL queries to inspect the local worker state and service details. The project also includes comprehensive documentation (\README.md\) detailing the architecture, message flows, and admin operations, along with integration tests (\single\_chain.rs\) and ABI format tests (\format.rs\) to validate the application's structure.

examples/controller · high confidence

Adds the EVM Bridge application (contract, service, and ABI) to the Linera bridge, enabling users to burn wrapped tokens on Linera to release ERC-20 assets on an EVM source chain and to verify EVM deposit proofs to mint wrapped tokens on Linera. The contract manages state for processed deposits, verified block hashes, the registered EVM bridge contract address, and the RPC endpoint, while the service exposes GraphQL mutations to schedule these bridge operations.

linera-bridge/contracts/evm-bridge · high confidence

The secp256k1 crypto module now includes a new \evm\ submodule that implements EIP-191 compatible signature primitives, allowing users to sign block proposals with EVM-compatible wallets and keys. This new scheme uses compressed public key encoding (33 bytes) and derives EVM addresses from the public key, whereas the existing standard secp256k1 scheme for validator public keys continues to use uncompressed encoding (65 bytes). Both schemes are available within the same module, enabling interoperability with EVM-based signing mechanisms while maintaining the existing validator key format.

linera-base/src/crypto/secp256k1 · high confidence

The \examples/gen-nft\ directory now contains a new example application that generates NFT token contents using an on-device AI model. The service layer fetches model weights and a tokenizer via HTTP, runs a Llama-based model (supporting GGUF, GGML, and non-quantized formats) to generate text from user prompts, and exposes this via a GraphQL \prompt\ query. The contract layer implements standard NFT operations (mint, transfer, claim) where the minted token's payload is the generated string rather than arbitrary bytes, and includes a custom random number generator for WASM compatibility.

examples/gen-nft · high confidence

A new GraphQL client library has been added to the \linera-service-graphql-client\ crate, providing a typed Rust interface for interacting with the node service. This library exposes queries for retrieving chain details, lists of chains, applications, and block history, as well as a subscription stream for node notifications. It includes utilities for sending requests and handling errors, with specific type definitions for WASM targets to ensure compatibility across different compilation environments.

linera-service-graphql-client/src · high confidence

The \examples/hex-game\ directory now contains a complete two-player Hex game application. The game logic runs on a shared temporary chain created for each match, allowing players to submit moves as operations without waiting for message acceptance from other chains. The example includes the contract and service implementations, state management, and a detailed README with setup and usage instructions for running the game locally.

examples/hex-game · high confidence

Adds a new example application that runs a 40M parameter TinyLlama model within a Linera service. The service downloads the model and tokenizer from Hugging Face, verifies their SHA3-256 hashes for integrity, and exposes a GraphQL \prompt\ field for inference. The example includes a web frontend and documentation, while ignoring generated binary artifacts like \.bin\, \.gguf\, and \tokenizer.json\.

examples/llm · high confidence

Adds a new browser-based GraphQL playground (\linera-playground/\) that lets developers run queries and mutations against Linera applications directly in the browser without running a local node. The app uses React and the GraphiQL editor, consuming the \@linera/client\ WASM package to handle client lifecycle, chain synchronization, and application queries. It supports connecting via pasted private keys or MetaMask for signing mutations, and persists configuration to localStorage.

linera-playground · high confidence

A new proxy service has been added to \linera-service\ to act as an intermediary between clients and validator shards, supporting both gRPC and simple TCP/UDP transport protocols. The proxy is configurable via command-line arguments and environment variables for storage backend, send/recv timeouts, Tokio thread counts, and OpenTelemetry OTLP exporter endpoints. It exposes Prometheus metrics for request latency, count, success, and error rates, labeled by method name and traffic type, and includes a middleware layer to prevent metric cardinality explosion from unimplemented methods. The proxy also supports optional jemalloc memory profiling and TLS configuration for gRPC connections.

linera-service/src/proxy · high confidence

The \linera-witty-macros\ crate is introduced to provide the procedural macros powering the \linera-witty\ library. It adds derive macros (\WitType\, \WitLoad\, \WitStore\) for mapping Rust types to WIT definitions and attribute macros (\wit\_import\, \wit\_export\) for generating Wasm guest bindings and exporting host functions. The implementation supports generic type specialization via \witty\_specialize\_with\, allows skipping struct fields, and includes unit tests to verify the correctness of the generated code.

linera-witty-macros · high confidence

Added a new \linera-indexer/graphql-client\ crate that provides a typed GraphQL client for interacting with the indexer. The library exposes modules for querying the indexer's main API (including plugin registration and current state) and the operations API (supporting operation ranges, counts, and individual lookups). It includes a README with instructions for generating the required GraphQL schemas and enforces documentation standards on the hand-written code.

linera-indexer/graphql-client · high confidence

Adds the Solidity implementation for the Linera-EVM bridge, enabling users to deposit ERC-20 tokens on Ethereum-compatible chains and mint them on Linera, and vice versa. The \FungibleBridge\ contract handles deposits and releases burns from Linera, while the \LightClient\ contract verifies Linera block headers and event inclusion proofs on-chain. The design includes a swappable \ILightClient\ interface and a pluggable \IBurnEventDecoder\ to allow governance-managed upgrades of the light client and event schema without requiring a full bridge redeployment or TVL migration.

linera-bridge/src/solidity · high confidence

This change adds the initial implementation of the Linera-to-EVM bridge within the \linera-bridge/src/evm\ module. It introduces a client module (\client.rs\) that provides helpers for deriving Ethereum addresses from Linera validator public keys, and a \light\_client\ module containing the Solidity source code for the LightClient contract along with comprehensive integration tests. These tests verify core committee management behaviors, including adding new committees, validating epoch sequencing, ensuring correct chain origins, and rejecting malformed validator key prefixes. The module also bundles the necessary Solidity ABI sources (such as BridgeTypes, FungibleBridge, and Microchain) to support the bridge's interaction with the EVM.

linera-bridge/src/evm · high confidence

Adds a new Matching Engine example application to the Linera SDK, enabling users to deploy a decentralized exchange that trades between two fungible tokens. The application supports creating, modifying, and canceling bid and ask orders, with fractional price support and atomic swap capabilities via temporary chains. It includes a GraphQL interface for querying order books and executing trades, along with documentation detailing setup, usage, and cross-chain message handling.

(repo-wide) · high confidence

A new example application demonstrating a native fungible token is now available in the \examples/native-fungible\ directory. This app uses system API calls for operations and is hardcoded to use the "NAT" ticker symbol. It includes a Rust smart contract (\src/contract.rs\) and service (\src/service.rs\) that implement the \FungibleTokenAbi\, supporting balance checks, transfers, approvals, and claims. A web frontend (\index.html\, \script.ts\) is provided to interact with the application, allowing users to view balances and send funds in real-time. The setup and deployment instructions are documented in the new \README.md\.

examples/fungible, examples/native-fungible · high confidence

The client now uses a new RequestsScheduler to manage communication with validator nodes, featuring intelligent load balancing based on EMA performance scores, request deduplication for in-flight operations, and a TTL-based LRU cache to avoid redundant work. This change improves efficiency and resilience by reusing results from larger cached requests and automatically retrying failed requests on alternative peers.

_linera-core/src/client/requests\scheduler · high confidence

This change adds the \Linera.sol\ and \LineraTypes.sol\ Solidity libraries, which provide EVM-compatible wrappers and serialization logic for Linera's core data structures (such as \ChainId\, \AccountOwner\, \ChainOwnership\, and \TimeoutConfig\). These bindings enable EVM-based applications to interact with Linera's execution environment, including accessing chain metadata, managing balances, and utilizing new runtime features like event emission and data blob verification.

linera-execution/solidity · high confidence

Added the \WitType\, \WitLoad\, and \WitStore\ traits to enable complex types to be sent and received between hosts and guests using WIT. The \WitType\ trait defines the memory layout and generates WIT type declarations, while \WitLoad\ and \WitStore\ handle loading from and storing to guest Wasm module memory. A \RegisterWitTypes\ mechanism is also provided to register these types in a deterministic order using a compile-time list.

_linera-witty/src/type\traits · high confidence

The \linera-witty/src/runtime\ module now provides a unified abstraction for interacting with WebAssembly guest instances, supporting both Wasmer and Wasmtime backends. This change introduces core traits (\Runtime\, \Instance\, \InstanceWithFunction\, \InstanceWithMemory\) and a \Memory\ handle type that manages guest memory access, allocation (\cabi\_realloc\), and deallocation (\cabi\_free\). It also adds a \RuntimeError\ enum for standardized error handling and a \MockRuntime\/\MockInstance\ implementation for testing, enabling developers to write runtime-agnostic code for calling Wasm functions and managing memory.

linera-witty/src/runtime · high confidence

Adds a new \wrapped-fungible\ example application that extends the standard fungible token with \MintAndTransfer\ and \Burn\ operations restricted to an authorized caller (typically the EVM bridge). The application introduces \RegisterAuthorizedCaller\ to designate the bridge, enforces that minting and burning only occur on a designated \mint\_chain\_id\, and exposes EVM-specific parameters (token address, chain ID, decimals) via the GraphQL service. The change includes the contract, service, state management, ABI definitions, and integration tests verifying standard transfers, cross-chain credits, and mint/burn authorization.

examples/wrapped-fungible · high confidence

The explorer now supports application introspection, allowing users to view and interact with GraphQL queries, mutations, and subscriptions defined by deployed applications. It also decodes user-operation bytes using BCS-serialized application formats fetched from the node, ensuring accurate display of operation data. These changes are implemented in the Rust backend modules (entrypoint, formats, graphql, input\_type, js\_utils) and the TypeScript frontend types, enabling dynamic UI generation for application-specific interactions.

linera-explorer/src · high confidence

The bridge now defines a single source of truth for its wire format and proof structures. A new \abi.rs\ module provides BCS-stable types for bridge operations (deposits, burns, RPC endpoint updates) and cross-chain messages, ensuring the on-chain Wasm contract, the off-chain relay, and tests stay in lockstep. A new \block\_proof.rs\ module replaces the previous practice of relaying full blocks with a lightweight proof that relays only the signed \BlockHeader\ and validator signatures, allowing the EVM light client to verify event inclusion via Merkle-style inclusion proofs without downloading the entire block body. Shared Solidity bindings in \contracts.rs\ guarantee that the relay and tests call the exact same EVM interfaces, while \main.rs\ exposes CLI commands to initialize the light client and generate deposit proofs.

linera-bridge/src · high confidence

The client-side functionality (CLI options, chain listener, benchmarking, and wallet context) has been extracted from linera-service into a new linera-client library crate. This provides a reusable client library for building Linera applications, separates benchmarking and metrics collection from the service binary, and introduces a storage-free LiteClient for efficient benchmark load generation.

linera-client · high confidence

The \linera-execution\ module now supports creating and applying execution state checkpoints, allowing chains to dump their state into blobs and restore it for bootstrapping or migration. It also introduces the \Committee\ type to manage validator sets and voting weights, along with the \ResourceControlPolicy\ to define fees and limits for block execution, such as fuel costs, blob sizes, and HTTP request constraints.

linera-execution/src · high confidence

The \linera-chain\ module now includes a new \justification\ submodule that implements the data structures and algorithms required to attribute faults when conflicting blocks are confirmed at the same height. This change introduces the \JustificationChain\, \CommittedQuorum\, and \JustificationLink\ types, which form a hash-linked chain of validator quorums to justify block validation rounds. It also adds the \proof\ submodule, which defines \EquivocationProof\ types (such as \DoubleVote\, \LockViolation\, and \FirstRoundViolation\) and provides formal soundness and completeness proofs to ensure that only genuinely faulty validators are convicted. This enables the protocol to produce self-contained evidence of misbehavior directly from certificates, enhancing the system's accountability guarantees.

linera-chain/src/justification · high confidence

Added a new gRPC server implementation for the indexer, enabling external clients to stream blockchain elements (blobs and blocks) to the indexer service. The server handles deserialization of incoming protobuf messages, buffers blobs until a corresponding block arrives, and then atomically stores the block along with its associated blobs into the configured database backend (supporting both SQLite and Postgres). This change introduces the \IndexerGrpcServer\ component and its associated processing logic, including error handling for deserialization and database operations, along with unit tests verifying the element processing pipeline.

linera-indexer/lib/src/grpc · high confidence

The \linera\ CLI now organizes validator management under a \validator\ subcommand (with \add\, \list\, \query\, \sync\, \remove\, \update\, and \batch-query\ actions) and adds a new \linera validator benchmark\ command. This benchmark probes a single candidate validator's reachability, read throughput, bulk-download performance, and tip-lag before onboarding, emitting structured reports (JSON, YAML, Markdown, brief) across six layers (preflight, optional deep seed, read baseline, read stress, bulk download, tip-lag). The CLI also adds common wallet/keystore/storage options (including \--with-wallet\ for multiple profiles), configurable block and execution-state cache sizes, and OpenTelemetry/Chrome trace exporter support.

linera-service/src/cli · high confidence

The new linera-cache crate provides a concurrent ValueCache that guarantees a single allocation per distinct content by combining a bounded S3-FIFO cache with a lock-free weak-reference index for deduplication. It introduces a custom Arc newtype that structurally enforces this invariant by preventing direct construction outside the cache, ensuring all consumers share the same Arc\<T\> for identical keys. The crate also includes a UniqueValueCache for non-Clone values and registers metrics eagerly to ensure observability.

linera-cache/src · high confidence

The linera-exporter has been extracted from linera-service into its own crate, providing a dedicated binary and library for exporting blockchain blocks and blobs. It exposes a gRPC NotifierService to receive block notifications and supports exporting to multiple destination types—Indexer, Validator, and Logging—configured via a TOML file. The service includes a block processor that resolves block dependencies, manages committee updates, and persists state, while exposing Prometheus metrics for monitoring export performance and queue lengths.

linera-exporter · high confidence

The \linera-persistent\ crate has been extracted from \linera-client\ to provide a unified abstraction for persisting data types. It introduces a \Persist\ trait with a \mutate\ helper that applies changes and automatically saves them, supporting multiple backends including an in-memory \Memory\ store and a file-based \File\ store that uses atomic writes and exclusive locking to ensure data integrity.

linera-persistent · high confidence

A new linera-storage-runtime crate has been added to provide storage configuration and runtime infrastructure for the Linera protocol. The crate includes a build script that configures conditional compilation flags, enabling support for RocksDB, ScyllaDB, and the storage service based on specific features and target architectures.

linera-storage-runtime · high confidence

Added the \linera-summary\ crate, an internal tool that analyzes CI job runtimes to generate performance summaries for pull requests. The tool compares the execution times of CI jobs between the PR branch and the base branch, then posts a Markdown-formatted table to the PR comment showing the runtime difference percentage for each job. It supports both CI mode (posting comments automatically) and local mode (printing to stdout for testing).

linera-summary · high confidence

A new linera-version crate has been added to extract and bake version information into the Linera build. It computes cryptographic hashes for the RPC, GraphQL, and WIT APIs (stored in api-hashes.json and recalculated via build.rs) and exposes a VersionInfo struct containing the crate version, git commit, and API hashes. This enables users to troubleshoot build issues and perform version compatibility checks across services, with a CLI tool to output the current API hashes and a test to ensure the cached hashes remain up to date.

linera-version · high confidence

This change introduces the \linera-views\ crate, providing a high-level abstraction for mapping complex data structures onto key-value stores. It defines core traits for database interaction (\KeyValueStore\, \ReadableKeyValueStore\, \WritableKeyValueStore\) and a context system (\Context\, \ViewContext\) to manage storage connections and base keys. The crate includes a batch system (\Batch\, \WriteOperation\) for atomic writes, an LRU prefix cache (\LruPrefixCache\) for performance optimization, and various view types (e.g., \RegisterView\, \MapView\, \CollectionView\) that allow applications to store and retrieve data using familiar data structures while handling persistence automatically.

linera-views/src · high confidence

The new \linera-witty\ crate provides the foundational infrastructure for generating WIT interface files and host-side Rust code to interface with WebAssembly guests. It introduces core traits (\WitType\, \WitLoad\, \WitStore\) and derive macros (\wit\_import\, \wit\_export\) to handle type flattening, memory layout, and parameter/result conversion according to the WebAssembly Component Model Canonical ABI. This enables developers to define and consume WIT interfaces directly from Rust, supporting both Wasmer and Wasmtime runtimes.

linera-witty/src · high confidence

Added the new linera-witty crate, which generates WIT files and host-side Rust code to interface with WebAssembly guests adhering to the WIT interface format. The crate includes a build script that configures feature flags (log, testing, wasmer, wasmtime, macros, wit\_export) to control code generation capabilities.

linera-witty · high confidence

The \linera-witty\ crate now includes a new \memory\_layout\ module that represents complex WIT types as a sequence of fundamental types using heterogeneous lists. This change introduces the \Layout\, \LayoutElement\, and \FlatLayout\ traits, enabling the system to flatten complex types into native WebAssembly types for more efficient parameter passing and return handling.

_linera-witty/src/memory\layout · high confidence

Adds a new React-based blockchain explorer for Linera, featuring a modern UI with Tailwind CSS and Vite. The frontend connects to a backend API (defaulting to port 3002) to display blocks, chains, and search results, with configuration options for PostgreSQL or SQLite database backends provided via environment variables.

linera-explorer-new · high confidence

A new \linera-wallet-json\ crate provides a persistent wallet and keystore backed by JSON files on disk. The wallet (\PersistentWallet\) tracks client chains, manages the default chain selection, and persists state via the \linera\_persistent\ library. The keystore (\Keystore\) stores signing keys in a separate JSON file with exclusive locking, supporting key generation and signing operations. Utility modules handle file path resolution (using environment variables or default config directories) and pretty-printing of wallet contents for user visibility.

linera-wallet-json · high confidence

Users can now communicate with validators using a lightweight RPC protocol over TCP or UDP, in addition to existing transports. This change adds a new \SimpleClient\ and \SimpleServer\ implementation in \linera-rpc/src/simple\ that uses length-delimited bincode serialization for \RpcMessage\s. The transport layer supports both TCP (streaming) and UDP (datagram) connections, allowing clients to connect via \tcp://host:port\ or \udp://host:port\ URLs. The server handles block proposals, certificate processing (validated, confirmed, timeout), chain info queries, blob uploads, and notification subscriptions over this simple transport.

linera-rpc/src/simple · high confidence

The \examples/social\ directory now contains a complete social media application that demonstrates event stream subscriptions. The app allows users to subscribe to other users' posts, create posts with optional images, and interact via likes and comments. It implements a contract that emits events for posts, likes, and comments to a named stream, and processes incoming stream updates to display received posts. A GraphQL service exposes queries for viewing received posts and mutations for subscribing, posting, liking, and commenting. The example includes a README with instructions for setting up the local network, compiling the application, and interacting with it via GraphQL.

examples/social · high confidence

Storage operations in \linera-storage\ now expose Prometheus metrics (e.g., \contains\_blob\, \read\_certificate\) labeled by \source\ to distinguish cache hits from database reads, ensuring both cache and DB paths are always visible in monitoring. Additionally, a new \linera-storage-decode-key\ binary has been added to inspect and decode \RootKey\ partition keys from storage backends, supporting ScyllaDB's single-byte prefix and accepting hex keys via arguments or stdin.

linera-storage/src · high confidence

The \linera-indexer\ library is introduced, providing a new component to index blockchain data from Linera nodes. It supports multiple database backends via feature flags, including RocksDB, ScyllaDB, SQLite, and Postgres, allowing users to choose their preferred storage engine. The indexer features a plugin architecture where custom plugins can register block data and expose their own GraphQL schemas. It connects to node services via WebSocket for real-time block notifications and exposes a GraphQL API (with a GraphiQL interface) for querying indexed data. The library includes runners for configuring and launching the indexer with specific database backends and command-line options for cache sizes, replication factors, and service endpoints.

linera-indexer/lib/src · high confidence

The linera-storage-service is now available as a standalone shared storage backend that exposes a gRPC interface defined in \key\_value\_store.proto\. It supports both in-memory and RocksDB backends, allowing clients to connect to a remote storage server for key-value operations. The service handles large payloads by chunking responses (up to 4MB per message) and includes features like namespace management, root key tracking, and LRU caching. A child process wrapper is provided to easily spawn and manage the storage server during testing.

linera-storage-service/src · high confidence

The indexer now includes a new \IndexerDatabase\ trait in \linera-indexer/lib/src/db\ that defines the interface for storing blocks, blobs, and message metadata, along with concrete implementations for Postgres and SQLite backends. This change adds a \MessageClassification\ utility to denormalize system message fields (such as credit/withdraw details) for easier database querying and introduces mock database implementations to support testing of error paths and successful storage operations.

linera-indexer/lib/src/db · high confidence

The linera-core crate has been introduced to serve as the central module for the Linera protocol, consolidating core data types, client logic, and node communication. This change adds new files including data\_types.rs (defining ChainInfoQuery and ChainInfo structures for chain state queries), genesis\_config.rs (managing initial network configuration and storage initialization), join\_set\_ext.rs (providing cross-platform task spawning for native and Web targets), and local\_node.rs (implementing the LocalNode and LocalNodeClient for local chain operations). The lib.rs file exposes these components along with chain workers, the client, and metrics initialization, establishing the foundational structure for client-validator interactions and local node management.

linera-core/src · high confidence

The linera-bridge location now includes a comprehensive deployment runbook (DEPLOYMENT.md) detailing the governance model (Pause Guardian, Proposer, Canceller), timelock constraints, and step-by-step instructions for deploying the LightClient and FungibleBridge contracts. A new Makefile (Makefile) automates the bridge demo environment, providing targets to build Wasm artifacts, start the Docker-based Linera network and relayer, and rebuild the web frontend. Additionally, the build system (build.rs) now implements an automated code generation pipeline that traces Rust types via serde-reflection and emits corresponding Solidity serialization libraries (BridgeTypes.sol, WrappedFungibleTypesV1.sol) using serde-generate, ensuring type consistency between the Rust backend and EVM contracts.

linera-bridge · high confidence

Added a new example application in \examples/how-to/perform-http-requests\ that demonstrates three patterns for interacting with external HTTP services: performing a request directly within the contract, using the service as an oracle to handle non-deterministic responses, and handling the resulting HTTP response. The example includes the contract logic, the GraphQL service interface for querying and scheduling operations, and a standalone test HTTP server binary built with Axum to simulate the external service.

examples/how-to/perform-http-requests/src · high confidence

The \@linera/client\ NPM package is now available, providing JavaScript bindings for the Linera client API compiled to WebAssembly. A key addition is the \WebCryptoEd25519\ signer, which allows browsers to manage Ed25519 keys securely using the Web Crypto API without exposing private keys to JavaScript, with keys persisted in IndexedDB. The package also includes a \PrivateKey\ signer for development and a build pipeline that generates Wasm artifacts compatible with Sentry.

web/@linera · high confidence

This change introduces dedicated Dockerfiles and supporting configuration for the Linera indexer, block explorer, EVM bridge, and Grafana Alloy observability stack. Users can now build and run separate images for the indexer (Dockerfile.indexer), explorer (Dockerfile.explorer), bridge relayer (Dockerfile.bridge), and exporter (Dockerfile.exporter), alongside a playground image (Dockerfile.playground) and a Foundry test image (Dockerfile.foundry). The setup includes a Caddyfile for reverse proxying gRPC traffic, environment templates for local and production deployments, and a Grafana Alloy configuration (alloy-config.river) for collecting metrics, logs, and traces. Build automation is provided via Google Cloud Build YAML files for each new image, and a new .env.indexer-test file defines ports and image names for testing the indexer and block processor stack.

docker · high confidence

Introduces a new demo application in \examples/bridge-demo\ that demonstrates a cross-chain token bridge between an EVM chain and Linera. The demo includes a frontend UI for managing deposits and withdrawals, a setup script (\setup.sh\) to deploy the necessary EVM contracts and Linera apps in a local Docker environment, and a companion script (\spawn-relayer.sh\) to run the bridge relayer against external networks. It also provides configuration examples (\.env.example\) and build configuration (\vite.config.ts\) to facilitate local development and testing of the bridge functionality.

examples/bridge-demo · high confidence

The Linera Explorer frontend has been rewritten in React, providing a modern interface to browse the blockchain. Users can now view a real-time list of the latest blocks, drill down into individual block details (including operations, messages, events, and oracle responses), and explore specific chains. The new UI features a dark theme, copyable hashes, binary data display, and a search bar for quick block lookup.

linera-explorer-new/src · high confidence

A new web-based counter example has been added to the \examples/counter/metamask\ directory, demonstrating how to integrate MetaMask for transaction signing within a Linera application. The demo initializes a Linera client using a composite signer that combines a local in-memory private key (for autosigning routine operations) with the MetaMask signer (for user-initiated actions). Users can connect their MetaMask wallet to view the chain history and increment a counter, with the interface displaying the connected owner address and chain ID.

examples/counter/metamask · high confidence

The \examples/non-fungible\ directory now contains a complete example application for creating and managing unique digital assets. This includes the contract logic (\contract.rs\) for minting, transferring, and claiming NFTs across chains, a GraphQL service interface (\service.rs\) for querying NFT data and scheduling operations, and the shared ABI definitions (\lib.rs\) specifying the \Mint\, \Transfer\, and \Claim\ operations. The application uses data blobs to store NFT metadata and supports cross-chain interactions via messages, providing a reference implementation for developers building similar decentralized applications on Linera.

examples/non-fungible · high confidence

The \linera-sdk/src/abis\ module now exposes formal Application Binary Interfaces (ABIs) for several core application types, allowing developers to build against standardized contracts. This includes the \ControllerAbi\ for managing worker and service lifecycle commands, the \EvmAbi\ for applications implementing an EVM runtime (using raw byte operations and \EvmQuery\), and the \FungibleTokenAbi\ and \WrappedFungibleTokenAbi\ for native and bridged ERC-20 style tokens. The fungible ABIs define standard operations like \Transfer\, \Claim\, and \Approve\, while the wrapped variant adds \MintAndTransfer\ and \Burn\ capabilities backed by an EVM bridge, along with specific parameters for decimal handling and chain identification.

linera-sdk/src/abis · high confidence

The \@linera/client\ package now exposes a comprehensive WASM-based API for browser applications, introducing \Client\, \Chain\, and \Application\ objects. Users can now manage multiple chains, query application state at specific block heights, and interact with the network through a unified client interface. The update includes a new \WebCryptoEd25519\ signer for secure, non-extractable key storage in IndexedDB, a \Composite\ signer for chaining multiple signing methods, and a \PrivateKey\ signer for development. It also adds a \LockError\ type for handling wallet contention via the Web Locks API, and improves error reporting by preserving JavaScript stack traces when errors cross the WASM boundary. Additionally, the \Formats\ module allows decoding application payloads using published BCS schemas, and the client now supports explicit start/stop operations for background chain listeners.

web/@linera/client · high confidence

The \linera-views/src/views\ module introduces several new view types and refactors existing ones to improve performance and usability. A new \BucketQueueView\ provides an efficient FIFO queue implementation using linear buckets. Collection views now use a new \collection\_entry\ module to load entries in a single round trip by combining an index marker with subview keys. Hashing capabilities are enhanced with \WrappedHashableContainerView\ for memoized hashing and \HistoricallyHashableView\ for computing hashes based on modification history. A \LazyRegisterView\ is added to defer loading a single value from storage until first access. Additionally, \KeyValueStoreView\ and \LogView\ are updated with new metrics and optimized storage operations.

linera-views/src/views · high confidence

The linera-base crate now includes a new abi module that defines the Application Binary Interface (ABI) traits for Linera applications, including ContractAbi and ServiceAbi. This module provides the foundational types and serialization/deserialization methods for operations, responses, queries, and query responses that applications use to interact with the Linera runtime. The abi module is part of the broader linera-base library which also contains modules for command handling, data types, GraphQL scalars, hashed values, HTTP request/response types, identifiers, ownership structures, and panic hooks.

linera-base/src · high confidence

The \linera-service\ crate now includes a new \linera-benchmark\ CLI tool that runs performance benchmarks against a Linera network using the fungible token application, allowing users to measure throughput and latency. Additionally, a new \Controller\ component has been added to orchestrate worker services by watching a controller chain and spawning task processors for managed services, enabling more dynamic and scalable service management. The service also introduces configurable block export transport options (Relay vs. Direct) and supports custom GraphQL query subscriptions with TTL-based caching for efficient real-time data streaming.

linera-service/src · high confidence

A new Dockerfile.debug image is now available at us-docker.pkg.dev/linera-io-dev/linera-public-registry/linera-debug:latest for debugging running containers without bloating production images. The image includes a comprehensive suite of system-level debugging and profiling tools (such as bpfcc-tools, gdb, strace, tcpdump, and FlameGraph) and provides helper scripts (cpu-profile.sh, memleak\_translate.sh) to generate CPU profiles and memory leak reports. It is designed to be attached to existing pods via kubectl debug to inspect processes like linera-server.

docker/debug · high confidence

The \linera-sdk-derive\ crate now provides two new procedural macros: \GraphQLMutationRoot\ and \StableEnum\. \GraphQLMutationRoot\ automatically generates a GraphQL mutation root struct for an operation enum, where each variant becomes a mutation that schedules the corresponding operation via the runtime. \StableEnum\ derives \Serialize\ and \Deserialize\ implementations for enums using a deterministic, collision-resistant tag (derived from Keccak-256) to ensure stable binary representation across versions, along with a \StableEnumTrace\ implementation for reflection. These macros simplify the creation of SDK applications by reducing boilerplate for mutation handling and serialization.

linera-sdk-derive · high confidence

The example indexer now includes a new gRPC-based server (linera-indexer-grpc) that supports multiple database backends (in-memory SQLite, file-persisted SQLite, and PostgreSQL) and can be started via a new shell script. Additionally, the example now features an operations plugin integration with end-to-end tests verifying indexer state and operation tracking against the node service.

linera-indexer/example · high confidence

This change introduces the core library components for a new gRPC-based indexer, including the protobuf service definition (Indexer service with IndexBatch RPC), the build script to compile these protos using tonic\_prost\_build, and the module documentation. The indexer connects to the node service, processes blocks, and implements a generic plugin trait and runner struct, enabling streaming of blocks and blobs with acknowledgment.

linera-indexer/lib · high confidence

The storage layer now includes several new backend implementations and adapters: a dual-store adapter that combines two existing stores, an IndexedDB backend for Web environments, a journaling adapter for atomic writes, an LRU caching layer, a metering layer for Prometheus metrics, and a value-splitting adapter for large values. These components are registered in the backends module and provide the foundation for the existing RocksDB and ScyllaDB backends.

linera-views/src/backends · high confidence

The new linera-metrics crate provides a centralized HTTP server for exposing Prometheus metrics and optional jemalloc-based memory profiling. It introduces stable Tokio runtime metrics (worker count, alive tasks, queue depth, and per-worker busy/park counts) to the /metrics endpoint, and adds /debug/pprof and /debug/flamegraph endpoints for heap profiles and SVG flamegraphs when the jemalloc feature is enabled and activated via the --enable-memory-profiling flag. The library ensures metrics are registered eagerly so their presence does not depend on workload execution paths.

linera-metrics · high confidence

A new \linera-spec\ crate has been introduced to serve as the central index for the Linera protocol's correctness specification. While the crate contains no executable code, it provides a structured, machine-checkable documentation of the system model, assumptions, and proofs regarding safety, liveness, and availability. It links to specific proof modules within \linera\_chain\ and \linera\_core\, allowing users to navigate the logical dependencies between statements like \CommitAgreement\ and \UnboundedProgress\ via Rust doc comments and supertrait relationships.

linera-spec/src · high confidence

This change introduces a comprehensive suite of new shell scripts in the \scripts/\ directory to support validator operations, developer workflows, and CI checks. For validators, \backup-validator-keys.sh\ and \extract-wallet-from-volume.sh\ provide tools to backup and recover wallet keys and configuration from Docker volumes, while \deploy-validator.sh\ automates the deployment of validator nodes using Docker Compose with support for ScyllaDB and Let's Encrypt. The \fix-validator-env.sh\ script assists in migrating legacy deployment configurations to the new \.env\ format. For developers, \bump\_version.sh\ automates version updates across Cargo and web packages, \cpu-profile.sh\ simplifies flamegraph generation, and \faucet-stress-test.bash\ allows stress-testing the faucet service. CI and maintenance are supported by \check\_chain\_loads.sh\, \check\_metrics\_features.sh\, \check\_metrics\_registration.sh\, and \check\_spec\_modules.sh\ to enforce code quality and correctness, alongside \install\_hooks.sh\ for pre-push checks and \owner.sh\/\publish.sh\/\yank.sh\ for crate management.

scripts · high confidence

The Linera indexer now includes a new \operations\ plugin that indexes executed operations per chain. This plugin tracks operations by chain ID, block height, and transaction index, storing them in a persistent view and exposing them via GraphQL. Users can query specific operations by key or retrieve the last operation for a given chain, enabling detailed inspection of transaction execution history within the indexer.

linera-indexer/plugins/src · high confidence

The \linera-sdk/src/service\ module now provides a dedicated runtime for application services, introducing \ServiceRuntime\ for live execution and \MockServiceRuntime\ for testing. This change adds support for querying application state and chain data (such as balances, allowances, and application descriptions) via a new WIT interface generated by \wit-bindgen\. Services can now perform HTTP requests as oracles and read data blobs, with the \service!\ macro handling the necessary boilerplate to export these capabilities to the host.

linera-sdk/src/service · high confidence

The \examples/social/web-frontend\ directory now contains a complete React-based social application. The project is bootstrapped with Vite and uses Tailwind CSS for styling. It integrates with the social app's GraphQL API using Apollo Client, featuring code generation for TypeScript types via \@graphql-codegen\. The frontend provides a user interface for posting, liking, and commenting on social content, with real-time updates handled through GraphQL subscriptions.

examples/social/web-frontend · high confidence

The \linera-storage-runtime\ crate has been introduced to centralize storage configuration and runtime execution logic. It provides \CommonStorageOptions\ for managing cache sizes, concurrency limits, and RocksDB statistics via command-line flags, alongside \StorageConfig\ and \StoreConfig\ structs that parse and validate connection strings for Memory, RocksDB, ScyllaDB, and dual-backend storage. The crate also defines the \Runnable\ and \RunnableWithStore\ traits, allowing jobs to be executed against high-level storage instances or low-level key-value stores, effectively decoupling storage backend selection from application logic.

linera-storage-runtime/src · high confidence

The \linera-execution\ test utilities now include a \MockApplication\ framework that allows tests to register expected calls (such as \instantiate\, \execute\_operation\, \finalize\, and \handle\_query\) and verify that all expected interactions occurred. Additionally, a new \solidity\ module provides helpers to compile Solidity smart contracts into EVM bytecode for testing, including support for importing \Linera.sol\ and OpenZeppelin contracts. A \SystemExecutionState\ struct was also added to simplify the creation of test execution states from simple data structures.

_linera-execution/src/test\utils · high confidence

The \linera-views\ crate now includes a \test\_utils\ module providing helper functions for generating random key-value pairs and operations, a \TestView\ trait with concrete implementations for \RegisterView\, \LogView\, and \MapView\ to simplify testing view state transitions, and a \performance\ module to benchmark store operations like \contains\_key\, \find\_keys\_by\_prefix\, and \read\_value\_bytes\.

_linera-views/src/test\utils · high confidence

Added \linera-execution/src/util\ with helper traits to simplify communication with the runtime actor and handle oracle responses. \UnboundedSenderExt\ and \ReceiverExt\ provide ergonomic methods (\send\_request\, \recv\_response\) for sending requests via unbounded channels and receiving responses, while \RespondExt\ allows senders to respond to requests with automatic logging if the receiver is canceled. A new \OracleResponseExt\ trait adds \to\_round\, \to\_service\_response\, \to\_http\_response\, and \to\_event\ methods to \OracleResponse\, enforcing type-safe extraction and returning \ExecutionError::OracleResponseMismatch\ on invalid types. The \sync\_response\ module introduces \SyncSender\ and \SyncReceiver\ wrappers around \oneshot\ channels to enforce synchronous, blocking usage patterns for actor responses.

linera-execution/src/util · high confidence

Added new utility modules in \linera-base/src/util\ to improve async handling and platform compatibility. The \future\ module introduces \FutureSyncExt\, allowing futures to be boxed while preserving \Sync\ bounds, which is useful for multi-threaded execution contexts. The \traits\ module defines \AutoTraits\ and \DynError\, which conditionally enforce \Send + Sync\ on non-web platforms to support type-erased error objects and multi-threaded operations, while remaining compatible with single-threaded web environments.

linera-base/src/util · high confidence

The indexer now supports SQLite as a storage backend, in addition to the existing PostgreSQL option. This change introduces a new \sqlite\ module containing schema definitions for blocks, operations, messages, events, blobs, and related tables, along with the implementation logic to initialize the schema and store block data atomically. Tests verify that the SQLite backend correctly handles blob storage, block insertion, and transaction rollback behavior.

linera-indexer/lib/src/db/sqlite · high confidence

The \linera-sdk\ now exposes simplified type aliases (such as \MapView\, \SetView\, and \LogView\) that automatically bind to the WebAssembly-specific \ViewStorageContext\, reducing boilerplate for developers. Additionally, a new \KeyValueStore::mock()\ method is available in test builds, allowing applications to use an in-memory store for unit testing without needing external storage backends.

linera-sdk/src/views · high confidence

The \linera-witty\ library now supports serializing and deserializing several additional types via the WIT interface. \GuestPointer\ is implemented as a 32-bit integer (\i32\). Heterogeneous lists from the \frunk\ crate (\HNil\ and \HCons\) are supported with correct internal padding and alignment handling. The \log::Level\ enum is mapped to a WIT enum with variants for error, warn, info, debug, and trace. These implementations ensure that these types can be correctly passed across Wasm boundaries using the Witty traits.

_linera-witty/src/type\traits/implementations · high confidence

The \linera-witty\ library now implements the \WitType\, \WitLoad\, and \WitStore\ traits for a wide range of Rust standard library types, enabling them to be used in WebAssembly Interface Types (WIT) interfaces. This includes primitive types (integers, floats, booleans), collections (\Vec\, \BTreeMap\, \BTreeSet\, slices), smart pointers (\Box\, \Rc\, \Arc\), and utility types (\String\, \Option\, \Result\, \Duration\, tuples).

_linera-witty/src/type\traits/implementations/std · high confidence

The \linera-service\ tracing module has been restructured to provide a unified initialization path that supports multiple export backends. Users can now export traces to OpenTelemetry-compatible backends (e.g., Tempo) via the OTLP protocol by setting the \LINERA\_OTLP\_EXPORTER\_ENDPOINT\ environment variable, with optimized batch processing for high-throughput scenarios. Additionally, a new Chrome Trace JSON exporter is available for local visualization in Chrome DevTools or Perfetto UI. The logging output now automatically injects \traceID\ and \spanID\ into log lines to enable correlation between logs and traces, and panics are consistently reported through the configured tracing subscriber.

linera-service/src/tracing · high confidence

The chain client logic has been reorganized into a new \linera-core/src/client/chain\_client\ module, separating the core client implementation (\mod.rs\) from its internal state management (\state.rs\). This change introduces a dedicated \State\ struct that encapsulates the per-chain proposal mutex and follow-only mode, ensuring that block proposals are serialized to prevent conflicts in the Fast consensus round and that read/write access to pending proposals is synchronized. The module also defines a comprehensive \Options\ struct to configure client behaviors such as message policies, batch sizes, and circuit breaker settings, providing a cleaner separation of concerns for chain-specific client operations.

_linera-core/src/client/chain\client · high confidence

The client runtime is now structured around a new \Environment\ trait that explicitly wires together storage, network, signer, and wallet components, replacing the previous implicit or flat structure. This includes a new \Wallet\ trait and an in-memory \Memory\ implementation that tracks the set of chains followed by the client, ensuring stable JSON serialization by sorting chain entries. This change provides a cleaner, more testable foundation for client-side state management and service composition.

linera-core/src/environment · high confidence

The \linera-witty\ primitive types module now implements the WebAssembly Component Model canonical ABI flattening logic, introducing traits like \FlatType\, \SimpleType\, and \JoinFlatTypes\ to handle the conversion of WIT types into native WebAssembly flat representations. As part of this structural change, the handling of 20-byte arrays (\\[u8; 20\]\) is corrected to properly flatten into a three-part record of two 64-bit integers and one 32-bit integer, ensuring correct memory layout and loading/storing behavior for EVM addresses.

_linera-witty/src/primitive\types · high confidence

The linera-chain module now includes a README.md file describing its role in managing chain state and cross-chain communication, along with a build.rs script that defines conditional compilation aliases (such as web, with\_testing, with\_metrics, and with\_graphql) to support different build targets and features.

linera-chain · high confidence

The Linera Explorer backend has been rewritten in Rust, replacing the previous implementation. This new server exposes a comprehensive REST API (via Axum) to query blockchain data including blocks, chains, bundles, messages, operations, events, and oracle responses from a PostgreSQL database. It also includes a health check endpoint and Prometheus metrics for monitoring request latency.

linera-explorer-new/server-rust · high confidence

The web-based examples (Counter and Native Fungible) now use a shared set of public assets and styles. A common \style.css\ and \arrow.svg\ have been added to \examples/assets\, and the individual example directories (\examples/counter/public\, \examples/native-fungible/public\) now reference these shared files via symlinks. This ensures consistent visual styling across the examples without duplicating asset files.

examples/assets, examples/counter/public, examples/native-fungible/public · high confidence

The certificate system in \linera-chain\ has been restructured to use a new \GenericCertificate\<T\>\ type that holds the certified value, round, signatures, and additional payload fields (unlocking round, first-round attestation, justification commitment). Specific certificate types (\ConfirmedBlockCertificate\, \ValidatedBlockCertificate\, \TimeoutCertificate\) now wrap this generic type and explicitly manage a \JustificationChain\ to track the history of quorums. This change introduces a unified \Certified\ trait and a \Certificate\ enum, standardizing how validators sign and verify blocks and timeouts, and ensuring that justification chains are correctly bound to certificates for fault attribution.

linera-chain/src/certificate · high confidence

The \scripts/check\_copyright\_header\ tool has been rewritten from a shell script into a Rust application. This change improves the robustness of the copyright header check by providing more specific, structured error messages (such as missing Zefchain Labs header, incorrect header format, or missing separation lines) instead of generic failures, and includes comprehensive unit tests to ensure accurate validation of file headers.

_scripts/check\_copyright\header · high confidence

The cryptographic primitives in \linera-base/src/crypto\ have been reorganized into distinct modules (\ed25519.rs\, \hash.rs\, \secp256k1.rs\, \signer.rs\) to improve code structure. This change introduces support for EVM-compatible signatures via the \secp256k1\ algorithm, allowing chain owners to use EVM wallets for signing. The \AccountPublicKey\, \AccountSecretKey\, and \AccountSignature\ types are now enums that support Ed25519, Secp256k1, and EVM Secp256k1 variants. Additionally, the \CryptoHash\ type now uses Keccak256 and includes a \make\_evm\_compatible\ method to zero out the last 12 bytes for EVM address compatibility. The \Signer\ trait is defined in its own module with an in-memory implementation, and the module exports are updated to reflect these new structures.

linera-base/src/crypto · high confidence

The \linera-views-derive\ macro has been updated to enforce that all generated View implementations explicitly specify a Context type. Previously, the context could be inferred or omitted in some cases; now, developers must either provide a generic type parameter that serves as the context or explicitly declare it using the \\#\[view(context = YourContextType)\]\ attribute. This change ensures stricter type safety and clearer ownership of the underlying storage context for all derived views.

linera-views-derive/src · high confidence

The \examples\ directory now includes a unified Vite build configuration that enforces required environment variables (such as \LINERA\_FAUCET\_URL\ and \LINERA\_APPLICATION\_ID\) and configures CORS headers for local development. Additionally, a Playwright test configuration is introduced to run end-to-end tests against the example applications, alongside a shared TypeScript configuration and pnpm workspace definition to standardize the development environment for these web-based demos.

examples · high confidence

The web directory now includes a pnpm workspace configuration defining the \@linera/client\ and \@linera/metamask\ packages, alongside a README clarifying that building requires a nightly Rust toolchain. To enforce this, a symlink to the shared nightly toolchain file and an \.envrc\ script have been added, ensuring the correct compiler version is used for web bindings and utilities.

web · high confidence

Added a formal specification and mathematical proof for the safety of the chain manager's consensus logic, located in \linera-chain/src/manager/proof\. This new module defines the system model, voting rules, and locking invariants, and proves that at most one block is ever committed per chain and height. It covers the commit rule, round monotonicity, and lock preservation, ensuring that correct validators cannot confirm conflicting blocks.

linera-chain/src/manager · high confidence

Added formal specification proofs in \linera-chain/src/proof\ that verify the correctness of checkpointing and epoch management. The \checkpoints\ module proves that checkpoints preserve message consumption boundaries, blob availability, and execution state integrity while allowing senders to forget messages once acknowledged. The \epochs\ module proves that committee knowledge is well-founded, ensuring no committee can certify its own introduction. These changes provide a mathematical guarantee of safety for these core system behaviors without altering the runtime implementation.

linera-chain/src/proof · high confidence

The Fungible example web frontend has been updated to connect to the new node service architecture. The application now expects a Node Service running on port 8080 and configures its GraphQL client to query the specific chain and application endpoints exposed by this service. The UI has been refreshed using Tailwind CSS and React components, and the frontend now supports sending tokens to other applications by allowing users to specify a target chain ID and owner address during transfers.

examples/fungible/web-frontend · high confidence

The chain module now distinguishes between three block execution phases—staging a proposal, validating a received proposal, and executing a confirmed certificate—via the new \BlockExecutionPhase\ enum and \BlockExecution\ type. This change introduces the \BlockExecutionTracker\ to manage transaction execution within a block, explicitly tracking resource usage, oracle responses, events, and messages per transaction. The \ChainStateView::execute\_block\ method now accepts a \BlockExecution\ argument to enforce that only the proposer can choose a bundle-failure policy (e.g., \AutoRetry\) and that only validators executing a confirmed certificate replay recorded oracle responses for determinism. Additionally, block execution metrics are now labeled by phase to allow separate monitoring of staging, validation, and confirmation latencies.

linera-chain/src · high confidence

The \linera-rpc\ crate now provides a unified, network-agnostic client (\Client\) that abstracts over gRPC and simple (TCP/UDP) transports, allowing users to communicate with validators regardless of the underlying protocol. Cross-chain message delivery is now explicitly configurable via \CrossChainConfig\, exposing command-line options to tune queue size, retry limits, backoff delays, and artificial sender delays or failure rates for testing. Additionally, the crate introduces structured network configuration types (\ShardConfig\, \ProxyConfig\, \ValidatorInternalNetworkPreConfig\) and supports OpenTelemetry context propagation to distinguish between organic and synthetic traffic in metrics and traces.

linera-rpc/src · high confidence

The chain worker logic has been reorganized into a dedicated \linera-core/src/chain\_worker\ module, introducing a \ChainWorkerConfig\ struct that allows operators to configure worker behavior via parameters such as \ttl\ (idle timeout), \sender\_chain\_ttl\, \block\_cache\_size\, \execution\_state\_cache\_size\, and recovery options like \allow\_revert\_confirm\ and \reset\_on\_corrupted\_chain\_state\. This change adds cancellation safety through a \RollbackGuard\ that automatically reverts uncommitted state changes if a write operation is dropped, and introduces a \DeliveryNotifier\ to manage cross-chain message delivery notifications. Additionally, a background keep-alive task is spawned based on the configured TTL to automatically free memory for idle chain workers.

_linera-core/src/chain\worker · high confidence

The \linera-faucet/client\ crate now provides the client-side library for interacting with the Linera faucet service. This change introduces a new \Error\ enum that replaces previous error handling (likely involving \anyhow\ or \thiserror-context\) with specific variants for JSON parsing, GraphQL errors, and HTTP failures. A key behavioral improvement is the \describe\_http\_failure\ function, which sanitizes \reqwest\ error messages to exclude verbose JavaScript stack traces on WebAssembly targets, ensuring cleaner and more consistent error reporting for users. The library exposes a \Faucet\ struct for querying the service, including methods to fetch the genesis configuration and handle chain claims.

linera-faucet/client · high confidence

The bridge relayer now persists deposit and burn requests to a local SQLite database, ensuring that in-flight bridging operations survive relayer restarts and can be replayed without requiring the relayer to be continuously online. This change introduces a Write Ahead Log-style persistence layer alongside the in-memory state, separating pending and finished requests into distinct tables to maintain query performance as historical volume grows. Additionally, the monitoring loops for both EVM deposits and Linera burns now include explicit retry mechanisms with configurable limits, allowing the relayer to recover from transient failures and correctly handle idempotent on-chain states (such as already-processed deposits) without getting stuck in infinite retry loops.

linera-bridge/src/monitor · high confidence

The \linera-explorer/src/components\ directory has been completely rewritten to use Vue 3 (Composition API with \\<script setup\>\) and Vitest for testing. This change introduces a new set of components (\App\, \Block\, \Blocks\, \Chain\, \Application\, \Applications\, \Entrypoint\, \DecodedBytes\, etc.) that power the explorer's interface, along with corresponding unit tests for each component. The new implementation leverages \@vue/test-utils\ for mounting and testing, and integrates with the \linera\_explorer\ Rust/WASM bindings for data fetching and decoding.

linera-explorer/src/components · high confidence

The \linera-sdk/src/contract\ module has been restructured to use a new WIT (WebAssembly Interface Types) interface generated by \wit-bindgen\. This change introduces dedicated conversion modules (\conversions\_from\_wit.rs\ and \conversions\_to\_wit.rs\) that map between the SDK's internal types (such as \ApplicationId\, \ChainId\, \Amount\, and \AccountOwner\) and the types generated by the WIT bindings. The \contract\ macro now exports these WIT entrypoints, and the \ContractRuntime\ and \MockContractRuntime\ implementations have been updated to interact with the host via these new WIT APIs, replacing the previous system API interface.

linera-sdk/src/contract · high confidence

The \linera-core/src/client\ module now introduces a structured \ReceivedLogs\ system and \ValidatorTracker\ components to efficiently track and download sender-chain certificates. This change replaces ad-hoc tracking with a batched, indexed approach that filters out already-known blocks, deduplicates requests via a \RequestsScheduler\, and manages per-validator state to optimize cross-chain message synchronization and reduce redundant network calls.

linera-core/src/client · high confidence

The \linera-rpc/src/grpc\ module has been replaced with a new implementation that introduces a \GrpcClient\ and \GrpcNodeProvider\ backed by a \GrpcConnectionPool\ (using \papaya\ for thread-safe channel caching). The client now features automatic retry logic with jittered exponential backoff for transient errors (including HTTP/2 protocol errors and proxy 5xx responses), and tracks subscription cooldowns to avoid retrying dead validators. The server exposes per-method Prometheus metrics (latency, count, success, error, and cancelled requests) and distinguishes organic from synthetic traffic. A \RelayClient\ allows shards to route block-export requests through the validator proxy, and the maximum gRPC message size is set to 16 MiB.

linera-rpc/src/grpc · high confidence

The bridge relay now includes localhost-only admin HTTP endpoints (bound to 127.0.0.1) that allow operators to manually re-queue failed burns and deposits back to pending status, enabling recovery without restarting the relayer. Additionally, the relay now detects committee rotation events on the admin chain and automatically relays them to the EVM LightClient contract with bounded retries and backoff, ensuring the LightClient stays synchronized with the current epoch and preventing it from rejecting valid burn certificates due to stale committee state.

linera-bridge/src/relay · high confidence

The \linera-witty\ library now supports exporting host functions that accept up to 16 parameters to guest Wasm instances. This change introduces the \GuestInterface\ trait and associated macros in \linera-witty/src/exported\_function\_interface\ to handle the canonical ABI's parameter flattening limits. When a function exceeds the flat parameter limit, the implementation automatically switches to passing parameters via memory addresses, ensuring that complex host functions with many arguments can be correctly invoked from Wasm guests.

_linera-witty/src/exported\_function\interface · high confidence

The project template generated by \linera project new\ has been updated to align with the latest Linera SDK changes. The contract and service entry points now use the \load\ and \store\ methods instead of \new\ and \finalize\, and state management relies on the \RootView\ system with \save\_and\_drop\ rather than manual state storage. The template also pins \async-graphql\ to version 7.0.17, includes release profile optimizations (LTO, size optimization), and removes the \.rs.template\ file extension from generated source files.

linera-service/template · high confidence

The WASM execution layer in \linera-execution/src/wasm\ has been refactored to use WIT (WebAssembly Interface Types) via the \linera\_witty\ library for defining contract and service entrypoints, replacing the previous manual binding approach. This change introduces a \ModuleCache\ to cache compiled WebAssembly modules by bytecode size (defaulting to 512 MiB), improving performance for repeated executions. The runtime API is now split into \BaseRuntimeApi\, \ContractRuntimeApi\, and \ServiceRuntimeApi\, providing a cleaner separation of system capabilities. Both Wasmer and Wasmtime backends are updated to use these new WIT-generated entrypoints and the shared caching mechanism, ensuring consistent behavior across runtimes while maintaining support for both contract and service execution lifecycles.

linera-execution/src/wasm · high confidence

The Linera Explorer now includes a TypeScript declaration file for the json-formatter-js library, enabling type-safe usage of the JSON formatter component within the application.

linera-explorer/src/types · high confidence

Add benchmark for cross-chain native token transfers; Add client and hashing benchmarks with Prometheus metric measurement; Add unit tests for the HTTP request example application; Added ABI format snapshot tests for example applications; Added ABI format snapshot tests for the LLM example; Added EVM test fixtures for basic checks, counter, and gas limits; Added EVM test fixtures for cross-chain and Linera integration; Added RPC serialization and transport tests; Added Wasm test modules for Witty import/export and reentrancy scenarios; Added common test infrastructure for Witty runtime integration; Added comprehensive test coverage for linera-execution runtime APIs and execution logic; Added comprehensive test coverage for linera-views storage backends and view types; Added contract-call test fixture to verify authenticated caller visibility; Added cost-tracking test fixture; Added e2e test infrastructure and Rust toolchain configuration; Added end-to-end tests for Linera bridge relay behavior; Added integration and ABI format tests for the social application; Added integration and UI tests for the Counter example application; Added integration and format tests for the native-fungible example; Added integration and schema validation tests for the GraphQL client; Added integration and serialization tests for the Linera Bridge; Added integration tests for HTTP request examples; Added integration tests for SDK example applications; Added integration tests for cross-chain transfers and token bouncing in the Fungible Token example; Added integration tests for crowd-funding campaign lifecycle and ABI format; Added integration tests for the EVM bridge contract; Added integration tests for the Hex game example; Added integration tests for the Linera storage service; Added performance benchmarks for the Storage Service database; Added single-chain integration test template for generated projects; Added snapshot test for Counter application format introspection; Added snapshot tests for Social application data formats; Added snapshot tests for WIT file generation; Added test fixture for data blob publish and read operations; Added test fixture for the Meta-Counter application; Added test fixtures for create-and-call and track-instantiation applications; Added test fixtures for event emitter and subscriber contracts; Added test utility to manage RUSTFLAGS warnings-as-errors; Added tests for Witty derive macros and reentrant host functions; Added tests for binary resolution utilities; Added tests for time-based operation expiry; Added tests to verify GraphQL indexer schemas; Added unit test for guest pointer memory alignment; Added unit tests for QueueView operations across storage backends; Added unit tests for chain state, data types, and inbox/outbox logic; Added unit tests for runtime resource tracking and system execution state; Initial client and WASM test suites for linera-core; New SDK test harness for integration testing applications; New benchmarks for linera-views performance; New integration tests for block export, wallet persistence, and README examples; New test utilities for block construction and HTTP server simulation; Snapshot tests for Linera bridge serialization formats; Updated RPC protocol snapshot tests.

The repository now includes a root \Cargo.toml\ defining the Linera workspace with version 0.16.0, a corresponding \Cargo.lock\ pinning all Rust dependencies (including \alloy\ 1.0.42 and \async-graphql\ 7.0.17), and a separate \examples/\ workspace with its own \Cargo.toml\ and \Cargo.lock\. This establishes the baseline dependency graph for the project and its example applications.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 38 → 49 (+11.2)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 86 → 87 (+0.4)
• Architecture 93 (new)
• Maturity 70 → 77 (+7.3)
• Readiness 25 → 50 (+25.1)
• Security 27 → 45 (+17.9)
• Domain Modelling 91 (new)
• Accessibility 39 (new)

• Change coupling: Block.vue ↔ Blocks.vue (linera-explorer/src/components/Block.vue)
• Critical CVE: [GHSA redacted] (linera-explorer/package-lock.json)
• Critical CVE: [GHSA redacted] (linera-explorer/package-lock.json)
• Critical CVE: [GHSA redacted] (linera-explorer/package-lock.json)
• Critical CVE: [GHSA redacted] (linera-explorer/package-lock.json)
• Critical CVE: [GHSA redacted] (web/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (linera-explorer/package-lock.json)
• Critical CVE: [GHSA redacted] (linera-playground/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (linera-explorer-new/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (Cargo.lock)
• Dimension evaluation failed
• High CVE: [GHSA redacted] (linera-explorer-new/package-lock.json)
• High CVE: [GHSA redacted] (linera-explorer-new/package-lock.json)
• High CVE: [GHSA redacted] (linera-explorer-new/package-lock.json)
• High CVE: [GHSA redacted] (linera-explorer-new/pnpm-lock.yaml)
• High CVE: [GHSA redacted] (linera-explorer-new/pnpm-lock.yaml)
• High CVE: [GHSA redacted] (linera-explorer/package-lock.json)
• High CVE: [GHSA redacted] (linera-explorer-new/package-lock.json)
• High CVE: [GHSA redacted] (linera-explorer-new/package-lock.json)
• High CVE: [GHSA redacted] (linera-explorer/package-lock.json)
• …and 91 more

• Batch::simplify (cognitive 19) (linera-views/src/batch.rs)
• BatchProcessor::execute_batch (cognitive 25) (linera-faucet/server/src/lib.rs)
• BatchProcessor::execute_batch (cyclomatic 22) (linera-faucet/server/src/lib.rs)
• BatchingHelper::next_chain_and_height (cognitive 18) (linera-core/src/client/received_log.rs)
• Benchmark::metrics_watcher (cognitive 18) (linera-client/src/benchmark.rs)
• Benchmark::parse_histogram (cognitive 18) (linera-client/src/benchmark.rs)
• BlockDetail.BlockDetail (cognitive 36) (linera-explorer-new/src/components/BlockDetail.tsx)
• BlockDetail.BlockDetail (cyclomatic 46) (linera-explorer-new/src/components/BlockDetail.tsx)
• BlockExecutionTracker::process_txn_outcome (cognitive 16) (linera-chain/src/block_tracker.rs)
• BlockExportQueue::drain_ready (cognitive 21) (linera-core/src/chain_worker/export.rs)
• BlockExportQueue::on_done (cognitive 43) (linera-core/src/chain_worker/export.rs)
• BlockExportQueue::on_done (cyclomatic 25) (linera-core/src/chain_worker/export.rs)
• BlockExportQueue::run (cognitive 17) (linera-core/src/chain_worker/export.rs)
• BlockExportQueue::sync_destinations (cognitive 17) (linera-core/src/chain_worker/export.rs)
• BlockExportQueue::tick (cognitive 44) (linera-core/src/chain_worker/export.rs)
• BlockExportQueue::tick (cyclomatic 25) (linera-core/src/chain_worker/export.rs)
• BlockProcessor::run_with_shutdown (cognitive 29) (linera-exporter/src/runloops/block_processor/mod.rs)
• Boundary-crossing change coupling: client.rs ↔ grpc.rs (linera-rpc/src/simple/client.rs)
• Boundary-crossing change coupling: client.rs ↔ main.rs (linera-rpc/src/client.rs)
• Boundary-crossing change coupling: client.rs ↔ main.rs (linera-rpc/src/simple/client.rs)
• …and 942 more

• 83 commits — 82 feature/other, 1 fixes

• linera-core/src — 15 commits
• linera-chain/src — 13 commits
• linera-views/src — 9 commits
• .github/workflows — 6 commits
• linera-client/src — 5 commits
• linera-base/src — 4 commits
• linera-rpc/src — 4 commits
• web/@linera — 4 commits
• linera-service/src — 3 commits
• (root) — 2 commits
• linera-execution/src — 2 commits
• linera-spec/src — 2 commits
• .github/actions — 1 commit
• docker/Dockerfile.playground — 1 commit
• docker/dashboards — 1 commit
• examples/task-processor — 1 commit
• linera-base/Cargo.toml — 1 commit
• linera-bridge/build.rs — 1 commit
• linera-bridge/tests — 1 commit
• linera-explorer/src — 1 commit

• fix: docker: fix the dead Block Execution Latency panel in the dev dashboard (#6677)
• change: Add unit tests for the shard-to-shard cross-chain message forwarder (#6657)
• change: Audit and correct the accountability proof (#6689)
• change: Audit and correct the progress and liveness proofs (#6691)
• change: Audit and correct the safety proof (#6685)
• change: Avoid dirtying next_height_to_preprocess when the height does not advance (#6652)
• change: Batch the ByteMapView entries resolver into a single multi_get (#6729)
• change: Batch validator catch-up via an aggregated MissingCrossChainUpdates error (#6573)
• change: Borrow keys instead of copying them twice per ScyllaDB multi-key query (#6732)
• change: Bound the shard server's concurrent streams deliberately (#6745)
• change: Correct the misleading claim that must_reload_view indicates a journal resolution failure (#6774)
• change: Decode all zstd frames when decompressing bytecodes on wasm32 (#6820)
• change: Describe faucet request failures without reproducing the JavaScript stack (#6785)
• change: Do not report shared-mode write batch errors as view-invalidating (#6776)
• change: Document the fast way to read the specification locally (#6680)
• change: Drive circuit-breaker probes for validator notification streams with a timer (#6695)
• change: Drive the lite client's in-flight block to confirmation before closing chains (#6766)
• change: Drop redundant execution-site rejection log in block_tracker (#6673)
• change: Drop thiserror-context and fold its annotations into error variants (#6747)
• change: Export both cache and db children of source-labelled counters (#6795)
• …and 63 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

linera-io/linera-protocol was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.