Introduce one smart contract without GraphQL and the corresponding end-to-end test. (#3577)

## Motivation

GraphQL is used all over the Linera code. This led to the question
whether we can program a Linera application without GraphQL. This PR
demonstrates that it is possible.

## Proposal

The following was done:
* Introduce an application `counter-no-graphql` that works without
GraphQL but still uses the `linera-sdk`.
* The `ApplicationWrapper` has been restructured to separate between
json queries and GraphQL queries.

This PR led to some further questions to address in next PRs:
* The `counter-no-graphql` application does not use GraphQL, but it
still typed. We should also have a `counter_untyped` for which
`execute_operation` takes a `Vec<u8>` and does not use the `linera-sdk`
macros.
* Different serializations are being used in the code: `bcs::to_bytes`
and `serde_json::to_vec`. No effort was made to unify this.
* The `raw_operation` function is returning some `CryptoHash` instead of
a `Vec<u8>`. It was not clear how to obtain the result of the
`execute_operation` from the resulting entry.
* The EVM application are untyped. Moving to the `raw_application` seems
premature.

## Test Plan

The test running without GraphQL has been inserted.

## Release Plan

This should be included in next TestNet release.

## Links

None.

Author: MathieuDutSik

Cargo.lock

@@ -250,6 +250,7 @@ linera-witty-macros = { version = "0.14.0", path = "./linera-witty-macros" }
 
 amm = { path = "./examples/amm" }
 counter = { path = "./examples/counter" }
+counter-no-graphql = { path = "./examples/counter-no-graphql" }
 crowd-funding = { path = "./examples/crowd-funding" }
 ethereum-tracker = { path = "./examples/ethereum-tracker" }
 fungible = { path = "./examples/fungible" }

Cargo.toml

@@ -3,6 +3,7 @@ resolver = "2"
 members = [
     "amm",
     "counter",
+    "counter-no-graphql",
     "crowd-funding",
     "ethereum-tracker",
     "fungible",

examples/Cargo.lock

@@ -0,0 +1,26 @@
+[package]
+name = "counter-no-graphql"
+version = "0.1.0"
+authors = ["Linera <[email protected]>"]
+edition = "2021"
+
+[dependencies]
+futures.workspace = true
+linera-sdk.workspace = true
+serde.workspace = true
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+linera-sdk = { workspace = true, features = ["test", "wasmer"] }
+tokio = { workspace = true, features = ["rt", "sync"] }
+
+[dev-dependencies]
+assert_matches.workspace = true
+linera-sdk = { workspace = true, features = ["test"] }
+
+[[bin]]
+name = "counter_no_graphql_contract"
+path = "src/contract.rs"
+
+[[bin]]
+name = "counter_no_graphql_service"
+path = "src/service.rs"

examples/Cargo.toml

@@ -0,0 +1,16 @@
+# Counter No GraphQL Example Application
+
+This example application implements a simple counter contract, it is initialized with an
+unsigned integer that can be increased by the `increment` operation. In contrast with the
+counter application, it works without GraphQL 
+
+## How It Works
+
+It is a very basic Linera application, which is initialized by a `u64` which can be incremented
+by a `u64`.
+
+For example, if the contract was initialized with 1, querying the contract would give us 1. Now if we want to
+`increment` it by 3, we will have to perform an operation with the parameter being 3. Now querying the
+application would give us 4 (1+3 = 4).
+
+## Usage

examples/counter-no-graphql/Cargo.toml

@@ -0,0 +1,139 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+#![cfg_attr(target_arch = "wasm32", no_main)]
+
+mod state;
+
+use counter_no_graphql::{CounterNoGraphQlAbi, CounterOperation};
+use linera_sdk::{
+    linera_base_types::WithContractAbi,
+    views::{RootView, View},
+    Contract, ContractRuntime,
+};
+
+use self::state::CounterState;
+
+pub struct CounterContract {
+    state: CounterState,
+    runtime: ContractRuntime<Self>,
+}
+
+linera_sdk::contract!(CounterContract);
+
+impl WithContractAbi for CounterContract {
+    type Abi = CounterNoGraphQlAbi;
+}
+
+impl Contract for CounterContract {
+    type Message = ();
+    type InstantiationArgument = u64;
+    type Parameters = ();
+
+    async fn load(runtime: ContractRuntime<Self>) -> Self {
+        let state = CounterState::load(runtime.root_view_storage_context())
+            .await
+            .expect("Failed to load state");
+        CounterContract { state, runtime }
+    }
+
+    async fn instantiate(&mut self, value: u64) {
+        // Validate that the application parameters were configured correctly.
+        self.runtime.application_parameters();
+
+        self.state.value.set(value);
+    }
+
+    async fn execute_operation(&mut self, operation: CounterOperation) -> u64 {
+        let previous_value = self.state.value.get();
+        let CounterOperation::Increment(value) = operation;
+        let new_value = previous_value + value;
+        self.state.value.set(new_value);
+        new_value
+    }
+
+    async fn execute_message(&mut self, _message: ()) {
+        panic!("Counter application doesn't support any cross-chain messages");
+    }
+
+    async fn store(mut self) {
+        self.state.save().await.expect("Failed to save state");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use futures::FutureExt as _;
+    use linera_sdk::{util::BlockingWait, views::View, Contract, ContractRuntime};
+
+    use super::{CounterContract, CounterOperation, CounterState};
+
+    #[test]
+    fn operation() {
+        let initial_value = 72_u64;
+        let mut counter = create_and_instantiate_counter(initial_value);
+
+        let increment = 42_308_u64;
+        let operation = CounterOperation::Increment(increment);
+
+        let response = counter
+            .execute_operation(operation)
+            .now_or_never()
+            .expect("Execution of counter operation should not await anything");
+
+        let expected_value = initial_value + increment;
+
+        assert_eq!(response, expected_value);
+        assert_eq!(*counter.state.value.get(), initial_value + increment);
+    }
+
+    #[test]
+    #[should_panic(expected = "Counter application doesn't support any cross-chain messages")]
+    fn message() {
+        let initial_value = 72_u64;
+        let mut counter = create_and_instantiate_counter(initial_value);
+
+        counter
+            .execute_message(())
+            .now_or_never()
+            .expect("Execution of counter operation should not await anything");
+    }
+
+    #[test]
+    fn cross_application_call() {
+        let initial_value = 2_845_u64;
+        let mut counter = create_and_instantiate_counter(initial_value);
+
+        let increment = 8_u64;
+        let operation = CounterOperation::Increment(increment);
+
+        let response = counter
+            .execute_operation(operation)
+            .now_or_never()
+            .expect("Execution of counter operation should not await anything");
+
+        let expected_value = initial_value + increment;
+
+        assert_eq!(response, expected_value);
+        assert_eq!(*counter.state.value.get(), expected_value);
+    }
+
+    fn create_and_instantiate_counter(initial_value: u64) -> CounterContract {
+        let runtime = ContractRuntime::new().with_application_parameters(());
+        let mut contract = CounterContract {
+            state: CounterState::load(runtime.root_view_storage_context())
+                .blocking_wait()
+                .expect("Failed to read from mock key value store"),
+            runtime,
+        };
+
+        contract
+            .instantiate(initial_value)
+            .now_or_never()
+            .expect("Initialization of counter state should not await anything");
+
+        assert_eq!(*contract.state.value.get(), initial_value);
+
+        contract
+    }
+}

examples/counter-no-graphql/README.md

@@ -0,0 +1,30 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/*! ABI of the Counter Example Application that does not use GraphQL */
+
+use linera_sdk::linera_base_types::{ContractAbi, ServiceAbi};
+use serde::{Deserialize, Serialize};
+
+pub struct CounterNoGraphQlAbi;
+
+impl ContractAbi for CounterNoGraphQlAbi {
+    type Operation = CounterOperation;
+    type Response = u64;
+}
+
+impl ServiceAbi for CounterNoGraphQlAbi {
+    type Query = CounterRequest;
+    type QueryResponse = u64;
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum CounterRequest {
+    Query,
+    Increment(u64),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum CounterOperation {
+    Increment(u64),
+}

examples/counter-no-graphql/src/contract.rs

@@ -0,0 +1,79 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+#![cfg_attr(target_arch = "wasm32", no_main)]
+
+mod state;
+
+use std::sync::Arc;
+
+use counter_no_graphql::{CounterOperation, CounterRequest};
+use linera_sdk::{linera_base_types::WithServiceAbi, views::View, Service, ServiceRuntime};
+
+use self::state::CounterState;
+
+pub struct CounterService {
+    state: CounterState,
+    runtime: Arc<ServiceRuntime<Self>>,
+}
+
+linera_sdk::service!(CounterService);
+
+impl WithServiceAbi for CounterService {
+    type Abi = counter_no_graphql::CounterNoGraphQlAbi;
+}
+
+impl Service for CounterService {
+    type Parameters = ();
+
+    async fn new(runtime: ServiceRuntime<Self>) -> Self {
+        let state = CounterState::load(runtime.root_view_storage_context())
+            .await
+            .expect("Failed to load state");
+        CounterService {
+            state,
+            runtime: Arc::new(runtime),
+        }
+    }
+
+    async fn handle_query(&self, request: CounterRequest) -> u64 {
+        match request {
+            CounterRequest::Query => *self.state.value.get(),
+            CounterRequest::Increment(value) => {
+                let operation = CounterOperation::Increment(value);
+                self.runtime.schedule_operation(&operation);
+                0
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use futures::FutureExt as _;
+    use linera_sdk::{util::BlockingWait, views::View, Service, ServiceRuntime};
+
+    use super::{CounterRequest, CounterService, CounterState};
+
+    #[test]
+    fn query() {
+        let value = 61_098_721_u64;
+        let runtime = Arc::new(ServiceRuntime::<CounterService>::new());
+        let mut state = CounterState::load(runtime.root_view_storage_context())
+            .blocking_wait()
+            .expect("Failed to read from mock key value store");
+        state.value.set(value);
+
+        let service = CounterService { state, runtime };
+        let request = CounterRequest::Query;
+
+        let response = service
+            .handle_query(request)
+            .now_or_never()
+            .expect("Query should not await anything");
+
+        assert_eq!(response, value)
+    }
+}

examples/counter-no-graphql/src/lib.rs

@@ -0,0 +1,11 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+use linera_sdk::views::{linera_views, RegisterView, RootView, ViewStorageContext};
+
+/// The application state.
+#[derive(RootView)]
+#[view(context = "ViewStorageContext")]
+pub struct CounterState {
+    pub value: RegisterView<u64>,
+}