diff --git a/examples/demo-stf/src/sov-cli/native.rs b/examples/demo-stf/src/sov-cli/native.rs
index 11d0ce446..f7e4076bb 100644
--- a/examples/demo-stf/src/sov-cli/native.rs
+++ b/examples/demo-stf/src/sov-cli/native.rs
@@ -534,7 +534,8 @@ mod test {
         let balance = demo
             .runtime
             .bank
-            .balance_of(user_address, token_address, &mut working_set);
+            .balance_of(user_address, token_address, &mut working_set)
+            .unwrap();
 
         balance.amount
     }
diff --git a/examples/demo-stf/src/tests/stf_tests.rs b/examples/demo-stf/src/tests/stf_tests.rs
index 2981eaa95..055826c9d 100644
--- a/examples/demo-stf/src/tests/stf_tests.rs
+++ b/examples/demo-stf/src/tests/stf_tests.rs
@@ -58,7 +58,7 @@ pub mod test {
             let storage = ProverStorage::with_path(path).unwrap();
             let mut working_set = WorkingSet::new(storage);
 
-            let resp = runtime.election.results(&mut working_set);
+            let resp = runtime.election.results(&mut working_set).unwrap();
 
             assert_eq!(
                 resp,
@@ -67,7 +67,7 @@ pub mod test {
                     count: 3
                 }))
             );
-            let resp = runtime.value_setter.query_value(&mut working_set);
+            let resp = runtime.value_setter.query_value(&mut working_set).unwrap();
 
             assert_eq!(resp, sov_value_setter::Response { value: Some(33) });
         }
@@ -112,7 +112,7 @@ pub mod test {
         let runtime = &mut Runtime::<DefaultContext>::default();
         let mut working_set = WorkingSet::new(demo.current_storage.clone());
 
-        let resp = runtime.election.results(&mut working_set);
+        let resp = runtime.election.results(&mut working_set).unwrap();
 
         assert_eq!(
             resp,
@@ -122,7 +122,7 @@ pub mod test {
             }))
         );
 
-        let resp = runtime.value_setter.query_value(&mut working_set);
+        let resp = runtime.value_setter.query_value(&mut working_set).unwrap();
 
         assert_eq!(resp, sov_value_setter::Response { value: Some(33) });
     }
@@ -170,14 +170,14 @@ pub mod test {
             let storage = ProverStorage::with_path(path).unwrap();
             let mut working_set = WorkingSet::new(storage);
 
-            let resp = runtime.election.results(&mut working_set);
+            let resp = runtime.election.results(&mut working_set).unwrap();
 
             assert_eq!(
                 resp,
                 sov_election::GetResultResponse::Err("Election is not frozen".to_owned())
             );
 
-            let resp = runtime.value_setter.query_value(&mut working_set);
+            let resp = runtime.value_setter.query_value(&mut working_set).unwrap();
 
             assert_eq!(resp, sov_value_setter::Response { value: None });
         }
diff --git a/examples/demo-stf/src/tests/tx_revert_tests.rs b/examples/demo-stf/src/tests/tx_revert_tests.rs
index c04e6fdcc..3c3d02b0b 100644
--- a/examples/demo-stf/src/tests/tx_revert_tests.rs
+++ b/examples/demo-stf/src/tests/tx_revert_tests.rs
@@ -67,11 +67,11 @@ fn test_tx_revert() {
         let mut working_set = WorkingSet::new(storage);
 
         // We sent 4 vote messages but one of them is invalid and should be reverted.
-        let resp = runtime.election.number_of_votes(&mut working_set);
+        let resp = runtime.election.number_of_votes(&mut working_set).unwrap();
 
         assert_eq!(resp, sov_election::GetNbOfVotesResponse::Result(3));
 
-        let resp = runtime.election.results(&mut working_set);
+        let resp = runtime.election.results(&mut working_set).unwrap();
 
         assert_eq!(
             resp,
@@ -83,7 +83,8 @@ fn test_tx_revert() {
 
         let resp = runtime
             .sequencer_registry
-            .sequencer_address(DEMO_SEQUENCER_DA_ADDRESS.to_vec(), &mut working_set);
+            .sequencer_address(DEMO_SEQUENCER_DA_ADDRESS.to_vec(), &mut working_set)
+            .unwrap();
         // Sequencer is not excluded from list of allowed!
         assert_eq!(Some(sequencer_rollup_address), resp.address);
     }
@@ -166,13 +167,14 @@ fn test_nonce_incremented_on_revert() {
         let mut working_set = WorkingSet::new(storage);
 
         // No votes actually recorded, because there was invalid vote
-        let resp = runtime.election.number_of_votes(&mut working_set);
+        let resp = runtime.election.number_of_votes(&mut working_set).unwrap();
 
         assert_eq!(resp, sov_election::GetNbOfVotesResponse::Result(0));
 
         let nonce = match runtime
             .accounts
             .get_account(voter.pub_key(), &mut working_set)
+            .unwrap()
         {
             Response::AccountExists { nonce, .. } => nonce,
             Response::AccountEmpty => 0,
@@ -230,7 +232,7 @@ fn test_tx_bad_sig() {
         let storage = ProverStorage::with_path(path).unwrap();
         let mut working_set = WorkingSet::new(storage);
 
-        let resp = runtime.election.results(&mut working_set);
+        let resp = runtime.election.results(&mut working_set).unwrap();
 
         assert_eq!(
             resp,
@@ -306,7 +308,7 @@ fn test_tx_bad_serialization() {
         let storage = ProverStorage::with_path(path).unwrap();
         let mut working_set = WorkingSet::new(storage);
 
-        let resp = runtime.election.results(&mut working_set);
+        let resp = runtime.election.results(&mut working_set).unwrap();
 
         assert_eq!(
             resp,
@@ -316,7 +318,8 @@ fn test_tx_bad_serialization() {
         // Sequencer is not in list of allowed sequencers
         let allowed_sequencer = runtime
             .sequencer_registry
-            .sequencer_address(SEQUENCER_DA_ADDRESS.to_vec(), &mut working_set);
+            .sequencer_address(SEQUENCER_DA_ADDRESS.to_vec(), &mut working_set)
+            .unwrap();
         assert!(allowed_sequencer.address.is_none());
 
         // Balance of sequencer is not increased
diff --git a/module-system/README.md b/module-system/README.md
index 0e3c90fb9..f897c855a 100644
--- a/module-system/README.md
+++ b/module-system/README.md
@@ -102,10 +102,10 @@ impl<C: sov_modules_api::Context> Bank<C> {
         user_address: C::Address,
         token_address: C::Address,
         working_set: &mut WorkingSet<C::Storage>,
-    ) -> BalanceResponse {
-        BalanceResponse {
+    ) -> RpcResult<BalanceResponse> {
+        Ok(BalanceResponse {
             amount: self.get_balance_of(user_address, token_address, working_set),
-        }
+        })
     }
 }
 ```
diff --git a/module-system/RPC_WALKTHROUGH.md b/module-system/RPC_WALKTHROUGH.md
index 384de4714..c53e5b907 100644
--- a/module-system/RPC_WALKTHROUGH.md
+++ b/module-system/RPC_WALKTHROUGH.md
@@ -31,7 +31,7 @@ impl<C: Context> Bank<C> {
         user_address: C::Address,
         token_address: C::Address,
         working_set: &mut WorkingSet<C::Storage>,
-    ) ->  BalanceResponse {
+    ) ->  RpcResult<BalanceResponse> {
     ...
     }
 
@@ -40,7 +40,7 @@ impl<C: Context> Bank<C> {
         &self,
         token_address: C::Address,
         working_set: &mut WorkingSet<C::Storage>,
-    ) -> TotalSupplyResponse {
+    ) -> RpcResult<TotalSupplyResponse> {
      ...
     }
 }
diff --git a/module-system/module-implementations/examples/sov-election/src/query.rs b/module-system/module-implementations/examples/sov-election/src/query.rs
index a5642984c..364acf6b0 100644
--- a/module-system/module-implementations/examples/sov-election/src/query.rs
+++ b/module-system/module-implementations/examples/sov-election/src/query.rs
@@ -1,3 +1,4 @@
+use jsonrpsee::core::RpcResult;
 use sov_modules_api::macros::rpc_gen;
 use sov_state::WorkingSet;
 
@@ -18,7 +19,10 @@ pub enum GetNbOfVotesResponse {
 #[rpc_gen(client, server, namespace = "election")]
 impl<C: sov_modules_api::Context> Election<C> {
     #[rpc_method(name = "results")]
-    pub fn results(&self, working_set: &mut WorkingSet<C::Storage>) -> GetResultResponse {
+    pub fn results(
+        &self,
+        working_set: &mut WorkingSet<C::Storage>,
+    ) -> RpcResult<GetResultResponse> {
         let is_frozen = self.is_frozen.get(working_set).unwrap_or_default();
 
         if is_frozen {
@@ -29,9 +33,9 @@ impl<C: sov_modules_api::Context> Election<C> {
                 .into_iter()
                 .max_by(|c1, c2| c1.count.cmp(&c2.count));
 
-            GetResultResponse::Result(candidate)
+            Ok(GetResultResponse::Result(candidate))
         } else {
-            GetResultResponse::Err("Election is not frozen".to_owned())
+            Ok(GetResultResponse::Err("Election is not frozen".to_owned()))
         }
     }
 
@@ -39,8 +43,8 @@ impl<C: sov_modules_api::Context> Election<C> {
     pub fn number_of_votes(
         &self,
         working_set: &mut WorkingSet<C::Storage>,
-    ) -> GetNbOfVotesResponse {
+    ) -> RpcResult<GetNbOfVotesResponse> {
         let number_of_votes = self.number_of_votes.get(working_set).unwrap_or_default();
-        GetNbOfVotesResponse::Result(number_of_votes)
+        Ok(GetNbOfVotesResponse::Result(number_of_votes))
     }
 }
diff --git a/module-system/module-implementations/examples/sov-election/src/tests.rs b/module-system/module-implementations/examples/sov-election/src/tests.rs
index 28d608f2a..36ea8af80 100644
--- a/module-system/module-implementations/examples/sov-election/src/tests.rs
+++ b/module-system/module-implementations/examples/sov-election/src/tests.rs
@@ -97,7 +97,7 @@ fn test_module<C: Context>(admin: C::Address, working_set: &mut WorkingSet<C::St
 
     // Get result
     {
-        let query_response: GetResultResponse = election.results(working_set);
+        let query_response: GetResultResponse = election.results(working_set).unwrap();
 
         assert_eq!(
             query_response,
diff --git a/module-system/module-implementations/examples/sov-value-setter/src/query.rs b/module-system/module-implementations/examples/sov-value-setter/src/query.rs
index 9d9679a1c..a7a7d7a07 100644
--- a/module-system/module-implementations/examples/sov-value-setter/src/query.rs
+++ b/module-system/module-implementations/examples/sov-value-setter/src/query.rs
@@ -1,3 +1,4 @@
+use jsonrpsee::core::RpcResult;
 use sov_modules_api::macros::rpc_gen;
 use sov_state::WorkingSet;
 
@@ -12,9 +13,9 @@ pub struct Response {
 impl<C: sov_modules_api::Context> ValueSetter<C> {
     /// Queries the state of the module.
     #[rpc_method(name = "queryValue")]
-    pub fn query_value(&self, working_set: &mut WorkingSet<C::Storage>) -> Response {
-        Response {
+    pub fn query_value(&self, working_set: &mut WorkingSet<C::Storage>) -> RpcResult<Response> {
+        Ok(Response {
             value: self.value.get(working_set),
-        }
+        })
     }
 }
diff --git a/module-system/module-implementations/examples/sov-value-setter/src/tests.rs b/module-system/module-implementations/examples/sov-value-setter/src/tests.rs
index ed4912788..6bb5ad002 100644
--- a/module-system/module-implementations/examples/sov-value-setter/src/tests.rs
+++ b/module-system/module-implementations/examples/sov-value-setter/src/tests.rs
@@ -53,7 +53,7 @@ fn test_value_setter_helper<C: Context>(
 
     // Test query
     {
-        let query_response = module.query_value(working_set);
+        let query_response = module.query_value(working_set).unwrap();
 
         assert_eq!(
             query::Response {
diff --git a/module-system/module-implementations/sov-accounts/src/query.rs b/module-system/module-implementations/sov-accounts/src/query.rs
index 0b7fe9afc..2073aabee 100644
--- a/module-system/module-implementations/sov-accounts/src/query.rs
+++ b/module-system/module-implementations/sov-accounts/src/query.rs
@@ -1,4 +1,5 @@
 #![allow(missing_docs)]
+use jsonrpsee::core::RpcResult;
 use sov_modules_api::macros::rpc_gen;
 use sov_modules_api::AddressBech32;
 use sov_state::WorkingSet;
@@ -26,13 +27,15 @@ impl<C: sov_modules_api::Context> Accounts<C> {
         &self,
         pub_key: C::PublicKey,
         working_set: &mut WorkingSet<C::Storage>,
-    ) -> Response {
-        match self.accounts.get(&pub_key, working_set) {
+    ) -> RpcResult<Response> {
+        let response = match self.accounts.get(&pub_key, working_set) {
             Some(Account { addr, nonce }) => Response::AccountExists {
                 addr: addr.into(),
                 nonce,
             },
             None => Response::AccountEmpty,
-        }
+        };
+
+        Ok(response)
     }
 }
diff --git a/module-system/module-implementations/sov-accounts/src/tests.rs b/module-system/module-implementations/sov-accounts/src/tests.rs
index a5f7f459d..01710e9bc 100644
--- a/module-system/module-implementations/sov-accounts/src/tests.rs
+++ b/module-system/module-implementations/sov-accounts/src/tests.rs
@@ -26,7 +26,9 @@ fn test_config_account() {
         .init_module(&account_config, native_working_set)
         .unwrap();
 
-    let query_response = accounts.get_account(init_pub_key, native_working_set);
+    let query_response = accounts
+        .get_account(init_pub_key, native_working_set)
+        .unwrap();
 
     assert_eq!(
         query_response,
@@ -55,7 +57,9 @@ fn test_update_account() {
             .create_default_account(sender.clone(), native_working_set)
             .unwrap();
 
-        let query_response = accounts.get_account(sender.clone(), native_working_set);
+        let query_response = accounts
+            .get_account(sender.clone(), native_working_set)
+            .unwrap();
 
         assert_eq!(
             query_response,
@@ -80,12 +84,14 @@ fn test_update_account() {
             .unwrap();
 
         // Account corresponding to the old public key does not exist
-        let query_response = accounts.get_account(sender, native_working_set);
+        let query_response = accounts.get_account(sender, native_working_set).unwrap();
 
         assert_eq!(query_response, query::Response::AccountEmpty);
 
         // New account with the new public key and an old address is created.
-        let query_response = accounts.get_account(new_pub_key, native_working_set);
+        let query_response = accounts
+            .get_account(new_pub_key, native_working_set)
+            .unwrap();
 
         assert_eq!(
             query_response,
diff --git a/module-system/module-implementations/sov-bank/src/query.rs b/module-system/module-implementations/sov-bank/src/query.rs
index f62bdb6a6..60c6ce64b 100644
--- a/module-system/module-implementations/sov-bank/src/query.rs
+++ b/module-system/module-implementations/sov-bank/src/query.rs
@@ -1,3 +1,4 @@
+use jsonrpsee::core::RpcResult;
 use sov_modules_api::macros::rpc_gen;
 use sov_state::WorkingSet;
 
@@ -21,10 +22,10 @@ impl<C: sov_modules_api::Context> Bank<C> {
         user_address: C::Address,
         token_address: C::Address,
         working_set: &mut WorkingSet<C::Storage>,
-    ) -> BalanceResponse {
-        BalanceResponse {
+    ) -> RpcResult<BalanceResponse> {
+        Ok(BalanceResponse {
             amount: self.get_balance_of(user_address, token_address, working_set),
-        }
+        })
     }
 
     #[rpc_method(name = "supplyOf")]
@@ -32,13 +33,13 @@ impl<C: sov_modules_api::Context> Bank<C> {
         &self,
         token_address: C::Address,
         working_set: &mut WorkingSet<C::Storage>,
-    ) -> TotalSupplyResponse {
-        TotalSupplyResponse {
+    ) -> RpcResult<TotalSupplyResponse> {
+        Ok(TotalSupplyResponse {
             amount: self
                 .tokens
                 .get(&token_address, working_set)
                 .map(|token| token.total_supply),
-        }
+        })
     }
 }
 
diff --git a/module-system/module-implementations/sov-bank/tests/burn_test.rs b/module-system/module-implementations/sov-bank/tests/burn_test.rs
index 4dc9497bc..9f13d9373 100644
--- a/module-system/module-implementations/sov-bank/tests/burn_test.rs
+++ b/module-system/module-implementations/sov-bank/tests/burn_test.rs
@@ -45,7 +45,8 @@ fn burn_deployed_tokens() {
     assert!(working_set.events().is_empty());
 
     let query_total_supply = |working_set: &mut WorkingSet<Storage>| -> Option<u64> {
-        let total_supply: TotalSupplyResponse = bank.supply_of(token_address.clone(), working_set);
+        let total_supply: TotalSupplyResponse =
+            bank.supply_of(token_address.clone(), working_set).unwrap();
         total_supply.amount
     };
 
diff --git a/module-system/module-implementations/sov-bank/tests/freeze_test.rs b/module-system/module-implementations/sov-bank/tests/freeze_test.rs
index 4a01f7042..404b29d19 100644
--- a/module-system/module-implementations/sov-bank/tests/freeze_test.rs
+++ b/module-system/module-implementations/sov-bank/tests/freeze_test.rs
@@ -131,11 +131,12 @@ fn freeze_token() {
         minter_address: new_holder.clone(),
     };
 
-    let query_total_supply =
-        |token_address: Address, working_set: &mut WorkingSet<Storage>| -> Option<u64> {
-            let total_supply: TotalSupplyResponse = bank.supply_of(token_address, working_set);
-            total_supply.amount
-        };
+    let query_total_supply = |token_address: Address,
+                              working_set: &mut WorkingSet<Storage>|
+     -> Option<u64> {
+        let total_supply: TotalSupplyResponse = bank.supply_of(token_address, working_set).unwrap();
+        total_supply.amount
+    };
 
     let minted = bank.call(mint_message, &minter_context, &mut working_set);
     assert!(minted.is_err());
diff --git a/module-system/module-implementations/sov-bank/tests/mint_test.rs b/module-system/module-implementations/sov-bank/tests/mint_test.rs
index f336f2f71..d50987a7c 100644
--- a/module-system/module-implementations/sov-bank/tests/mint_test.rs
+++ b/module-system/module-implementations/sov-bank/tests/mint_test.rs
@@ -38,11 +38,12 @@ fn mint_token() {
     // No events at the moment. If there are, needs to be checked
     assert!(working_set.events().is_empty());
 
-    let query_total_supply =
-        |token_address: Address, working_set: &mut WorkingSet<Storage>| -> Option<u64> {
-            let total_supply: TotalSupplyResponse = bank.supply_of(token_address, working_set);
-            total_supply.amount
-        };
+    let query_total_supply = |token_address: Address,
+                              working_set: &mut WorkingSet<Storage>|
+     -> Option<u64> {
+        let total_supply: TotalSupplyResponse = bank.supply_of(token_address, working_set).unwrap();
+        total_supply.amount
+    };
 
     let query_user_balance =
         |user_address: Address, working_set: &mut WorkingSet<Storage>| -> Option<u64> {
diff --git a/module-system/module-implementations/sov-bank/tests/transfer_test.rs b/module-system/module-implementations/sov-bank/tests/transfer_test.rs
index b187064a0..662a6af93 100644
--- a/module-system/module-implementations/sov-bank/tests/transfer_test.rs
+++ b/module-system/module-implementations/sov-bank/tests/transfer_test.rs
@@ -36,7 +36,8 @@ fn transfer_initial_token() {
         };
 
     let query_total_supply = |working_set: &mut WorkingSet<Storage>| -> Option<u64> {
-        let total_supply: TotalSupplyResponse = bank.supply_of(token_address.clone(), working_set);
+        let total_supply: TotalSupplyResponse =
+            bank.supply_of(token_address.clone(), working_set).unwrap();
         total_supply.amount
     };
 
@@ -278,7 +279,8 @@ fn transfer_deployed_token() {
         };
 
     let query_total_supply = |working_set: &mut WorkingSet<Storage>| -> Option<u64> {
-        let total_supply: TotalSupplyResponse = bank.supply_of(token_address.clone(), working_set);
+        let total_supply: TotalSupplyResponse =
+            bank.supply_of(token_address.clone(), working_set).unwrap();
         total_supply.amount
     };
 
diff --git a/module-system/module-implementations/sov-evm/src/query.rs b/module-system/module-implementations/sov-evm/src/query.rs
index 7f7a3be00..6f4aa2649 100644
--- a/module-system/module-implementations/sov-evm/src/query.rs
+++ b/module-system/module-implementations/sov-evm/src/query.rs
@@ -1,6 +1,7 @@
 use ethereum_types::{Address, H256, U256, U64};
 use ethers::types::Bytes;
 use ethers_core::types::{Block, BlockId, FeeHistory, Transaction, TransactionReceipt, TxHash};
+use jsonrpsee::core::RpcResult;
 use reth_rpc_types::state::StateOverride;
 use reth_rpc_types::{BlockOverrides, CallRequest, TransactionRequest};
 use revm::primitives::{CfgEnv, ExecutionResult, U256 as EVM_U256};
@@ -16,9 +17,9 @@ use crate::Evm;
 impl<C: sov_modules_api::Context> Evm<C> {
     // TODO https://github.com/Sovereign-Labs/sovereign-sdk/issues/502
     #[rpc_method(name = "chainId")]
-    pub fn chain_id(&self, _working_set: &mut WorkingSet<C::Storage>) -> Option<U64> {
+    pub fn chain_id(&self, _working_set: &mut WorkingSet<C::Storage>) -> RpcResult<Option<U64>> {
         info!("evm module: eth_chainId");
-        Some(U64::from(1u64))
+        Ok(Some(U64::from(1u64)))
     }
 
     // TODO https://github.com/Sovereign-Labs/sovereign-sdk/issues/502
@@ -28,7 +29,7 @@ impl<C: sov_modules_api::Context> Evm<C> {
         _block_number: Option<String>,
         _details: Option<bool>,
         _working_set: &mut WorkingSet<C::Storage>,
-    ) -> Option<Block<TxHash>> {
+    ) -> RpcResult<Option<Block<TxHash>>> {
         info!("evm module: eth_getBlockByNumber");
 
         let block = Block::<TxHash> {
@@ -36,19 +37,19 @@ impl<C: sov_modules_api::Context> Evm<C> {
             ..Default::default()
         };
 
-        Some(block)
+        Ok(Some(block))
     }
 
     // TODO https://github.com/Sovereign-Labs/sovereign-sdk/issues/502
     #[rpc_method(name = "feeHistory")]
-    pub fn fee_history(&self, _working_set: &mut WorkingSet<C::Storage>) -> FeeHistory {
+    pub fn fee_history(&self, _working_set: &mut WorkingSet<C::Storage>) -> RpcResult<FeeHistory> {
         info!("evm module: eth_feeHistory");
-        FeeHistory {
+        Ok(FeeHistory {
             base_fee_per_gas: Default::default(),
             gas_used_ratio: Default::default(),
             oldest_block: Default::default(),
             reward: Default::default(),
-        }
+        })
     }
 
     // TODO https://github.com/Sovereign-Labs/sovereign-sdk/issues/502
@@ -57,10 +58,10 @@ impl<C: sov_modules_api::Context> Evm<C> {
         &self,
         hash: H256,
         working_set: &mut WorkingSet<C::Storage>,
-    ) -> Option<Transaction> {
+    ) -> RpcResult<Option<Transaction>> {
         info!("evm module: eth_getTransactionByHash");
         let evm_transaction = self.transactions.get(&hash.into(), working_set);
-        evm_transaction.map(|tx| tx.into())
+        Ok(evm_transaction.map(|tx| tx.into()))
     }
 
     // TODO https://github.com/Sovereign-Labs/sovereign-sdk/issues/502
@@ -69,10 +70,10 @@ impl<C: sov_modules_api::Context> Evm<C> {
         &self,
         hash: H256,
         working_set: &mut WorkingSet<C::Storage>,
-    ) -> Option<TransactionReceipt> {
+    ) -> RpcResult<Option<TransactionReceipt>> {
         info!("evm module: eth_getTransactionReceipt");
         let receipt = self.receipts.get(&hash.into(), working_set);
-        receipt.map(|r| r.into())
+        Ok(receipt.map(|r| r.into()))
     }
 
     //https://github.com/paradigmxyz/reth/blob/f577e147807a783438a3f16aad968b4396274483/crates/rpc/rpc/src/eth/api/transactions.rs#L502
@@ -89,7 +90,7 @@ impl<C: sov_modules_api::Context> Evm<C> {
         _state_overrides: Option<StateOverride>,
         _block_overrides: Option<Box<BlockOverrides>>,
         working_set: &mut WorkingSet<C::Storage>,
-    ) -> Bytes {
+    ) -> RpcResult<Bytes> {
         info!("evm module: eth_call");
         let tx_env = prepare_call_env(request);
 
@@ -108,7 +109,7 @@ impl<C: sov_modules_api::Context> Evm<C> {
             ExecutionResult::Success { output, .. } => output,
             _ => todo!(),
         };
-        output.into_data().into()
+        Ok(output.into_data().into())
     }
 
     // TODO https://github.com/Sovereign-Labs/sovereign-sdk/issues/502
@@ -118,13 +119,13 @@ impl<C: sov_modules_api::Context> Evm<C> {
         // TODO https://github.com/Sovereign-Labs/sovereign-sdk/issues/501
         _request: TransactionRequest,
         _working_set: &mut WorkingSet<C::Storage>,
-    ) -> U256 {
+    ) -> RpcResult<U256> {
         unimplemented!("eth_sendTransaction not implemented")
     }
 
     // TODO https://github.com/Sovereign-Labs/sovereign-sdk/issues/502
     #[rpc_method(name = "blockNumber")]
-    pub fn block_number(&self, _working_set: &mut WorkingSet<C::Storage>) -> U256 {
+    pub fn block_number(&self, _working_set: &mut WorkingSet<C::Storage>) -> RpcResult<U256> {
         unimplemented!("eth_blockNumber not implemented")
     }
 
@@ -135,7 +136,7 @@ impl<C: sov_modules_api::Context> Evm<C> {
         _address: Address,
         _block_number: Option<BlockId>,
         _working_set: &mut WorkingSet<C::Storage>,
-    ) -> Option<U256> {
+    ) -> RpcResult<Option<U256>> {
         unimplemented!("eth_getTransactionCount not implemented")
     }
 }
diff --git a/module-system/module-implementations/sov-sequencer-registry/src/query.rs b/module-system/module-implementations/sov-sequencer-registry/src/query.rs
index eb538ef4f..f42b29d37 100644
--- a/module-system/module-implementations/sov-sequencer-registry/src/query.rs
+++ b/module-system/module-implementations/sov-sequencer-registry/src/query.rs
@@ -1,3 +1,4 @@
+use jsonrpsee::core::RpcResult;
 use sov_modules_api::macros::rpc_gen;
 use sov_modules_api::Context;
 use sov_state::WorkingSet;
@@ -19,9 +20,9 @@ impl<C: Context> SequencerRegistry<C> {
         &self,
         da_address: Vec<u8>,
         working_set: &mut WorkingSet<C::Storage>,
-    ) -> SequencerAddressResponse<C> {
-        SequencerAddressResponse {
+    ) -> RpcResult<SequencerAddressResponse<C>> {
+        Ok(SequencerAddressResponse {
             address: self.allowed_sequencers.get(&da_address, working_set),
-        }
+        })
     }
 }
diff --git a/module-system/module-implementations/sov-sequencer-registry/tests/helpers/mod.rs b/module-system/module-implementations/sov-sequencer-registry/tests/helpers/mod.rs
index a67694fba..36328e74a 100644
--- a/module-system/module-implementations/sov-sequencer-registry/tests/helpers/mod.rs
+++ b/module-system/module-implementations/sov-sequencer-registry/tests/helpers/mod.rs
@@ -1,3 +1,4 @@
+use jsonrpsee::core::RpcResult;
 use sov_modules_api::default_context::DefaultContext;
 use sov_modules_api::{Address, Hasher, Module, Spec};
 use sov_sequencer_registry::{SequencerConfig, SequencerRegistry};
@@ -38,7 +39,7 @@ impl TestSequencer {
     pub fn query_balance_via_bank(
         &mut self,
         working_set: &mut WorkingSet<<C as Spec>::Storage>,
-    ) -> sov_bank::BalanceResponse {
+    ) -> RpcResult<sov_bank::BalanceResponse> {
         self.bank.balance_of(
             self.sequencer_config.seq_rollup_address.clone(),
             self.sequencer_config.coins_to_lock.token_address.clone(),
@@ -51,7 +52,7 @@ impl TestSequencer {
         &mut self,
         user_address: <DefaultContext as Spec>::Address,
         working_set: &mut WorkingSet<<C as Spec>::Storage>,
-    ) -> sov_bank::BalanceResponse {
+    ) -> RpcResult<sov_bank::BalanceResponse> {
         self.bank.balance_of(
             user_address,
             self.sequencer_config.coins_to_lock.token_address.clone(),
diff --git a/module-system/module-implementations/sov-sequencer-registry/tests/hooks_test.rs b/module-system/module-implementations/sov-sequencer-registry/tests/hooks_test.rs
index 071679892..ec9dc469d 100644
--- a/module-system/module-implementations/sov-sequencer-registry/tests/hooks_test.rs
+++ b/module-system/module-implementations/sov-sequencer-registry/tests/hooks_test.rs
@@ -16,7 +16,7 @@ fn begin_blob_hook_known_sequencer() {
     test_sequencer.genesis(working_set);
 
     let balance_after_genesis = {
-        let resp = test_sequencer.query_balance_via_bank(working_set);
+        let resp = test_sequencer.query_balance_via_bank(working_set).unwrap();
         resp.amount.unwrap()
     };
     assert_eq!(INITIAL_BALANCE - LOCKED_AMOUNT, balance_after_genesis);
@@ -32,11 +32,12 @@ fn begin_blob_hook_known_sequencer() {
         .begin_blob_hook(&mut test_blob, working_set)
         .unwrap();
 
-    let resp = test_sequencer.query_balance_via_bank(working_set);
+    let resp = test_sequencer.query_balance_via_bank(working_set).unwrap();
     assert_eq!(balance_after_genesis, resp.amount.unwrap());
     let resp = test_sequencer
         .registry
-        .sequencer_address(GENESIS_SEQUENCER_DA_ADDRESS.to_vec(), working_set);
+        .sequencer_address(GENESIS_SEQUENCER_DA_ADDRESS.to_vec(), working_set)
+        .unwrap();
     assert!(resp.address.is_some());
 }
 
@@ -69,7 +70,7 @@ fn end_blob_hook_success() {
     let working_set = &mut WorkingSet::new(ProverStorage::with_path(tmpdir.path()).unwrap());
     test_sequencer.genesis(working_set);
     let balance_after_genesis = {
-        let resp = test_sequencer.query_balance_via_bank(working_set);
+        let resp = test_sequencer.query_balance_via_bank(working_set).unwrap();
         resp.amount.unwrap()
     };
     assert_eq!(INITIAL_BALANCE - LOCKED_AMOUNT, balance_after_genesis);
@@ -89,11 +90,12 @@ fn end_blob_hook_success() {
         .registry
         .end_blob_hook(SequencerOutcome::Completed, working_set)
         .unwrap();
-    let resp = test_sequencer.query_balance_via_bank(working_set);
+    let resp = test_sequencer.query_balance_via_bank(working_set).unwrap();
     assert_eq!(balance_after_genesis, resp.amount.unwrap());
     let resp = test_sequencer
         .registry
-        .sequencer_address(GENESIS_SEQUENCER_DA_ADDRESS.to_vec(), working_set);
+        .sequencer_address(GENESIS_SEQUENCER_DA_ADDRESS.to_vec(), working_set)
+        .unwrap();
     assert!(resp.address.is_some());
 }
 
@@ -104,7 +106,7 @@ fn end_blob_hook_slash() {
     let working_set = &mut WorkingSet::new(ProverStorage::with_path(tmpdir.path()).unwrap());
     test_sequencer.genesis(working_set);
     let balance_after_genesis = {
-        let resp = test_sequencer.query_balance_via_bank(working_set);
+        let resp = test_sequencer.query_balance_via_bank(working_set).unwrap();
         resp.amount.unwrap()
     };
     assert_eq!(INITIAL_BALANCE - LOCKED_AMOUNT, balance_after_genesis);
@@ -128,11 +130,12 @@ fn end_blob_hook_slash() {
         .end_blob_hook(result, working_set)
         .unwrap();
 
-    let resp = test_sequencer.query_balance_via_bank(working_set);
+    let resp = test_sequencer.query_balance_via_bank(working_set).unwrap();
     assert_eq!(balance_after_genesis, resp.amount.unwrap());
     let resp = test_sequencer
         .registry
-        .sequencer_address(GENESIS_SEQUENCER_DA_ADDRESS.to_vec(), working_set);
+        .sequencer_address(GENESIS_SEQUENCER_DA_ADDRESS.to_vec(), working_set)
+        .unwrap();
     assert!(resp.address.is_none());
 }
 
@@ -162,7 +165,7 @@ fn end_blob_hook_slash_preferred_sequencer() {
     let working_set = &mut WorkingSet::new(ProverStorage::with_path(tmpdir.path()).unwrap());
     test_sequencer.genesis(working_set);
     let balance_after_genesis = {
-        let resp = test_sequencer.query_balance_via_bank(working_set);
+        let resp = test_sequencer.query_balance_via_bank(working_set).unwrap();
         resp.amount.unwrap()
     };
     assert_eq!(INITIAL_BALANCE - LOCKED_AMOUNT, balance_after_genesis);
@@ -186,11 +189,12 @@ fn end_blob_hook_slash_preferred_sequencer() {
         .end_blob_hook(result, working_set)
         .unwrap();
 
-    let resp = test_sequencer.query_balance_via_bank(working_set);
+    let resp = test_sequencer.query_balance_via_bank(working_set).unwrap();
     assert_eq!(balance_after_genesis, resp.amount.unwrap());
     let resp = test_sequencer
         .registry
-        .sequencer_address(GENESIS_SEQUENCER_DA_ADDRESS.to_vec(), working_set);
+        .sequencer_address(GENESIS_SEQUENCER_DA_ADDRESS.to_vec(), working_set)
+        .unwrap();
     assert!(resp.address.is_none());
 
     assert!(test_sequencer
@@ -219,7 +223,8 @@ fn end_blob_hook_slash_unknown_sequencer() {
 
     let resp = test_sequencer
         .registry
-        .sequencer_address(UNKNOWN_SEQUENCER_DA_ADDRESS.to_vec(), working_set);
+        .sequencer_address(UNKNOWN_SEQUENCER_DA_ADDRESS.to_vec(), working_set)
+        .unwrap();
     assert!(resp.address.is_none());
 
     let result = SequencerOutcome::Slashed {
@@ -232,6 +237,7 @@ fn end_blob_hook_slash_unknown_sequencer() {
 
     let resp = test_sequencer
         .registry
-        .sequencer_address(UNKNOWN_SEQUENCER_DA_ADDRESS.to_vec(), working_set);
+        .sequencer_address(UNKNOWN_SEQUENCER_DA_ADDRESS.to_vec(), working_set)
+        .unwrap();
     assert!(resp.address.is_none());
 }
diff --git a/module-system/module-implementations/sov-sequencer-registry/tests/sequencer_registry_test.rs b/module-system/module-implementations/sov-sequencer-registry/tests/sequencer_registry_test.rs
index aba2acf93..15662d088 100644
--- a/module-system/module-implementations/sov-sequencer-registry/tests/sequencer_registry_test.rs
+++ b/module-system/module-implementations/sov-sequencer-registry/tests/sequencer_registry_test.rs
@@ -24,7 +24,8 @@ fn test_registration_lifecycle() {
         let sequencer_address = generate_address(GENESIS_SEQUENCER_KEY);
         let registry_response = test_sequencer
             .registry
-            .sequencer_address(GENESIS_SEQUENCER_DA_ADDRESS.to_vec(), working_set);
+            .sequencer_address(GENESIS_SEQUENCER_DA_ADDRESS.to_vec(), working_set)
+            .unwrap();
         assert_eq!(Some(sequencer_address), registry_response.address);
     }
 
@@ -37,12 +38,14 @@ fn test_registration_lifecycle() {
 
     let balance_before = test_sequencer
         .query_balance(sequencer_address.clone(), working_set)
+        .unwrap()
         .amount
         .unwrap();
 
     let registry_response_before = test_sequencer
         .registry
-        .sequencer_address(da_address.clone(), working_set);
+        .sequencer_address(da_address.clone(), working_set)
+        .unwrap();
     assert!(registry_response_before.address.is_none());
 
     let register_message = CallMessage::Register {
@@ -55,13 +58,15 @@ fn test_registration_lifecycle() {
 
     let balance_after_registration = test_sequencer
         .query_balance(sequencer_address.clone(), working_set)
+        .unwrap()
         .amount
         .unwrap();
     assert_eq!(balance_before - LOCKED_AMOUNT, balance_after_registration);
 
     let registry_response_after_registration = test_sequencer
         .registry
-        .sequencer_address(da_address.clone(), working_set);
+        .sequencer_address(da_address.clone(), working_set)
+        .unwrap();
     assert_eq!(
         Some(sequencer_address.clone()),
         registry_response_after_registration.address
@@ -77,13 +82,15 @@ fn test_registration_lifecycle() {
 
     let balance_after_exit = test_sequencer
         .query_balance(sequencer_address, working_set)
+        .unwrap()
         .amount
         .unwrap();
     assert_eq!(balance_before, balance_after_exit);
 
     let registry_response_after_exit = test_sequencer
         .registry
-        .sequencer_address(da_address, working_set);
+        .sequencer_address(da_address, working_set)
+        .unwrap();
     assert!(registry_response_after_exit.address.is_none());
 }
 
diff --git a/module-system/sov-modules-macros/src/lib.rs b/module-system/sov-modules-macros/src/lib.rs
index 21da369a8..69b5cce8a 100644
--- a/module-system/sov-modules-macros/src/lib.rs
+++ b/module-system/sov-modules-macros/src/lib.rs
@@ -152,6 +152,7 @@ pub fn codec(input: TokenStream) -> TokenStream {
 /// ```
 /// use sov_modules_api::{Context, ModuleInfo};
 /// use sov_modules_api::macros::rpc_gen;
+/// use jsonrpsee::core::RpcResult;
 ///
 /// #[derive(ModuleInfo)]
 /// struct MyModule<C: Context> {
@@ -163,8 +164,8 @@ pub fn codec(input: TokenStream) -> TokenStream {
 /// #[rpc_gen(client, server, namespace = "myNamespace")]
 /// impl<C: Context> MyModule<C> {
 ///     #[rpc_method(name = "myMethod")]
-///     fn my_method(&self, param: u32) -> u32 {
-///         1
+///     fn my_method(&self, param: u32) -> RpcResult<u32> {
+///         Ok(1)
 ///     }
 /// }
 /// ```
@@ -175,6 +176,7 @@ pub fn codec(input: TokenStream) -> TokenStream {
 /// use sov_modules_api::{Context, ModuleInfo};
 /// use sov_modules_api::macros::rpc_gen;
 /// use sov_state::WorkingSet;
+/// use jsonrpsee::core::RpcResult;
 ///
 /// #[derive(ModuleInfo)]
 /// struct MyModule<C: Context> {
@@ -184,18 +186,18 @@ pub fn codec(input: TokenStream) -> TokenStream {
 /// };
 ///
 /// impl<C: Context> MyModule<C> {
-///     fn my_method(&self, working_set: &mut WorkingSet<C::Storage>, param: u32) -> u32 {
-///         1
+///     fn my_method(&self, working_set: &mut WorkingSet<C::Storage>, param: u32) -> RpcResult<u32> {
+///         Ok(1)
 ///     }  
 /// }
 ///
 /// #[jsonrpsee::proc_macros::rpc(client, server, namespace ="myNamespace")]
 /// pub trait MyModuleRpc {
 ///     #[method(name = "myMethod")]
-///     fn my_method(&self, param: u32) -> Result<u32, jsonrpsee::core::Error>;
+///     fn my_method(&self, param: u32) ->RpcResult<u32>;
 ///
 ///     #[method(name = "health")]
-///     fn health(&self) -> Result<(), jsonrpsee::core::Error> {
+///     fn health(&self) -> RpcResult<()> {
 ///         Ok(())
 ///     }
 /// }
diff --git a/module-system/sov-modules-macros/src/rpc/rpc_gen.rs b/module-system/sov-modules-macros/src/rpc/rpc_gen.rs
index a3e1a10b8..fd1e027de 100644
--- a/module-system/sov-modules-macros/src/rpc/rpc_gen.rs
+++ b/module-system/sov-modules-macros/src/rpc/rpc_gen.rs
@@ -142,20 +142,19 @@ impl RpcImplBlock {
 
             impl_trait_methods.push(impl_trait_method);
 
-            signature.output = wrap_in_jsonprsee_result(&signature.output);
             let blanket_impl_method = if let Some(idx) = method.idx_of_working_set_arg {
                 // If necessary, adjust the signature to remove the working set argument.
                 let pre_working_set_args = arg_values.clone().take(idx);
                 let post_working_set_args = arg_values.clone().skip(idx + 1);
                 quote! {
                     #signature {
-                        Ok(<Self as #impl_trait_name #ty_generics >::#method_name(#(#pre_working_set_args,)* #(#post_working_set_args),* ))
+                        <Self as #impl_trait_name #ty_generics >::#method_name(#(#pre_working_set_args,)* #(#post_working_set_args),* )
                     }
                 }
             } else {
                 quote! {
                     #signature {
-                        Ok(<Self as #impl_trait_name #ty_generics >::#method_name(#(#arg_values),*))
+                        <Self as #impl_trait_name #ty_generics >::#method_name(#(#arg_values),*)
                     }
                 }
             };
@@ -203,19 +202,6 @@ impl RpcImplBlock {
     }
 }
 
-fn wrap_in_jsonprsee_result(return_type: &syn::ReturnType) -> syn::ReturnType {
-    let result_type: Type = match return_type {
-        syn::ReturnType::Default => syn::parse_quote! { ::jsonrpsee::core::RpcResult<()> },
-        syn::ReturnType::Type(_, ty) => syn::parse_quote! { ::jsonrpsee::core::RpcResult<#ty> },
-    };
-    syn::ReturnType::Type(
-        syn::token::RArrow {
-            spans: [proc_macro2::Span::call_site(); 2],
-        },
-        Box::new(result_type),
-    )
-}
-
 fn add_server_bounds_attr_if_missing(attrs: &mut Vec<syn::NestedMeta>) {
     for attr in attrs.iter() {
         if let syn::NestedMeta::Meta(syn::Meta::List(syn::MetaList { path, .. })) = attr {
@@ -293,9 +279,6 @@ fn build_rpc_trait(
                 let mut intermediate_signature = method.sig.clone();
                 intermediate_signature.inputs = intermediate_trait_inputs;
 
-                intermediate_signature.output =
-                    wrap_in_jsonprsee_result(&intermediate_signature.output);
-
                 // Build the annotated signature for the intermediate trait
                 let annotated_signature = quote! {
                     #attr
diff --git a/module-system/sov-modules-macros/tests/derive_rpc.rs b/module-system/sov-modules-macros/tests/derive_rpc.rs
index 274e0ffa0..760dcdfe8 100644
--- a/module-system/sov-modules-macros/tests/derive_rpc.rs
+++ b/module-system/sov-modules-macros/tests/derive_rpc.rs
@@ -1,3 +1,4 @@
+use jsonrpsee::core::RpcResult;
 use sov_modules_api::default_context::ZkDefaultContext;
 use sov_modules_api::macros::rpc_gen;
 use sov_modules_api::{Context, ModuleInfo};
@@ -12,23 +13,31 @@ pub struct TestStruct<C: ::sov_modules_api::Context> {
 #[rpc_gen(client, server, namespace = "test")]
 impl<C: sov_modules_api::Context> TestStruct<C> {
     #[rpc_method(name = "firstMethod")]
-    pub fn first_method(&self, _working_set: &mut WorkingSet<C::Storage>) -> u32 {
-        11
+    pub fn first_method(&self, _working_set: &mut WorkingSet<C::Storage>) -> RpcResult<u32> {
+        Ok(11)
     }
 
     #[rpc_method(name = "secondMethod")]
-    pub fn second_method(&self, result: u32, _working_set: &mut WorkingSet<C::Storage>) -> u32 {
-        result
+    pub fn second_method(
+        &self,
+        result: u32,
+        _working_set: &mut WorkingSet<C::Storage>,
+    ) -> RpcResult<u32> {
+        Ok(result)
     }
 
     #[rpc_method(name = "thirdMethod")]
-    pub fn third_method(&self, result: u32) -> u32 {
-        result
+    pub fn third_method(&self, result: u32) -> RpcResult<u32> {
+        Ok(result)
     }
 
     #[rpc_method(name = "fourthMethod")]
-    pub fn fourth_method(&self, _working_set: &mut WorkingSet<C::Storage>, result: u32) -> u32 {
-        result
+    pub fn fourth_method(
+        &self,
+        _working_set: &mut WorkingSet<C::Storage>,
+        result: u32,
+    ) -> RpcResult<u32> {
+        Ok(result)
     }
 }
 
@@ -59,38 +68,43 @@ fn main() {
         let result =
             <RpcStorage<ZkDefaultContext> as TestStructRpcServer<ZkDefaultContext>>::first_method(
                 &r,
-            );
-        assert_eq!(result.unwrap(), 11);
+            )
+            .unwrap();
+        assert_eq!(result, 11);
     }
 
     {
         let result =
             <RpcStorage<ZkDefaultContext> as TestStructRpcServer<ZkDefaultContext>>::second_method(
                 &r, 22,
-            );
-        assert_eq!(result.unwrap(), 22);
+            )
+            .unwrap();
+        assert_eq!(result, 22);
     }
 
     {
         let result =
             <RpcStorage<ZkDefaultContext> as TestStructRpcServer<ZkDefaultContext>>::third_method(
                 &r, 33,
-            );
-        assert_eq!(result.unwrap(), 33);
+            )
+            .unwrap();
+        assert_eq!(result, 33);
     }
 
     {
         let result =
             <RpcStorage<ZkDefaultContext> as TestStructRpcServer<ZkDefaultContext>>::fourth_method(
                 &r, 44,
-            );
-        assert_eq!(result.unwrap(), 44);
+            )
+            .unwrap();
+        assert_eq!(result, 44);
     }
 
     {
         let result =
-            <RpcStorage<ZkDefaultContext> as TestStructRpcServer<ZkDefaultContext>>::health(&r);
-        assert_eq!(result.unwrap(), ());
+            <RpcStorage<ZkDefaultContext> as TestStructRpcServer<ZkDefaultContext>>::health(&r)
+                .unwrap();
+        assert_eq!(result, ());
     }
 
     println!("All tests passed!")