linera_views::Context: extract KeyValueStore functions (#3861)

## Motivation
The `Context` trait currently duplicates the `ReadableKeyValue` and
`WritableKeyValue` traits.

## Proposal
Instead, provide direct access to the store so there's no need to pass
through these calls. This shrinks the `Context` trait and its
implementers quite considerably in preparation for
#1948.

While we're at it, factor `BaseKey` out into a separate type for the
same reason.

Additionally, I noticed we've maintained the `Local`/`Send` split for
our traits, a distinction that we chose to abandon in the codebase in
favour of conditional compilation, so I merged those. This led to some
knock-on effects:

- we get to remove `async-trait` in a lot of places, replacing its trait
transformation functionality with `trait-variant` where necessary — this
simplifies the implementation of the traits, since implementers don't
need to re-iterate the `Send`ness of the trait
- since we can now no longer implement things for `*Store` without
implementing them for `Local*Store`, we need to be more careful about
the propagation of `Send`/`Sync` traits. Notably this required making
GraphQL support conditional, which could even be extended to a feature
flag in the future (just by modifying `Cargo.toml` and `build.rs`, since
I made use of the `with_*` alias pattern).

In addition it seems that `cargo machete` detected some unused
dependencies in our workspace and decided to remove them.

## Test Plan

CI.

## Release Plan
- Nothing to do / These changes follow the usual release cycle.

## Links
- [reviewer
checklist](https://github.com/linera-io/linera-protocol/blob/main/CONTRIBUTING.md#reviewer-checklist)

Author: Twey

Cargo.lock

@@ -150,11 +150,6 @@ revm-primitives = "15.2.0"
 rocksdb = "0.21.0"
 ruzstd = "0.7.1"
 scylla = "0.15.1"
-secp256k1 = { version = "0.30.0", default-features = false, features = [
-    "alloc",
-    "rand",
-    "serde",
-] }
 semver = "1.0.22"
 serde = { version = "1.0.197", features = ["derive"] }
 serde-name = "0.2.1"
@@ -204,7 +199,6 @@ url = "2.4"
 wasm-bindgen = "0.2.92"
 wasm-bindgen-futures = "0.4.42"
 wasm-bindgen-test = "0.3.42"
-wasm-encoder = "0.24.1"
 wasm-instrument = { package = "linera-wasm-instrument", version = "0.4.0-linera.1" }
 wasm_thread = "0.3.0"
 wasmer = { package = "linera-wasmer", version = "4.4.0-linera.7", default-features = false }
@@ -213,7 +207,6 @@ wasmer-compiler-singlepass = { package = "linera-wasmer-compiler-singlepass", ve
     "unwind",
     "avx",
 ] }
-wasmparser = "0.101.1"
 wasmtime = { version = "25.0.0", default-features = false, features = [
     "cranelift",
     "runtime",
@@ -280,9 +273,6 @@ max_combination_size = 1
 [profile.dev.package.linera-wasmer]
 opt-level = 3
 
-[profile.dev.package.wasmparser]
-opt-level = 3
-
 [profile.dev.package.wasmtime]
 opt-level = 3
 

Cargo.toml

@@ -3,7 +3,9 @@
 
 fn main() {
     cfg_aliases::cfg_aliases! {
+        web: { all(target_arch = "wasm32", feature = "web") },
         with_testing: { any(test, feature = "test") },
         with_metrics: { all(not(target_arch = "wasm32"), feature = "metrics") },
+        with_graphql: { not(web) },
     };
 }

examples/Cargo.lock

@@ -8,7 +8,6 @@ use std::{
     sync::Arc,
 };
 
-use async_graphql::SimpleObject;
 use futures::stream::{self, StreamExt, TryStreamExt};
 use linera_base::{
     crypto::{CryptoHash, ValidatorPublicKey},
@@ -33,6 +32,7 @@ use linera_views::{
     reentrant_collection_view::ReentrantCollectionView,
     register_view::RegisterView,
     set_view::SetView,
+    store::ReadableKeyValueStore as _,
     views::{ClonableView, CryptoHashView, RootView, View},
 };
 use serde::{Deserialize, Serialize};
@@ -182,7 +182,8 @@ static NUM_OUTBOXES: LazyLock<HistogramVec> = LazyLock::new(|| {
 const EMPTY_BLOCK_SIZE: usize = 94;
 
 /// An origin, cursor and timestamp of a unskippable bundle in our inbox.
-#[derive(Debug, Clone, Serialize, Deserialize, async_graphql::SimpleObject)]
+#[cfg_attr(with_graphql, derive(async_graphql::SimpleObject))]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TimestampedBundleInInbox {
     /// The origin and cursor of the bundle.
     pub entry: BundleInInbox,
@@ -191,9 +192,8 @@ pub struct TimestampedBundleInInbox {
 }
 
 /// An origin and cursor of a unskippable bundle that is no longer in our inbox.
-#[derive(
-    Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize, async_graphql::SimpleObject,
-)]
+#[cfg_attr(with_graphql, derive(async_graphql::SimpleObject))]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
 pub struct BundleInInbox {
     /// The origin from which we received the bundle.
     pub origin: ChainId,
@@ -215,8 +215,12 @@ impl BundleInInbox {
 const TIMESTAMPBUNDLE_BUCKET_SIZE: usize = 100;
 
 /// A view accessing the state of a chain.
-#[derive(Debug, RootView, ClonableView, SimpleObject)]
-#[graphql(cache_control(no_cache))]
+#[cfg_attr(
+    with_graphql,
+    derive(async_graphql::SimpleObject),
+    graphql(cache_control(no_cache))
+)]
+#[derive(Debug, RootView, ClonableView)]
 pub struct ChainStateView<C>
 where
     C: Clone + Context + Send + Sync + 'static,
@@ -262,7 +266,8 @@ where
 }
 
 /// Block-chaining state.
-#[derive(Debug, Default, Clone, Eq, PartialEq, Serialize, Deserialize, SimpleObject)]
+#[cfg_attr(with_graphql, derive(async_graphql::SimpleObject))]
+#[derive(Debug, Default, Clone, Eq, PartialEq, Serialize, Deserialize)]
 pub struct ChainTipState {
     /// Hash of the latest certified block in this chain, if any.
     pub block_hash: Option<CryptoHash>,
@@ -468,7 +473,7 @@ where
     pub async fn validate_incoming_bundles(&self) -> Result<(), ChainError> {
         let chain_id = self.chain_id();
         let pairs = self.inboxes.try_load_all_entries().await?;
-        let max_stream_queries = self.context().max_stream_queries();
+        let max_stream_queries = self.context().store().max_stream_queries();
         let stream = stream::iter(pairs)
             .map(|(origin, inbox)| async move {
                 if let Some(bundle) = inbox.removed_bundles.front().await? {

linera-chain/build.rs

@@ -65,7 +65,8 @@ static REMOVED_BUNDLES: LazyLock<HistogramVec> = LazyLock::new(|| {
 /// * The cursors of added bundles (resp. removed bundles) must be increasing over time.
 /// * Reconciliation of added and removed bundles is allowed to skip some added bundles.
 ///   However, the opposite is not true: every removed bundle must be eventually added.
-#[derive(Debug, ClonableView, View, async_graphql::SimpleObject)]
+#[cfg_attr(with_graphql, derive(async_graphql::SimpleObject))]
+#[derive(Debug, ClonableView, View)]
 pub struct InboxStateView<C>
 where
     C: Clone + Context + Send + Sync,

linera-chain/src/chain.rs

@@ -70,7 +70,6 @@
 
 use std::collections::BTreeMap;
 
-use async_graphql::{ComplexObject, SimpleObject};
 use custom_debug_derive::Debug;
 use futures::future::Either;
 use linera_base::{
@@ -138,8 +137,8 @@ impl LockingBlock {
 }
 
 /// The state of the certification process for a chain's next block.
-#[derive(Debug, View, ClonableView, SimpleObject)]
-#[graphql(complex)]
+#[cfg_attr(with_graphql, derive(async_graphql::SimpleObject), graphql(complex))]
+#[derive(Debug, View, ClonableView)]
 pub struct ChainManager<C>
 where
     C: Clone + Context + Send + Sync + 'static,
@@ -149,37 +148,37 @@ where
     /// The seed for the pseudo-random number generator that determines the round leaders.
     pub seed: RegisterView<C, u64>,
     /// The probability distribution for choosing a round leader.
-    #[graphql(skip)] // Derived from ownership.
+    #[cfg_attr(with_graphql, graphql(skip))] // Derived from ownership.
     pub distribution: RegisterView<C, Option<WeightedAliasIndex<u64>>>,
     /// The probability distribution for choosing a fallback round leader.
-    #[graphql(skip)] // Derived from validator weights.
+    #[cfg_attr(with_graphql, graphql(skip))] // Derived from validator weights.
     pub fallback_distribution: RegisterView<C, Option<WeightedAliasIndex<u64>>>,
     /// Highest-round authenticated block that we have received and checked. If there are multiple
     /// proposals in the same round, this contains only the first one.
-    #[graphql(skip)]
+    #[cfg_attr(with_graphql, graphql(skip))]
     pub proposed: RegisterView<C, Option<BlockProposal>>,
     /// These are blobs published or read by the proposed block.
     pub proposed_blobs: MapView<C, BlobId, Blob>,
     /// Latest validated proposal that a validator may have voted to confirm. This is either the
     /// latest `ValidatedBlock` we have seen, or the proposal from the `Fast` round.
-    #[graphql(skip)]
+    #[cfg_attr(with_graphql, graphql(skip))]
     pub locking_block: RegisterView<C, Option<LockingBlock>>,
     /// These are blobs published or read by the locking block.
     pub locking_blobs: MapView<C, BlobId, Blob>,
     /// Latest leader timeout certificate we have received.
-    #[graphql(skip)]
+    #[cfg_attr(with_graphql, graphql(skip))]
     pub timeout: RegisterView<C, Option<TimeoutCertificate>>,
     /// Latest vote we cast to confirm a block.
-    #[graphql(skip)]
+    #[cfg_attr(with_graphql, graphql(skip))]
     pub confirmed_vote: RegisterView<C, Option<Vote<ConfirmedBlock>>>,
     /// Latest vote we cast to validate a block.
-    #[graphql(skip)]
+    #[cfg_attr(with_graphql, graphql(skip))]
     pub validated_vote: RegisterView<C, Option<Vote<ValidatedBlock>>>,
     /// Latest timeout vote we cast.
-    #[graphql(skip)]
+    #[cfg_attr(with_graphql, graphql(skip))]
     pub timeout_vote: RegisterView<C, Option<Vote<Timeout>>>,
     /// Fallback vote we cast.
-    #[graphql(skip)]
+    #[cfg_attr(with_graphql, graphql(skip))]
     pub fallback_vote: RegisterView<C, Option<Vote<Timeout>>>,
     /// The time after which we are ready to sign a timeout certificate for the current round.
     pub round_timeout: RegisterView<C, Option<Timestamp>>,
@@ -189,13 +188,14 @@ where
     /// Having a leader timeout certificate in any given round causes the next one to become
     /// current. Seeing a validated block certificate or a valid proposal in any round causes that
     /// round to become current, unless a higher one already is.
-    #[graphql(skip)]
+    #[cfg_attr(with_graphql, graphql(skip))]
     pub current_round: RegisterView<C, Round>,
     /// The owners that take over in fallback mode.
     pub fallback_owners: RegisterView<C, BTreeMap<AccountOwner, u64>>,
 }
 
-#[ComplexObject]
+#[cfg(with_graphql)]
+#[async_graphql::ComplexObject]
 impl<C> ChainManager<C>
 where
     C: Context + Clone + Send + Sync + 'static,

linera-chain/src/inbox.rs

@@ -47,7 +47,8 @@ const BLOCK_HEIGHT_BUCKET_SIZE: usize = 1000;
 ///   we just send the certified blocks over and let the receivers figure out what were the
 ///   messages for them.
 /// * When marking block heights as received, messages at lower heights are also marked (i.e. dequeued).
-#[derive(Debug, ClonableView, View, async_graphql::SimpleObject)]
+#[cfg_attr(with_graphql, derive(async_graphql::SimpleObject))]
+#[derive(Debug, ClonableView, View)]
 pub struct OutboxStateView<C>
 where
     C: Context + Send + Sync + 'static,

linera-chain/src/manager.rs

@@ -3,7 +3,6 @@
 
 use std::collections::BTreeMap;
 
-use async_graphql::SimpleObject;
 use linera_base::{
     data_types::{Blob, Round},
     ensure,
@@ -19,7 +18,8 @@ use linera_views::{
 use crate::ChainError;
 
 /// The pending blobs belonging to a block that can't be processed without them.
-#[derive(Debug, View, ClonableView, SimpleObject)]
+#[cfg_attr(with_graphql, derive(async_graphql::SimpleObject))]
+#[derive(Debug, View, ClonableView)]
 pub struct PendingBlobsView<C>
 where
     C: Clone + Context + Send + Sync + 'static,

linera-chain/src/outbox.rs

@@ -7,6 +7,7 @@ fn main() {
 
         with_fs: { all(not(target_arch = "wasm32"), feature = "fs") },
         with_metrics: { all(not(target_arch = "wasm32"), feature = "metrics") },
+        with_graphql: { not(web) },
         with_testing: { any(test, feature = "test") },
         with_tokio_multi_thread: { not(target_arch = "wasm32") },
         with_wasmer: { feature = "wasmer" },