diff --git a/cw-orch/src/osmosis_test_tube/core.rs b/cw-orch/src/osmosis_test_tube/core.rs
index beeb8409d..320160950 100644
--- a/cw-orch/src/osmosis_test_tube/core.rs
+++ b/cw-orch/src/osmosis_test_tube/core.rs
@@ -6,6 +6,7 @@ use osmosis_test_tube::Account;
 use osmosis_test_tube::Bank;
 use osmosis_test_tube::Gamm;
 use osmosis_test_tube::Module;
+use osmosis_test_tube::RunnerError;
 use osmosis_test_tube::SigningAccount;
 use osmosis_test_tube::Wasm;
 use std::str::FromStr;
@@ -73,6 +74,12 @@ pub struct OsmosisTestTube<S: StateInterface = MockState> {
     pub app: Rc<RefCell<OsmosisTestApp>>,
 }
 
+/// Maps a RunnerError (from osmosis-test-tube), to a CwOrch Error
+/// As we don't have a custom Error type for this integration, we use this helper function to map errors instead
+pub fn map_err(e: RunnerError) -> CwOrchError {
+    CwOrchError::StdErr(format!("Osmosis Test Tube Error : {}", e))
+}
+
 impl<S: StateInterface> OsmosisTestTube<S> {
     /// Creates an account and sets its balance
     pub fn init_account(
@@ -82,7 +89,7 @@ impl<S: StateInterface> OsmosisTestTube<S> {
         self.app
             .borrow()
             .init_account(&amount)
-            .map_err(Into::into)
+            .map_err(map_err)
             .map(Rc::new)
     }
 
@@ -95,7 +102,7 @@ impl<S: StateInterface> OsmosisTestTube<S> {
         self.app
             .borrow()
             .init_accounts(&amount, account_n)
-            .map_err(Into::into)
+            .map_err(map_err)
             .map(|s| s.into_iter().map(Rc::new).collect())
     }
 
@@ -105,14 +112,16 @@ impl<S: StateInterface> OsmosisTestTube<S> {
         to: String,
         amount: Vec<cosmwasm_std::Coin>,
     ) -> Result<AppResponse, CwOrchError> {
-        let send_response = Bank::new(&*self.app.borrow()).send(
-            MsgSend {
-                from_address: self.sender.address(),
-                to_address: to,
-                amount: cosmwasm_to_proto_coins(amount),
-            },
-            &self.sender,
-        )?;
+        let send_response = Bank::new(&*self.app.borrow())
+            .send(
+                MsgSend {
+                    from_address: self.sender.address(),
+                    to_address: to,
+                    amount: cosmwasm_to_proto_coins(amount),
+                },
+                &self.sender,
+            )
+            .map_err(map_err)?;
 
         Ok(AppResponse {
             data: Some(Binary(send_response.raw_data)),
@@ -139,7 +148,8 @@ impl<S: StateInterface> OsmosisTestTube<S> {
             .query_balance(&QueryBalanceRequest {
                 address: address.to_owned(),
                 denom: denom.to_string(),
-            })?
+            })
+            .map_err(map_err)?
             .balance
             .map(|c| Uint128::from_str(&c.amount).unwrap())
             .unwrap_or(Uint128::zero());
@@ -155,7 +165,8 @@ impl<S: StateInterface> OsmosisTestTube<S> {
             .query_all_balances(&QueryAllBalancesRequest {
                 address: address.to_owned(),
                 pagination: None,
-            })?
+            })
+            .map_err(map_err)?
             .balances
             .into_iter()
             .map(|c| Coin {
@@ -219,8 +230,9 @@ impl<S: StateInterface> TxHandler for OsmosisTestTube<S> {
 
     fn upload(&self, contract: &impl Uploadable) -> Result<Self::Response, CwOrchError> {
         let wasm_contents = std::fs::read(contract.wasm().path())?;
-        let upload_response =
-            Wasm::new(&*self.app.borrow()).store_code(&wasm_contents, None, &self.sender)?;
+        let upload_response = Wasm::new(&*self.app.borrow())
+            .store_code(&wasm_contents, None, &self.sender)
+            .map_err(map_err)?;
 
         Ok(AppResponse {
             data: Some(Binary(upload_response.raw_data)),
@@ -234,12 +246,9 @@ impl<S: StateInterface> TxHandler for OsmosisTestTube<S> {
         coins: &[cosmwasm_std::Coin],
         contract_address: &Addr,
     ) -> Result<Self::Response, CwOrchError> {
-        let execute_response = Wasm::new(&*self.app.borrow()).execute(
-            contract_address.as_ref(),
-            exec_msg,
-            coins,
-            &self.sender,
-        )?;
+        let execute_response = Wasm::new(&*self.app.borrow())
+            .execute(contract_address.as_ref(), exec_msg, coins, &self.sender)
+            .map_err(map_err)?;
 
         Ok(AppResponse {
             data: Some(Binary(execute_response.raw_data)),
@@ -255,14 +264,16 @@ impl<S: StateInterface> TxHandler for OsmosisTestTube<S> {
         admin: Option<&Addr>,
         coins: &[cosmwasm_std::Coin],
     ) -> Result<Self::Response, CwOrchError> {
-        let instantiate_response = Wasm::new(&*self.app.borrow()).instantiate(
-            code_id,
-            init_msg,
-            admin.map(|a| a.to_string()).as_deref(),
-            label,
-            coins,
-            &self.sender,
-        )?;
+        let instantiate_response = Wasm::new(&*self.app.borrow())
+            .instantiate(
+                code_id,
+                init_msg,
+                admin.map(|a| a.to_string()).as_deref(),
+                label,
+                coins,
+                &self.sender,
+            )
+            .map_err(map_err)?;
 
         Ok(AppResponse {
             data: Some(Binary(instantiate_response.raw_data)),
@@ -275,7 +286,9 @@ impl<S: StateInterface> TxHandler for OsmosisTestTube<S> {
         query_msg: &Q,
         contract_address: &Addr,
     ) -> Result<T, CwOrchError> {
-        let query = Wasm::new(&*self.app.borrow()).query(contract_address.as_ref(), query_msg)?;
+        let query = Wasm::new(&*self.app.borrow())
+            .query(contract_address.as_ref(), query_msg)
+            .map_err(map_err)?;
 
         Ok(query)
     }