refactor: adding separate logicerror context for reuse in app factory

Author: aorumbayev

crates/algokit_utils/src/applications/app_client/error_transformation.rs

@@ -1,7 +1,8 @@
 use super::types::LogicError;
 use super::{AppClient, AppSourceMaps};
+use crate::AlgorandClient;
 use crate::transactions::TransactionResultError;
-use algokit_abi::arc56_contract::PcOffsetMethod;
+use algokit_abi::{Arc56Contract, arc56_contract::PcOffsetMethod};
 use lazy_static::lazy_static;
 use regex::Regex;
 use serde_json::Value as JsonValue;
@@ -39,6 +40,13 @@ pub(crate) fn extract_logic_error_data(error_str: &str) -> Option<LogicErrorData
     })
 }
 
+pub(crate) struct LogicErrorContext<'logic_error_ctx> {
+    pub app_id: u64,
+    pub app_spec: &'logic_error_ctx Arc56Contract,
+    pub algorand: &'logic_error_ctx AlgorandClient,
+    pub source_maps: Option<&'logic_error_ctx AppSourceMaps>,
+}
+
 impl AppClient {
     /// Import compiled source maps for approval and clear programs.
     pub fn import_source_maps(&mut self, source_maps: AppSourceMaps) {
@@ -51,9 +59,9 @@ impl AppClient {
     }
 }
 
-impl AppClient {
+impl LogicErrorContext<'_> {
     /// Create an enhanced LogicError from a transaction error, applying source maps if available.
-    pub fn expose_logic_error(
+    pub(crate) fn expose_logic_error(
         &self,
         error: &TransactionResultError,
         is_clear_state_program: bool,
@@ -96,7 +104,7 @@ impl AppClient {
         let mut arc56_line_no: Option<u64> = None;
         let mut arc56_listing: Vec<String> = Vec::new();
 
-        if let Some(si_model) = self.app_spec().source_info.as_ref() {
+        if let Some(si_model) = self.app_spec.source_info.as_ref() {
             let program_source_info = if is_clear_state_program {
                 &si_model.clear
             } else {
@@ -134,7 +142,7 @@ impl AppClient {
             }
 
             if arc56_line_no.is_some()
-                && self.app_spec().source.is_some()
+                && self.app_spec.source.is_some()
                 && self.get_source_map(is_clear_state_program).is_none()
             {
                 if let Some(teal_src) = self.decode_teal(is_clear_state_program) {
@@ -156,15 +164,12 @@ impl AppClient {
         if let Some(emsg) = arc56_error_message.or(msg_msg) {
             let app_id_from_msg = Self::extract_app_id(&err_str);
             let app_id = app_id_from_msg
-                .or_else(|| Some(self.app_id().to_string()))
+                .or_else(|| Some(self.app_id.to_string()))
                 .unwrap_or_else(|| "N/A".to_string());
             let txid_str = tx_id.unwrap_or_else(|| "N/A".to_string());
             let runtime_msg = format!(
                 "Runtime error when executing {} (appId: {}) in transaction {}: {}",
-                self.app_spec().name,
-                app_id,
-                txid_str,
-                emsg
+                self.app_spec.name, app_id, txid_str, emsg
             );
             logic.message = runtime_msg.clone();
         }
@@ -224,7 +229,7 @@ impl AppClient {
 
     /// Get the selected program's source map.
     fn get_source_map(&self, is_clear_state_program: bool) -> Option<&JsonValue> {
-        let maps = self.source_maps.as_ref()?;
+        let maps = self.source_maps?;
         if is_clear_state_program {
             maps.clear_source_map.as_ref()
         } else {
@@ -365,15 +370,15 @@ impl AppClient {
     /// This avoids async calls; returns None if not available.
     fn get_program_bytes(&self, is_clear_state_program: bool) -> Option<Vec<u8>> {
         let teal_src = self.decode_teal(is_clear_state_program)?;
-        self.algorand()
+        self.algorand
             .app()
             .get_compilation_result(&teal_src)
             .map(|c| c.compiled_base64_to_bytes)
     }
 
     /// Decode base64 TEAL source from the app spec.
     fn decode_teal(&self, is_clear_state_program: bool) -> Option<String> {
-        let src = self.app_spec().source.as_ref()?;
+        let src = self.app_spec.source.as_ref()?;
         if is_clear_state_program {
             src.get_decoded_clear().ok()
         } else {
@@ -389,3 +394,21 @@ impl AppClient {
             .map(|m| m.as_str().to_string())
     }
 }
+
+impl AppClient {
+    /// Create an enhanced LogicError from a transaction error, applying source maps if available.
+    pub fn expose_logic_error(
+        &self,
+        error: &TransactionResultError,
+        is_clear_state_program: bool,
+    ) -> LogicError {
+        let context = LogicErrorContext {
+            app_id: self.app_id(),
+            app_spec: self.app_spec(),
+            algorand: self.algorand(),
+            source_maps: self.source_maps.as_ref(),
+        };
+
+        context.expose_logic_error(error, is_clear_state_program)
+    }
+}

crates/algokit_utils/src/applications/app_client/mod.rs

@@ -25,7 +25,7 @@ pub struct BoxValue {
 }
 mod compilation;
 mod error;
-mod error_transformation;
+pub(crate) mod error_transformation;
 mod params_builder;
 mod state_accessor;
 mod transaction_builder;

crates/algokit_utils/src/applications/app_factory/mod.rs

@@ -5,6 +5,7 @@ use std::sync::{Arc, Mutex};
 use algokit_abi::arc56_contract::CallOnApplicationComplete;
 use algokit_abi::{ABIReturn, ABIValue, Arc56Contract};
 
+use crate::applications::app_client::error_transformation::LogicErrorContext;
 use crate::applications::app_client::{AppClientMethodCallParams, CompilationParams};
 use crate::applications::app_deployer::{AppLookup, OnSchemaBreak, OnUpdate};
 use crate::applications::app_factory;
@@ -498,22 +499,16 @@ impl AppFactory {
             message: error_str.to_string(),
         };
 
-        let client = AppClient::new(AppClientParams {
+        let source_maps = self.current_source_maps();
+        let context = LogicErrorContext {
             app_id: 0,
-            app_spec: self.app_spec.clone(),
-            algorand: self.algorand.clone(),
-            app_name: Some(self.app_name.clone()),
-            default_sender: self.default_sender.clone(),
-            default_signer: self.default_signer.clone(),
-            source_maps: self.current_source_maps(),
-            transaction_composer_config: self.transaction_composer_config.clone(),
-        });
+            app_spec: &self.app_spec,
+            algorand: self.algorand.as_ref(),
+            source_maps: source_maps.as_ref(),
+        };
 
-        Some(
-            client
-                .expose_logic_error(&tx_err, is_clear_state_program)
-                .message,
-        )
+        let logic = context.expose_logic_error(&tx_err, is_clear_state_program);
+        Some(logic.message)
     }
 
     /// Idempotently deploys (create, update, or replace) an application using