Merge branch 'main' into Pravdyvy/fixed-error-propagation

Cargo.lock

@@ -3839,8 +3839,10 @@ dependencies = [
  "anyhow",
  "env_logger",
  "log",
+ "sequencer_core",
  "serde",
  "serde_json",
+ "storage",
 ]
 
 [[package]]

accounts/src/account_core/mod.rs

@@ -110,7 +110,7 @@ impl Account {
             privacy_flag,
         };
 
-        let asset_utxo = UTXO::create_utxo_from_payload(payload_with_asset);
+        let asset_utxo = UTXO::create_utxo_from_payload(payload_with_asset)?;
 
         self.utxo_tree.insert_item(asset_utxo)?;
 
@@ -138,7 +138,7 @@ mod tests {
         UTXONullifier::default()
     }
 
-    fn generate_dummy_utxo(address: TreeHashType, amount: u128) -> UTXO {
+    fn generate_dummy_utxo(address: TreeHashType, amount: u128) -> anyhow::Result<UTXO> {
         let payload = UTXOPayload {
             owner: address,
             asset: vec![],
@@ -159,7 +159,7 @@ mod tests {
     #[test]
     fn test_mark_spent_utxo() {
         let mut account = Account::new();
-        let utxo = generate_dummy_utxo(account.address, 100);
+        let utxo = generate_dummy_utxo(account.address, 100).unwrap();
         account.add_new_utxo_outputs(vec![utxo]).unwrap();
 
         let mut utxo_nullifier_map = HashMap::new();
@@ -174,8 +174,8 @@ mod tests {
     #[test]
     fn test_add_new_utxo_outputs() {
         let mut account = Account::new();
-        let utxo1 = generate_dummy_utxo(account.address, 100);
+        let utxo1 = generate_dummy_utxo(account.address, 100).unwrap();
-        let utxo2 = generate_dummy_utxo(account.address, 200);
+        let utxo2 = generate_dummy_utxo(account.address, 200).unwrap();
 
         let result = account.add_new_utxo_outputs(vec![utxo1.clone(), utxo2.clone()]);
 

node_core/src/lib.rs

@@ -8,7 +8,7 @@ use k256::elliptic_curve::group::GroupEncoding;
 
 use ::storage::transaction::{Transaction, TransactionPayload, TxKind};
 use accounts::account_core::{Account, AccountAddress};
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 use config::NodeConfig;
 use executions::{
     private_exec::{generate_commitments, generate_nullifiers},
@@ -476,7 +476,8 @@ impl NodeCore {
                     .to_bytes()
                     .to_vec(),
             )
-            .unwrap(),
+            .map_err(|err| anyhow!("{:?}", err))
+            .map_err(ExecutionFailureKind::write_error)?,
             generator_blinding_factor: Tweak::new(&mut thread_rng()),
         };
 
@@ -782,11 +783,7 @@ impl NodeCore {
 
             let acc = write_guard.acc_map.get_mut(&acc_addr).unwrap();
 
-            acc.utxo_tree
+            acc.utxo_tree.get_item(new_utxo_hash)?.unwrap().clone()
-                .get_item(new_utxo_hash)
-                .unwrap()
-                .unwrap()
-                .clone()
         };
 
         new_utxo.log();
@@ -963,11 +960,7 @@ impl NodeCore {
             let acc = write_guard.acc_map.get_mut(&acc_addr_rec).unwrap();
             acc.log();
 
-            acc.utxo_tree
+            acc.utxo_tree.get_item(new_utxo_hash)?.unwrap().clone()
-                .get_item(new_utxo_hash)
-                .unwrap()
-                .unwrap()
-                .clone()
         };
         new_utxo.log();
         info!(
@@ -1007,11 +1000,7 @@ impl NodeCore {
             let acc = write_guard.acc_map.get_mut(&acc_addr_rec).unwrap();
             acc.log();
 
-            acc.utxo_tree
+            acc.utxo_tree.get_item(new_utxo_hash)?.unwrap().clone()
-                .get_item(new_utxo_hash)
-                .unwrap()
-                .unwrap()
-                .clone()
         };
         new_utxo.log();
         info!(
@@ -1056,12 +1045,7 @@ impl NodeCore {
                 let acc = write_guard.acc_map.get_mut(&acc_addr_rec).unwrap();
                 acc.log();
 
-                let new_utxo = acc
+                let new_utxo = acc.utxo_tree.get_item(new_utxo_hash)?.unwrap().clone();
-                    .utxo_tree
-                    .get_item(new_utxo_hash)
-                    .unwrap()
-                    .unwrap()
-                    .clone();
 
                 new_utxo.log();
                 info!(
@@ -1081,12 +1065,7 @@ impl NodeCore {
                 let acc = write_guard.acc_map.get_mut(&acc_addr).unwrap();
                 acc.log();
 
-                let new_utxo = acc
+                let new_utxo = acc.utxo_tree.get_item(new_utxo_hash)?.unwrap().clone();
-                    .utxo_tree
-                    .get_item(new_utxo_hash)
-                    .unwrap()
-                    .unwrap()
-                    .clone();
 
                 new_utxo.log();
                 info!(

node_core/src/sequencer_client/json.rs

@@ -1,15 +1,8 @@
 use serde::{Deserialize, Serialize};
-use storage::{block::Block, transaction::Transaction};
+use storage::transaction::Transaction;
 
 //Requests
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct RegisterAccountRequest {
-    pub nullifier_public_key: Vec<u8>,
-    pub viewing_public_key: Vec<u8>,
-    pub address: [u8; 32],
-}
-
 #[derive(Serialize, Deserialize, Debug)]
 pub struct SendTxRequest {
     pub transaction: Transaction,
@@ -17,37 +10,14 @@ pub struct SendTxRequest {
     pub tx_roots: [[u8; 32]; 3],
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct GetBlockDataRequest {
-    pub block_id: u64,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct GetGenesisIdRequest {}
-
 //Responses
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct RegisterAccountResponse {
-    pub status: String,
-}
-
 #[derive(Serialize, Deserialize, Debug)]
 pub struct SendTxResponse {
     pub status: String,
     pub additional_data: Option<String>,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct GetBlockDataResponse {
-    pub block: Block,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct GetGenesisIdResponse {
-    pub genesis_id: u64,
-}
-
 //General
 
 #[derive(Debug, Clone, Serialize)]

node_core/src/sequencer_client/mod.rs

@@ -8,6 +8,10 @@ use json::{
 };
 use k256::elliptic_curve::group::GroupEncoding;
 use reqwest::Client;
+use rpc_primitives::requests::{
+    GetBlockDataRequest, GetBlockDataResponse, GetGenesisIdRequest, GetGenesisIdResponse,
+    RegisterAccountRequest, RegisterAccountResponse,
+};
 use serde_json::Value;
 use storage::transaction::Transaction;
 

node_rpc/src/process.rs

@@ -11,23 +11,23 @@ use rpc_primitives::{
 };
 use storage::transaction::ActionData;
 
-use crate::types::{
+use rpc_primitives::requests::{
-    err_rpc::cast_common_execution_error_into_rpc_error,
+    GetBlockDataRequest, GetBlockDataResponse, GetLastBlockRequest, GetLastBlockResponse,
-    rpc_structs::{
+    RegisterAccountRequest, RegisterAccountResponse,
-        ExecuteScenarioMultipleSendRequest, ExecuteScenarioMultipleSendResponse,
+};
-        ExecuteScenarioSplitRequest, ExecuteScenarioSplitResponse, ExecuteSubscenarioRequest,
+
-        ExecuteSubscenarioResponse, GetBlockDataRequest, GetBlockDataResponse, GetLastBlockRequest,
+use crate::types::rpc_structs::{
-        GetLastBlockResponse, RegisterAccountRequest, RegisterAccountResponse,
+    ExecuteScenarioMultipleSendRequest, ExecuteScenarioMultipleSendResponse,
-        ShowAccountPublicBalanceRequest, ShowAccountPublicBalanceResponse, ShowAccountUTXORequest,
+    ExecuteScenarioSplitRequest, ExecuteScenarioSplitResponse, ExecuteSubscenarioRequest,
-        ShowAccountUTXOResponse, ShowTransactionRequest, ShowTransactionResponse,
+    ExecuteSubscenarioResponse, ShowAccountPublicBalanceRequest, ShowAccountPublicBalanceResponse,
-        UTXOShortEssentialStruct, WriteDepositPublicBalanceRequest,
+    ShowAccountUTXORequest, ShowAccountUTXOResponse, ShowTransactionRequest,
-        WriteDepositPublicBalanceResponse, WriteMintPrivateUTXOMultipleAssetsRequest,
+    ShowTransactionResponse, UTXOShortEssentialStruct, WriteDepositPublicBalanceRequest,
-        WriteMintPrivateUTXOMultipleAssetsResponse, WriteMintPrivateUTXORequest,
+    WriteDepositPublicBalanceResponse, WriteMintPrivateUTXOMultipleAssetsRequest,
-        WriteMintPrivateUTXOResponse, WriteSendDeshieldedBalanceRequest,
+    WriteMintPrivateUTXOMultipleAssetsResponse, WriteMintPrivateUTXORequest,
-        WriteSendDeshieldedUTXOResponse, WriteSendPrivateUTXORequest, WriteSendPrivateUTXOResponse,
+    WriteMintPrivateUTXOResponse, WriteSendDeshieldedBalanceRequest,
-        WriteSendShieldedUTXORequest, WriteSendShieldedUTXOResponse, WriteSendSplitUTXOResponse,
+    WriteSendDeshieldedUTXOResponse, WriteSendPrivateUTXORequest, WriteSendPrivateUTXOResponse,
-        WriteSplitUTXORequest,
+    WriteSendShieldedUTXORequest, WriteSendShieldedUTXOResponse, WriteSendSplitUTXOResponse,
-    },
+    WriteSplitUTXORequest,
 };
 
 use super::{respond, types::err_rpc::RpcErr, JsonHandler};

node_rpc/src/types/mod.rs

@@ -1,3 +1,2 @@
 pub mod err_rpc;
-pub mod parse;
 pub mod rpc_structs;

node_rpc/src/types/parse.rs

@@ -1 +0,0 @@
-

node_rpc/src/types/rpc_structs.rs

@@ -4,23 +4,8 @@ use rpc_primitives::parser::parse_params;
 use rpc_primitives::parser::RpcRequest;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use storage::block::Block;
-use storage::transaction::Transaction;
 use storage::transaction::TxKind;
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct RegisterAccountRequest {}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct SendTxRequest {
-    pub transaction: Transaction,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct GetBlockDataRequest {
-    pub block_id: u64,
-}
-
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ExecuteSubscenarioRequest {
     pub scenario_id: u64,
@@ -38,12 +23,6 @@ pub struct ExecuteScenarioMultipleSendRequest {
     pub number_to_send: usize,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct GetGenesisIdRequest {}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct GetLastBlockRequest {}
-
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ShowAccountPublicBalanceRequest {
     pub account_addr: String,
@@ -111,14 +90,11 @@ pub struct WriteSplitUTXORequest {
     pub utxo_commitment: String,
 }
 
-parse_request!(RegisterAccountRequest);
+// parse_request!(GetGenesisIdRequest);
-parse_request!(SendTxRequest);
-parse_request!(GetBlockDataRequest);
-parse_request!(GetGenesisIdRequest);
 parse_request!(ExecuteSubscenarioRequest);
 parse_request!(ExecuteScenarioSplitRequest);
 parse_request!(ExecuteScenarioMultipleSendRequest);
-parse_request!(GetLastBlockRequest);
+// parse_request!(GetLastBlockRequest);
 
 parse_request!(ShowAccountPublicBalanceRequest);
 parse_request!(ShowAccountUTXORequest);
@@ -132,26 +108,6 @@ parse_request!(WriteSendShieldedUTXORequest);
 parse_request!(WriteSendDeshieldedBalanceRequest);
 parse_request!(WriteSplitUTXORequest);
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct HelloResponse {
-    pub greeting: String,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct RegisterAccountResponse {
-    pub status: String,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct SendTxResponse {
-    pub status: String,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct GetBlockDataResponse {
-    pub block: Block,
-}
-
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ExecuteSubscenarioResponse {
     pub scenario_result: String,
@@ -167,16 +123,6 @@ pub struct ExecuteScenarioMultipleSendResponse {
     pub scenario_result: String,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct GetGenesisIdResponse {
-    pub genesis_id: u64,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct GetLastBlockResponse {
-    pub last_block: u64,
-}
-
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ShowAccountPublicBalanceResponse {
     pub addr: String,

rpc_primitives/Cargo.toml

@@ -9,3 +9,9 @@ serde_json.workspace = true
 env_logger.workspace = true
 log.workspace = true
 serde.workspace = true
+
+[dependencies.storage]
+path = "../storage"
+
+[dependencies.sequencer_core]
+path = "../sequencer_core"

rpc_primitives/src/lib.rs

@@ -5,6 +5,7 @@ use serde::{Deserialize, Serialize};
 pub mod errors;
 pub mod message;
 pub mod parser;
+pub mod requests;
 
 #[derive(Serialize, Deserialize, Clone, Copy, Debug)]
 pub struct RpcPollingConfig {

rpc_primitives/src/requests.rs

@@ -1,7 +1,7 @@
-use rpc_primitives::errors::RpcParseError;
+use crate::errors::RpcParseError;
-use rpc_primitives::parse_request;
+use crate::parse_request;
-use rpc_primitives::parser::parse_params;
+use crate::parser::parse_params;
-use rpc_primitives::parser::RpcRequest;
+use crate::parser::RpcRequest;
 use sequencer_core::transaction_mempool::TransactionMempool;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;

sequencer_rpc/src/process.rs

@@ -8,7 +8,7 @@ use rpc_primitives::{
     parser::RpcRequest,
 };
 
-use crate::types::rpc_structs::{
+use rpc_primitives::requests::{
     GetBlockDataRequest, GetBlockDataResponse, GetGenesisIdRequest, GetGenesisIdResponse,
     GetLastBlockRequest, GetLastBlockResponse, HelloRequest, HelloResponse, RegisterAccountRequest,
     RegisterAccountResponse, SendTxRequest, SendTxResponse,

sequencer_rpc/src/types/mod.rs

@@ -1,3 +1,2 @@
 pub mod err_rpc;
 pub mod parse;
-pub mod rpc_structs;

utxo/src/utxo_core.rs

@@ -29,8 +29,8 @@ pub struct UTXOPayload {
 }
 
 impl UTXO {
-    pub fn create_utxo_from_payload(payload_with_asset: UTXOPayload) -> Self {
+    pub fn create_utxo_from_payload(payload_with_asset: UTXOPayload) -> anyhow::Result<Self> {
-        let raw_payload = serde_json::to_vec(&payload_with_asset).unwrap();
+        let raw_payload = serde_json::to_vec(&payload_with_asset)?;
 
         let mut hasher = sha2::Sha256::new();
 
@@ -38,14 +38,14 @@ impl UTXO {
 
         let hash = <TreeHashType>::from(hasher.finalize_fixed());
 
-        Self {
+        Ok(Self {
             hash,
             owner: payload_with_asset.owner,
             nullifier: None,
             asset: payload_with_asset.asset,
             amount: payload_with_asset.amount,
             privacy_flag: payload_with_asset.privacy_flag,
-        }
+        })
     }
 
     pub fn consume_utxo(&mut self, nullifier: UTXONullifier) -> Result<()> {
@@ -123,7 +123,7 @@ mod tests {
     #[test]
     fn test_create_utxo_from_payload() {
         let payload = sample_payload();
-        let utxo = UTXO::create_utxo_from_payload(payload.clone());
+        let utxo = UTXO::create_utxo_from_payload(payload.clone()).unwrap();
 
         // Ensure hash is created and the UTXO fields are correctly assigned
         assert_eq!(utxo.owner, payload.owner);
@@ -134,7 +134,7 @@ mod tests {
     #[test]
     fn test_consume_utxo() {
         let payload = sample_payload();
-        let mut utxo = UTXO::create_utxo_from_payload(payload);
+        let mut utxo = UTXO::create_utxo_from_payload(payload).unwrap();
 
         let nullifier = sample_nullifier();
 
@@ -150,7 +150,7 @@ mod tests {
     #[test]
     fn test_interpret_asset() {
         let payload = sample_payload();
-        let utxo = UTXO::create_utxo_from_payload(payload);
+        let utxo = UTXO::create_utxo_from_payload(payload).unwrap();
 
         // Interpret asset as TestAsset
         let interpreted: TestAsset = utxo.interpret_asset().unwrap();
@@ -168,7 +168,7 @@ mod tests {
     fn test_interpret_invalid_asset() {
         let mut payload = sample_payload();
         payload.asset = vec![0, 1, 2, 3]; // Invalid data for deserialization
-        let utxo = UTXO::create_utxo_from_payload(payload);
+        let utxo = UTXO::create_utxo_from_payload(payload).unwrap();
 
         // This should fail because the asset is not valid JSON for TestAsset
         let result: Result<TestAsset> = utxo.interpret_asset();

utxo/src/utxo_tree.rs

@@ -88,7 +88,7 @@ mod tests {
         }
     }
 
-    fn sample_utxo() -> UTXO {
+    fn sample_utxo() -> anyhow::Result<UTXO> {
         UTXO::create_utxo_from_payload(sample_utxo_payload())
     }
 
@@ -102,7 +102,7 @@ mod tests {
     #[test]
     fn test_insert_item() {
         let mut smt = UTXOSparseMerkleTree::new();
-        let utxo = sample_utxo();
+        let utxo = sample_utxo().unwrap();
 
         let result = smt.insert_item(utxo.clone());
 
@@ -119,8 +119,8 @@ mod tests {
     #[test]
     fn test_insert_items() {
         let mut smt = UTXOSparseMerkleTree::new();
-        let utxo1 = sample_utxo();
+        let utxo1 = sample_utxo().unwrap();
-        let utxo2 = sample_utxo();
+        let utxo2 = sample_utxo().unwrap();
 
         let result = smt.insert_items(vec![utxo1.clone(), utxo2.clone()]);
 
@@ -138,7 +138,7 @@ mod tests {
     #[test]
     fn test_get_item_exists() {
         let mut smt = UTXOSparseMerkleTree::new();
-        let utxo = sample_utxo();
+        let utxo = sample_utxo().unwrap();
 
         smt.insert_item(utxo.clone()).unwrap();
 
@@ -151,7 +151,7 @@ mod tests {
     #[test]
     fn test_get_item_not_exists() {
         let mut smt = UTXOSparseMerkleTree::new();
-        let utxo = sample_utxo();
+        let utxo = sample_utxo().unwrap();
 
         // Insert one UTXO and try to fetch a different hash
         smt.insert_item(utxo).unwrap();
@@ -166,7 +166,7 @@ mod tests {
     #[test]
     fn test_get_membership_proof() {
         let mut smt = UTXOSparseMerkleTree::new();
-        let utxo = sample_utxo();
+        let utxo = sample_utxo().unwrap();
 
         smt.insert_item(utxo.clone()).unwrap();
 

zkvm/src/lib.rs

@@ -29,7 +29,10 @@ pub fn prove_mint_utxo(
 
     let digest: UTXOPayload = receipt.journal.decode()?;
 
-    Ok((UTXO::create_utxo_from_payload(digest), receipt))
+    Ok((
+        UTXO::create_utxo_from_payload(digest).map_err(ExecutionFailureKind::write_error)?,
+        receipt,
+    ))
 }
 
 pub fn prove_send_utxo(
@@ -68,8 +71,9 @@ pub fn prove_send_utxo(
     Ok((
         digest
             .into_iter()
-            .map(|(payload, addr)| (UTXO::create_utxo_from_payload(payload), addr))
+            .map(|(payload, addr)| (UTXO::create_utxo_from_payload(payload).map(|sel| (sel, addr))))
-            .collect(),
+            .collect::<anyhow::Result<Vec<(UTXO, [u8; 32])>>>()
+            .map_err(ExecutionFailureKind::write_error)?,
         receipt,
     ))
 }
@@ -117,12 +121,14 @@ pub fn prove_send_utxo_multiple_assets_one_receiver(
             .0
             .into_iter()
             .map(|payload| UTXO::create_utxo_from_payload(payload))
-            .collect(),
+            .collect::<anyhow::Result<Vec<UTXO>>>()
+            .map_err(ExecutionFailureKind::write_error)?,
         digest
             .1
             .into_iter()
             .map(|payload| UTXO::create_utxo_from_payload(payload))
-            .collect(),
+            .collect::<anyhow::Result<Vec<UTXO>>>()
+            .map_err(ExecutionFailureKind::write_error)?,
         receipt,
     ))
 }
@@ -143,7 +149,8 @@ pub fn prove_send_utxo_shielded(
         asset: vec![],
         amount,
         privacy_flag: true,
-    });
+    })
+    .map_err(ExecutionFailureKind::write_error)?;
     let utxo_payload = temp_utxo_to_spend.into_payload();
 
     let mut builder = ExecutorEnv::builder();
@@ -171,8 +178,9 @@ pub fn prove_send_utxo_shielded(
     Ok((
         digest
             .into_iter()
-            .map(|(payload, addr)| (UTXO::create_utxo_from_payload(payload), addr))
+            .map(|(payload, addr)| (UTXO::create_utxo_from_payload(payload).map(|sel| (sel, addr))))
-            .collect(),
+            .collect::<anyhow::Result<Vec<(UTXO, [u8; 32])>>>()
+            .map_err(ExecutionFailureKind::write_error)?,
         receipt,
     ))
 }
@@ -253,24 +261,25 @@ pub fn prove_mint_utxo_multiple_assets(
         digest
             .into_iter()
             .map(UTXO::create_utxo_from_payload)
-            .collect(),
+            .collect::<anyhow::Result<Vec<UTXO>>>()
+            .map_err(ExecutionFailureKind::write_error)?,
         receipt,
     ))
 }
 
-pub fn execute_mint_utxo(amount_to_mint: u128, owner: AccountAddress) -> UTXO {
+pub fn execute_mint_utxo(amount_to_mint: u128, owner: AccountAddress) -> anyhow::Result<UTXO> {
     let mut builder = ExecutorEnv::builder();
 
-    builder.write(&amount_to_mint).unwrap();
+    builder.write(&amount_to_mint)?;
-    builder.write(&owner).unwrap();
+    builder.write(&owner)?;
 
-    let env = builder.build().unwrap();
+    let env = builder.build()?;
 
     let executor = default_executor();
 
-    let receipt = executor.execute(env, test_methods::MINT_UTXO_ELF).unwrap();
+    let receipt = executor.execute(env, test_methods::MINT_UTXO_ELF)?;
 
-    let digest: UTXOPayload = receipt.journal.decode().unwrap();
+    let digest: UTXOPayload = receipt.journal.decode()?;
 
     UTXO::create_utxo_from_payload(digest)
 }
@@ -278,76 +287,77 @@ pub fn execute_mint_utxo(amount_to_mint: u128, owner: AccountAddress) -> UTXO {
 pub fn execute_send_utxo(
     spent_utxo: UTXO,
     owners_parts: Vec<(u128, AccountAddress)>,
-) -> (UTXO, Vec<(UTXO, AccountAddress)>) {
+) -> anyhow::Result<(UTXO, Vec<(UTXO, AccountAddress)>)> {
     let mut builder = ExecutorEnv::builder();
 
     let utxo_payload = spent_utxo.into_payload();
 
-    builder.write(&utxo_payload).unwrap();
+    builder.write(&utxo_payload)?;
-    builder.write(&owners_parts).unwrap();
+    builder.write(&owners_parts)?;
 
-    let env = builder.build().unwrap();
+    let env = builder.build()?;
 
     let executor = default_executor();
 
-    let receipt = executor.execute(env, test_methods::SEND_UTXO_ELF).unwrap();
+    let receipt = executor.execute(env, test_methods::SEND_UTXO_ELF)?;
 
-    let digest: (UTXOPayload, Vec<(UTXOPayload, AccountAddress)>) =
+    let digest: (UTXOPayload, Vec<(UTXOPayload, AccountAddress)>) = receipt.journal.decode()?;
-        receipt.journal.decode().unwrap();
 
-    (
+    Ok((
-        UTXO::create_utxo_from_payload(digest.0),
+        UTXO::create_utxo_from_payload(digest.0)?,
         digest
             .1
             .into_iter()
-            .map(|(payload, addr)| (UTXO::create_utxo_from_payload(payload), addr))
+            .map(|(payload, addr)| (UTXO::create_utxo_from_payload(payload).map(|sel| (sel, addr))))
-            .collect(),
+            .collect::<anyhow::Result<Vec<(UTXO, [u8; 32])>>>()
-    )
+            .map_err(ExecutionFailureKind::write_error)?,
+    ))
 }
 
-pub fn prove<T: serde::ser::Serialize>(input_vec: Vec<T>, elf: &[u8]) -> (u64, Receipt) {
+pub fn prove<T: serde::ser::Serialize>(
+    input_vec: Vec<T>,
+    elf: &[u8],
+) -> anyhow::Result<(u64, Receipt)> {
     let mut builder = ExecutorEnv::builder();
 
     for input in input_vec {
-        builder.write(&input).unwrap();
+        builder.write(&input)?;
     }
 
-    let env = builder.build().unwrap();
+    let env = builder.build()?;
 
     let prover = default_prover();
 
-    let receipt = prover.prove(env, elf).unwrap().receipt;
+    let receipt = prover.prove(env, elf)?.receipt;
 
-    let digest = receipt.journal.decode().unwrap();
+    let digest = receipt.journal.decode()?;
-    (digest, receipt)
+    Ok((digest, receipt))
 }
 
 // This only executes the program and does not generate a receipt.
 pub fn execute<T: serde::ser::Serialize + for<'de> serde::Deserialize<'de>>(
     input_vec: Vec<T>,
     elf: &[u8],
-) -> T {
+) -> anyhow::Result<T> {
     let mut builder = ExecutorEnv::builder();
 
     for input in input_vec {
-        builder.write(&input).unwrap();
+        builder.write(&input)?;
     }
 
-    let env = builder.build().unwrap();
+    let env = builder.build()?;
 
     let exec = default_executor();
-    let session = exec.execute(env, elf).unwrap();
+    let session = exec.execute(env, elf)?;
 
     // We read the result committed to the journal by the guest code.
-    let result: T = session.journal.decode().unwrap();
+    let result: T = session.journal.decode()?;
 
-    result
+    Ok(result)
 }
 
-pub fn verify(receipt: Receipt, image_id: impl Into<Digest>) {
+pub fn verify(receipt: Receipt, image_id: impl Into<Digest>) -> anyhow::Result<()> {
-    receipt
+    Ok(receipt.verify(image_id)?)
-        .verify(image_id)
-        .expect("receipt verification failed");
 }
 
 #[cfg(test)]
@@ -362,7 +372,7 @@ mod tests {
         let message = 1;
         let message_2 = 2;
 
-        let (digest, receipt) = prove(vec![message, message_2], SUMMATION_ELF);
+        let (digest, receipt) = prove(vec![message, message_2], SUMMATION_ELF).unwrap();
 
         verify(receipt, SUMMATION_ID);
         assert_eq!(digest, message + message_2);
@@ -373,7 +383,7 @@ mod tests {
         let message = 123476;
         let message_2 = 2342384;
 
-        let (digest, receipt) = prove(vec![message, message_2], SUMMATION_ELF);
+        let (digest, receipt) = prove(vec![message, message_2], SUMMATION_ELF).unwrap();
 
         verify(receipt, SUMMATION_ID);
         assert_eq!(digest, message + message_2);
@@ -384,7 +394,7 @@ mod tests {
         let message = 1;
         let message_2 = 2;
 
-        let (digest, receipt) = prove(vec![message, message_2], MULTIPLICATION_ELF);
+        let (digest, receipt) = prove(vec![message, message_2], MULTIPLICATION_ELF).unwrap();
 
         verify(receipt, MULTIPLICATION_ID);
         assert_eq!(digest, message * message_2);
@@ -395,7 +405,7 @@ mod tests {
         let message = 3498;
         let message_2 = 438563;
 
-        let (digest, receipt) = prove(vec![message, message_2], MULTIPLICATION_ELF);
+        let (digest, receipt) = prove(vec![message, message_2], MULTIPLICATION_ELF).unwrap();
 
         verify(receipt, MULTIPLICATION_ID);
         assert_eq!(digest, message * message_2);
@@ -406,7 +416,7 @@ mod tests {
         let message: u64 = 1;
         let message_2: u64 = 2;
 
-        let result = execute(vec![message, message_2], SUMMATION_ELF);
+        let result = execute(vec![message, message_2], SUMMATION_ELF).unwrap();
         assert_eq!(result, message + message_2);
     }
 
@@ -415,7 +425,7 @@ mod tests {
         let message: u64 = 123476;
         let message_2: u64 = 2342384;
 
-        let result = execute(vec![message, message_2], SUMMATION_ELF);
+        let result = execute(vec![message, message_2], SUMMATION_ELF).unwrap();
         assert_eq!(result, message + message_2);
     }
 
@@ -424,7 +434,7 @@ mod tests {
         let message: u128 = 1;
         let message_2: u128 = 2;
 
-        let result = execute(vec![message, message_2], BIG_CALCULATION_ELF);
+        let result = execute(vec![message, message_2], BIG_CALCULATION_ELF).unwrap();
         assert_eq!(result, big_calculation(message, message_2));
     }
 
@@ -433,7 +443,7 @@ mod tests {
         let message: u128 = 20;
         let message_2: u128 = 10;
 
-        let result = execute(vec![message, message_2], BIG_CALCULATION_ELF);
+        let result = execute(vec![message, message_2], BIG_CALCULATION_ELF).unwrap();
         assert_eq!(result, big_calculation(message, message_2));
     }