unified syntax - ReturnsResultOrError + tests

contracts/feature-tests/scenario-tester/scenarios/interactor_trace.scen.json

@@ -36,7 +36,9 @@
                 "gasLimit": "70,000,000"
             },
             "expect": {
-                "out": [],
+                "out": [
+                    "str:init-result"
+                ],
                 "status": "0"
             }
         },

contracts/feature-tests/scenario-tester/scenarios/st-adder.scen.json

@@ -32,7 +32,9 @@
                 "gasPrice": "0"
             },
             "expect": {
-                "out": [],
+                "out": [
+                    "str:init-result"
+                ],
                 "status": "",
                 "logs": "*",
                 "gas": "*",

contracts/feature-tests/scenario-tester/src/lib.rs

@@ -12,9 +12,11 @@ pub trait ScenarioTester {
     #[storage_mapper("sum")]
     fn sum(&self) -> SingleValueMapper<BigUint>;
 
+    /// Return value for testing reasons.
     #[init]
-    fn init(&self, initial_value: BigUint) {
+    fn init(&self, initial_value: BigUint) -> &'static str {
         self.sum().set(initial_value);
+        "init-result"
     }
 
     #[upgrade]

contracts/feature-tests/scenario-tester/src/scenario_tester_proxy.rs

@@ -43,12 +43,13 @@ where
     From: TxFrom<Env>,
     Gas: TxGas<Env>,
 {
+    /// Return value for testing reasons. 
     pub fn init<
         Arg0: ProxyArg<BigUint<Env::Api>>,
     >(
         self,
         initial_value: Arg0,
-    ) -> TxTypedDeploy<Env, From, NotPayable, Gas, ()> {
+    ) -> TxTypedDeploy<Env, From, NotPayable, Gas, &'static str> {
         self.wrapped_tx
             .payment(NotPayable)
             .raw_deploy()

contracts/feature-tests/scenario-tester/tests/st_blackbox_raw_steps_test.rs

@@ -25,7 +25,7 @@ fn scenario_tester_blackbox_raw() {
                 .from("address:owner")
                 .code(scenario_tester_code)
                 .argument("5")
-                .expect(TxExpect::ok().no_result()),
+                .expect(TxExpect::ok().result("str:init-result")),
         )
         .sc_query(
             ScQueryStep::new()

contracts/feature-tests/scenario-tester/tests/st_blackbox_test.rs

@@ -286,3 +286,41 @@ fn st_blackbox_tx_hash() {
 
     assert_eq!(tx_hash.as_array(), &[22u8; 32]);
 }
+
+#[test]
+fn st_blackbox_returns_result_or_error() {
+    let mut world = world();
+
+    world
+        .account(OWNER_ADDRESS)
+        .nonce(1)
+        .balance(100)
+        .account(OTHER_ADDRESS)
+        .nonce(2)
+        .balance(300)
+        .esdt_balance(TOKEN_ID, 500)
+        .commit();
+
+    let (result, check_tx_hash) = world
+        .tx()
+        .from(OWNER_ADDRESS)
+        .typed(scenario_tester_proxy::ScenarioTesterProxy)
+        .init(5u32)
+        .code(CODE_PATH)
+        .new_address(ST_ADDRESS)
+        .tx_hash([33u8; 32])
+        .returns(
+            ReturnsResultOrError::new()
+                .returns(ReturnsNewAddress)
+                .returns(ReturnsResultAs::<String>::new())
+                .returns(ReturnsTxHash),
+        )
+        .returns(ReturnsTxHash)
+        .run();
+
+    assert_eq!(check_tx_hash.as_array(), &[33u8; 32]);
+    let (new_address, out_value, also_check_tx_hash) = result.unwrap();
+    assert_eq!(new_address, ST_ADDRESS.to_address());
+    assert_eq!(out_value, "init-result");
+    assert_eq!(also_check_tx_hash.as_array(), &[33u8; 32]);
+}

contracts/feature-tests/scenario-tester/tests/st_blackbox_upgrade_test.rs

@@ -29,7 +29,7 @@ fn st_blackbox_upgrade() {
                 .code(&st_code)
                 .argument("5")
                 .gas_limit("5,000,000")
-                .expect(TxExpect::ok().no_result()),
+                .expect(TxExpect::ok().result("str:init-result")),
         )
         .sc_call(
             ScCallStep::new()

framework/scenario/src/facade/result_handlers.rs

@@ -6,6 +6,7 @@ mod returns_logs;
 mod returns_message;
 mod returns_new_bech32_address;
 mod returns_new_token_identifier;
+mod returns_result_or_err;
 mod returns_status;
 mod returns_tx_hash;
 mod with_tx_raw_response;
@@ -18,6 +19,7 @@ pub use returns_logs::ReturnsLogs;
 pub use returns_message::ReturnsMessage;
 pub use returns_new_bech32_address::ReturnsNewBech32Address;
 pub use returns_new_token_identifier::ReturnsNewTokenIdentifier;
+pub use returns_result_or_err::ReturnsResultOrError;
 pub use returns_status::ReturnsStatus;
 pub use returns_tx_hash::ReturnsTxHash;
 pub use with_tx_raw_response::WithRawTxResponse;

framework/scenario/src/facade/result_handlers/returns_result_or_err.rs

@@ -0,0 +1,89 @@
+use std::marker::PhantomData;
+
+use multiversx_sc::{
+    tuple_util::NestedTupleFlatten,
+    types::{
+        OriginalResultMarker, RHList, RHListAppendRet, RHListExec, RHListItem, RHListItemExec,
+        TxEnv,
+    },
+};
+
+use crate::scenario_model::{TxResponse, TxResponseStatus};
+
+/// Indicates that a `Result` will be returned, either with the handled result,
+/// according to the inner result handlers, or with an error in case of a failed transaction.
+pub struct ReturnsResultOrError<Env, Original, Ok>
+where
+    Env: TxEnv,
+    Ok: RHList<Env>,
+{
+    _phantom_env: PhantomData<Env>,
+    _phantom_original: PhantomData<Original>,
+    pub ok_t: Ok,
+}
+
+impl<Env, Original> Default for ReturnsResultOrError<Env, Original, OriginalResultMarker<Original>>
+where
+    Env: TxEnv,
+{
+    fn default() -> Self {
+        ReturnsResultOrError {
+            _phantom_env: PhantomData,
+            _phantom_original: PhantomData,
+            ok_t: OriginalResultMarker::new(),
+        }
+    }
+}
+
+impl<Env, Original> ReturnsResultOrError<Env, Original, OriginalResultMarker<Original>>
+where
+    Env: TxEnv,
+{
+    pub fn new() -> Self {
+        ReturnsResultOrError::default()
+    }
+}
+
+impl<Env, Original, Ok> ReturnsResultOrError<Env, Original, Ok>
+where
+    Env: TxEnv,
+    Ok: RHListExec<TxResponse, Env>,
+{
+    pub fn returns<RH>(self, item: RH) -> ReturnsResultOrError<Env, Original, Ok::RetOutput>
+    where
+        RH: RHListItem<Env, Ok::OriginalResult>,
+        Ok: RHListAppendRet<Env, RH>,
+    {
+        ReturnsResultOrError {
+            _phantom_env: PhantomData,
+            _phantom_original: PhantomData,
+            ok_t: self.ok_t.append_ret(item),
+        }
+    }
+}
+
+impl<Env, Original, Ok> RHListItem<Env, Original> for ReturnsResultOrError<Env, Original, Ok>
+where
+    Env: TxEnv,
+    Ok: RHListExec<TxResponse, Env>,
+    Ok::ListReturns: NestedTupleFlatten,
+{
+    type Returns = Result<<Ok::ListReturns as NestedTupleFlatten>::Unpacked, TxResponseStatus>;
+}
+
+impl<Env, Original, Ok> RHListItemExec<TxResponse, Env, Original>
+    for ReturnsResultOrError<Env, Original, Ok>
+where
+    Env: TxEnv,
+    Ok: RHListExec<TxResponse, Env>,
+    Ok::ListReturns: NestedTupleFlatten,
+{
+    fn item_process_result(self, raw_result: &TxResponse) -> Self::Returns {
+        if raw_result.tx_error.is_success() {
+            let tuple_result = self.ok_t.list_process_result(raw_result);
+            Ok(tuple_result.flatten_unpack())
+        } else {
+            Err(raw_result.tx_error.clone())
+        }
+    }
+}