Crate linera_sdk

This module provides an SDK for developing Linera applications using Rust.

A Linera application consists of two WebAssembly binaries: a contract and a service. In both binaries, there should be a shared application state. The state is a type that represents what the application would like to persist in storage across blocks, and must implement the Contract trait in the contract binary and the Service trait in the service binary.

The application can select between two storage backends to use. Selecting the storage backend is done by specifying both the Contract::Storage and the Service::Storage associated types.

The SimpleStateStorage backend stores the application’s state type by serializing it into binary blob. This allows the entire contents of the state to be persisted and made available to the application when it is executed.

The ViewStateStorage backend stores the application’s state using the linera-views, a framework that allows loading selected parts of the state. This is useful if the application’s state is large and doesn’t need to be loaded in its entirety for every execution.

The contract binary should use the contract! macro to export the application’s contract endpoints implemented via the Contract trait implementation.

The service binary should use the service! macro to export the application’s service endpoints implemented via the Service trait implementation.

Examples

The examples directory contains some example applications.

Modules

• base
  Types reexported from linera_base.
• contract
  Types and macros useful for writing an application contract.
• graphql
  GraphQL traits for generating interfaces into applications.
• service
  Types and macros useful for writing an application service.
• test
  Helper types for writing unit tests for WebAssembly applications.
• views
  Helper types for using linera_views to store application state.

Macros

• contract
  Declares an implementation of the Contract trait, exporting it from the Wasm module.
• ensure
  A macro for asserting that a condition is true, returning an error if it is not.
• export_contract
  Declares the export of the interface for the given type.
• export_service
  Declares the export of the interface for the given type.
• instance_exported_future
  Declares a type exporting a future declared as a WIT type.
• service
  Declares an implementation of the Service trait, exporting it from the Wasm module.

Structs

• ApplicationCallResult
  The result of calling into an application.
• CalleeContext
  The context of the execution of an application’s cross-application call or session call handler.
• ContractLogger
  A logger that uses the system API for contracts.
• ExecutionResult
  Externally visible results of an execution. These results are meant in the context of the application that created them.
• ExportedFuture
  A future that’s exported from a guest Wasm module to the host.
• MessageContext
  The context of the execution of an application’s message.
• OperationContext
  The context of the execution of an application’s operation.
• OutgoingMessage
  A message together with routing information.
• QueryContext
  The context of the execution of an application’s query.
• ServiceLogger
  A logger that uses the system API for services.
• SessionCallResult
  The result of calling into a session.
• SimpleStateStorage
  A simple state management runtime based on a single byte array.
• ViewStateStorage
  A state management runtime based on linera_views.

Traits

• Contract
  The contract interface of a Linera application.
• FromBcsBytes
  Extension trait to deserialize a type from a vector of bytes using bcs.
• Service
  The service interface of a Linera application.
• ToBcsBytes
  Extension trait to serialize a type into a vector of bytes using bcs.