Make the composed operation work in an example.

Author: MathieuDutSik

examples/counter/src/contract.rs

@@ -45,11 +45,11 @@ impl Contract for CounterContract {
         self.state.value.set(value);
     }
 
-    async fn execute_operation(&mut self, operation: CounterOperation) -> u64 {
-        let CounterOperation::Increment(operation) = operation;
-        let new_value = self.state.value.get() + operation;
+    async fn execute_operation(&mut self, operation: CounterOperation) -> CounterOperation {
+        let CounterOperation::Increment(increment) = operation;
+        let new_value = self.state.value.get() + increment;
         self.state.value.set(new_value);
-        new_value
+        operation
     }
 
     async fn execute_message(&mut self, _message: ()) {
@@ -84,8 +84,8 @@ mod tests {
 
         let expected_value = initial_value + increment;
 
-        assert_eq!(response, expected_value);
-        assert_eq!(*counter.state.value.get(), initial_value + increment);
+        assert_eq!(response, CounterOperation::Increment(increment));
+        assert_eq!(*counter.state.value.get(), expected_value);
     }
 
     #[test]
@@ -115,7 +115,7 @@ mod tests {
 
         let expected_value = initial_value + increment;
 
-        assert_eq!(response, expected_value);
+        assert_eq!(response, CounterOperation::Increment(increment));
         assert_eq!(*counter.state.value.get(), expected_value);
     }
 

examples/counter/src/lib.rs

@@ -12,15 +12,15 @@ use serde::{Deserialize, Serialize};
 
 pub struct CounterAbi;
 
-#[derive(Debug, Deserialize, Serialize, GraphQLMutationRoot)]
+#[derive(Debug, Deserialize, PartialEq, Eq, Serialize, GraphQLMutationRoot)]
 pub enum CounterOperation {
     /// Increment the counter by the given value
     Increment(u64),
 }
 
 impl ContractAbi for CounterAbi {
     type Operation = CounterOperation;
-    type Response = u64;
+    type Response = CounterOperation;
 }
 
 impl ServiceAbi for CounterAbi {

linera-core/src/unit_tests/wasm_client_tests.rs

@@ -164,8 +164,10 @@ where
 
     let increment = 5_u64;
     let counter_operation = counter::CounterOperation::Increment(increment);
+    let operation1 = Operation::user(application_id, &counter_operation)?;
+    let operation2 = Operation::user_composed(application_id.forget_abi());
     creator
-        .execute_operation(Operation::user(application_id, &counter_operation)?)
+        .execute_operations(vec![operation1, operation2], vec![])
         .await
         .unwrap();
 
@@ -175,9 +177,10 @@ where
         .await
         .unwrap();
 
+    // We do an increment by 5 and then immediately reiterate it.
     let expected = QueryOutcome {
         response: async_graphql::Response::new(
-            async_graphql::Value::from_json(json!({"value": 15})).unwrap(),
+            async_graphql::Value::from_json(json!({"value": 20})).unwrap(),
         ),
         operations: vec![],
     };

linera-execution/src/wasm/runtime_api.rs

@@ -683,11 +683,20 @@ where
     Runtime: ServiceRuntime + 'static,
 {
     /// Schedules an operation to be included in the block being built by this query.
-    fn schedule_operation(caller: &mut Caller, input: OperationInput) -> Result<(), RuntimeError> {
+    fn schedule_operation(caller: &mut Caller, operation: Vec<u8>) -> Result<(), RuntimeError> {
         caller
             .user_data_mut()
             .runtime
-            .schedule_operation(input)
+            .schedule_operation(OperationInput::Direct(operation))
+            .map_err(|error| RuntimeError::Custom(error.into()))
+    }
+    
+    /// Schedules a composed operation to be included in the block being built by this query.
+    fn schedule_composed_operation(caller: &mut Caller) -> Result<(), RuntimeError> {
+        caller
+            .user_data_mut()
+            .runtime
+            .schedule_operation(OperationInput::Composed)
             .map_err(|error| RuntimeError::Custom(error.into()))
     }
 

linera-sdk/wit/service-runtime-api.wit

@@ -2,6 +2,7 @@ package linera:app;
 
 interface service-runtime-api {
     schedule-operation: func(operation: list<u8>);
+    schedule-composed-operation: func();
     try-query-application: func(application: application-id, argument: list<u8>) -> list<u8>;
     check-execution-time: func(fuel-consumed: u64);