removed multiversx-sdk dependency from multiversx-sc-scenario

contracts/feature-tests/abi-tester/src/abi_test_type.rs

@@ -45,5 +45,6 @@ pub struct OnlyShowsUpInEsdtAttr {
 
 #[derive(TypeAbi)]
 pub struct ManagedDecimalWrapper<M: ManagedTypeApi> {
+    #[allow(dead_code)]
     pub field: ManagedDecimal<M, ConstDecimals<2>>,
 }

framework/base/src/storage/mappers/vec_mapper.rs

@@ -12,7 +12,7 @@ use crate::{
     storage::{storage_clear, storage_set, StorageKey},
     types::{ManagedAddress, ManagedType, MultiValueEncoded},
 };
-use core::{marker::PhantomData, usize};
+use core::marker::PhantomData;
 
 const ITEM_SUFFIX: &[u8] = b".item";
 const LEN_SUFFIX: &[u8] = b".len";

framework/scenario/Cargo.toml

@@ -55,7 +55,3 @@ version = "0.2.0"
 [dependencies.multiversx-chain-vm]
 version = "=0.8.4"
 path = "../../vm"
-
-[dependencies.multiversx-sdk]
-version = "=0.4.1"
-path = "../../sdk/core"

framework/scenario/src/scenario/model/transaction/tx_response.rs

@@ -1,6 +1,5 @@
 use multiversx_chain_vm::tx_mock::TxResult;
 use multiversx_sc::types::Address;
-use multiversx_sdk::data::transaction::{ApiLogs, ApiSmartContractResult};
 
 use super::{Log, TxExpect, TxResponseStatus};
 
@@ -21,10 +20,6 @@ pub struct TxResponse {
     pub gas: u64,
     /// The refund of the transaction.
     pub refund: u64,
-    /// The smart contract results of the transaction.
-    pub api_scrs: Vec<ApiSmartContractResult>,
-    /// The api logs of the transaction.
-    pub api_logs: Option<ApiLogs>,
 }
 
 impl TxResponse {

framework/snippets/src/network_response.rs

@@ -13,29 +13,19 @@ const LOG_IDENTIFIER_SIGNAL_ERROR: &str = "signalError";
 
 /// Creates a [`TxResponse`] from a [`TransactionOnNetwork`].
 pub fn parse_tx_response(tx: TransactionOnNetwork) -> TxResponse {
-    let mut response = TxResponse {
-        api_scrs: tx.smart_contract_results.unwrap_or_default(),
-        api_logs: tx.logs,
-        ..Default::default()
-    };
-
-    response.tx_error = process_signal_error(&response);
-    if !response.tx_error.is_success() {
-        return response;
+    let tx_error = process_signal_error(&tx);
+    if !tx_error.is_success() {
+        return TxResponse {
+            tx_error,
+            ..Default::default()
+        };
     }
 
-    process(
-        &mut response,
-        tx.sender.to_bytes(),
-        tx.nonce,
-        tx.processing_type_on_destination,
-    );
-
-    response
+    process_success(&tx)
 }
 
-fn process_signal_error(tx_response: &TxResponse) -> TxResponseStatus {
-    if let Some(event) = find_log(tx_response, LOG_IDENTIFIER_SIGNAL_ERROR) {
+fn process_signal_error(tx: &TransactionOnNetwork) -> TxResponseStatus {
+    if let Some(event) = find_log(tx, LOG_IDENTIFIER_SIGNAL_ERROR) {
         let topics = event.topics.as_ref();
         if let Some(error) = process_topics_error(topics) {
             return TxResponseStatus::signal_error(&error);
@@ -49,34 +39,27 @@ fn process_signal_error(tx_response: &TxResponse) -> TxResponseStatus {
     TxResponseStatus::default()
 }
 
-fn process(
-    tx_response: &mut TxResponse,
-    sender_address: [u8; 32],
-    nonce: u64,
-    processing_type_on_destination: String,
-) {
-    process_out(tx_response);
-    process_new_deployed_address(
-        tx_response,
-        sender_address,
-        nonce,
-        processing_type_on_destination,
-    );
-    process_new_issued_token_identifier(tx_response);
+fn process_success(tx: &TransactionOnNetwork) -> TxResponse {
+    TxResponse {
+        out: process_out(tx),
+        new_deployed_address: process_new_deployed_address(tx),
+        new_issued_token_identifier: process_new_issued_token_identifier(tx),
+        ..Default::default()
+    }
 }
 
-fn process_out(tx_response: &mut TxResponse) {
-    let out_scr = tx_response.api_scrs.iter().find(is_out_scr);
+fn process_out(tx: &TransactionOnNetwork) -> Vec<Vec<u8>> {
+    let out_scr = tx.smart_contract_results.iter().find(is_out_scr);
 
     if let Some(out_scr) = out_scr {
-        tx_response.out = decode_scr_data_or_panic(&out_scr.data);
-    } else if let Some(data) = process_out_from_log(tx_response) {
-        tx_response.out = data
+        decode_scr_data_or_panic(&out_scr.data)
+    } else {
+        process_out_from_log(tx).unwrap_or_default()
     }
 }
 
-fn process_out_from_log(tx_response: &TxResponse) -> Option<Vec<Vec<u8>>> {
-    if let Some(logs) = &tx_response.api_logs {
+fn process_out_from_log(tx: &TransactionOnNetwork) -> Option<Vec<Vec<u8>>> {
+    if let Some(logs) = &tx.logs {
         logs.events.iter().rev().find_map(|event| {
             if event.identifier == "writeLog" {
                 if let Some(data) = &event.data {
@@ -96,17 +79,13 @@ fn process_out_from_log(tx_response: &TxResponse) -> Option<Vec<Vec<u8>>> {
     }
 }
 
-fn process_new_deployed_address(
-    tx_response: &mut TxResponse,
-    sender_address_bytes: [u8; 32],
-    nonce: u64,
-    processing_type_on_destination: String,
-) {
-    if processing_type_on_destination != SC_DEPLOY_PROCESSING_TYPE {
-        return;
+fn process_new_deployed_address(tx: &TransactionOnNetwork) -> Option<Address> {
+    if tx.processing_type_on_destination != SC_DEPLOY_PROCESSING_TYPE {
+        return None;
     }
 
-    let sender_nonce_bytes = nonce.to_le_bytes();
+    let sender_address_bytes = tx.sender.to_bytes();
+    let sender_nonce_bytes = tx.nonce.to_le_bytes();
     let mut bytes_to_hash: Vec<u8> = Vec::new();
     bytes_to_hash.extend_from_slice(&sender_address_bytes);
     bytes_to_hash.extend_from_slice(&sender_nonce_bytes);
@@ -120,17 +99,17 @@ fn process_new_deployed_address(
     address[10..30].copy_from_slice(&address_keccak[10..30]);
     address[30..32].copy_from_slice(&sender_address_bytes[30..32]);
 
-    tx_response.new_deployed_address = Some(Address::from(address));
+    Some(Address::from(address))
 }
 
-fn process_new_issued_token_identifier(tx_response: &mut TxResponse) {
-    for scr in tx_response.api_scrs.iter() {
+fn process_new_issued_token_identifier(tx: &TransactionOnNetwork) -> Option<String> {
+    for scr in tx.smart_contract_results.iter() {
         if scr.sender.to_bech32_string().unwrap() != ESDTSystemSCAddress.to_bech32_string() {
             continue;
         }
 
-        let Some(prev_tx) = tx_response
-            .api_scrs
+        let Some(prev_tx) = tx
+            .smart_contract_results
             .iter()
             .find(|e| e.hash == scr.prev_tx_hash)
         else {
@@ -155,30 +134,18 @@ fn process_new_issued_token_identifier(tx_response: &mut TxResponse) {
 
         if scr.data.starts_with("ESDTTransfer@") {
             let encoded_tid = scr.data.split('@').nth(1);
-            if encoded_tid.is_none() {
-                return;
-            }
-
-            tx_response.new_issued_token_identifier =
-                Some(String::from_utf8(hex::decode(encoded_tid.unwrap()).unwrap()).unwrap());
-
-            break;
+            return Some(String::from_utf8(hex::decode(encoded_tid?).unwrap()).unwrap());
         } else if scr.data.starts_with("@00@") {
             let encoded_tid = scr.data.split('@').nth(2);
-            if encoded_tid.is_none() {
-                return;
-            }
-
-            tx_response.new_issued_token_identifier =
-                Some(String::from_utf8(hex::decode(encoded_tid.unwrap()).unwrap()).unwrap());
-
-            break;
+            return Some(String::from_utf8(hex::decode(encoded_tid?).unwrap()).unwrap());
         }
     }
+
+    None
 }
 
-fn find_log<'a>(tx_response: &'a TxResponse, log_identifier: &str) -> Option<&'a Events> {
-    if let Some(logs) = &tx_response.api_logs {
+fn find_log<'a>(tx: &'a TransactionOnNetwork, log_identifier: &str) -> Option<&'a Events> {
+    if let Some(logs) = &tx.logs {
         logs.events
             .iter()
             .find(|event| event.identifier == log_identifier)

framework/snippets/tests/test_tx_multiple_sc_results.rs

@@ -281,7 +281,9 @@ fn test_transaction_multiple_sc_results() {
         .data
         .unwrap()
         .transaction;
-    let tx_response = network_response::parse_tx_response(tx_on_network);
-    assert_eq!(tx_response.api_scrs.len(), 4usize);
-    assert!(is_out_scr(&tx_response.api_scrs.get(2).unwrap()));
+    assert_eq!(tx_on_network.smart_contract_results.len(), 4usize);
+    assert!(is_out_scr(
+        &tx_on_network.smart_contract_results.get(2).unwrap()
+    ));
+    let _ = network_response::parse_tx_response(tx_on_network);
 }

sdk/core/src/data/transaction.rs

@@ -80,7 +80,8 @@ pub struct TransactionOnNetwork {
     pub status: String,
     pub hyperblock_nonce: Option<u64>,
     pub hyperblock_hash: Option<String>,
-    pub smart_contract_results: Option<Vec<ApiSmartContractResult>>,
+    #[serde(default)]
+    pub smart_contract_results: Vec<ApiSmartContractResult>,
     pub logs: Option<ApiLogs>,
 }