diff --git a/Cargo.lock b/Cargo.lock index 8f56826..0f2c767 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -994,6 +994,20 @@ dependencies = [ "os_str_bytes", ] +[[package]] +name = "common" +version = "0.1.0" +dependencies = [ + "anyhow", + "monotree", + "reqwest 0.11.27", + "risc0-zkvm", + "rpc_primitives", + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "consensus" version = "0.1.0" @@ -2674,6 +2688,7 @@ dependencies = [ "actix-rt", "anyhow", "bincode", + "common", "elliptic-curve", "env_logger", "hex", @@ -2705,6 +2720,7 @@ dependencies = [ "actix-cors", "actix-web", "anyhow", + "common", "consensus", "env_logger", "futures", @@ -5410,6 +5426,7 @@ version = "0.1.0" dependencies = [ "accounts", "anyhow", + "common", "env_logger", "log", "risc0-zkvm", diff --git a/Cargo.toml b/Cargo.toml index e04fca5..548f216 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,6 +16,7 @@ members = [ "node_core", "sequencer_core", "rpc_primitives", + "common", ] [workspace.dependencies] diff --git a/common/Cargo.toml b/common/Cargo.toml new file mode 100644 index 0000000..0c4664f --- /dev/null +++ b/common/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "common" +version = "0.1.0" +edition = "2021" + +[dependencies] +anyhow.workspace = true +thiserror.workspace = true +serde_json.workspace = true +serde.workspace = true +reqwest.workspace = true +monotree.workspace = true +risc0-zkvm = { git = "https://github.com/risc0/risc0.git", branch = "release-1.2" } + +[dependencies.rpc_primitives] +path = "../rpc_primitives" diff --git a/common/src/lib.rs b/common/src/lib.rs new file mode 100644 index 0000000..0ebfcdf --- /dev/null +++ b/common/src/lib.rs @@ -0,0 +1,69 @@ +use rpc_primitives::errors::RpcError; +use serde::Deserialize; + +#[derive(Debug, Clone, Deserialize)] +pub struct SequencerRpcError { + pub jsonrpc: String, + pub error: RpcError, + pub id: u64, +} + +#[derive(thiserror::Error, Debug)] +pub enum SequencerClientError { + #[error("HTTP error")] + HTTPError(reqwest::Error), + #[error("Serde error")] + SerdeError(serde_json::Error), + #[error("Internal error")] + InternalError(SequencerRpcError), +} + +impl From for SequencerClientError { + fn from(value: reqwest::Error) -> Self { + SequencerClientError::HTTPError(value) + } +} + +impl From for SequencerClientError { + fn from(value: serde_json::Error) -> Self { + SequencerClientError::SerdeError(value) + } +} + +impl From for SequencerClientError { + fn from(value: SequencerRpcError) -> Self { + SequencerClientError::InternalError(value) + } +} + +#[derive(Debug, thiserror::Error)] +pub enum ExecutionFailureKind { + #[error("Failed to write into builder err: {0:?}")] + WriteError(anyhow::Error), + #[error("Failed to build builder err: {0:?}")] + BuilderError(anyhow::Error), + #[error("Failed prove execution err: {0:?}")] + ProveError(anyhow::Error), + #[error("Failed to decode data from VM: {0:?}")] + DecodeError(#[from] risc0_zkvm::serde::Error), + #[error("Inputs amounts does not match outputs")] + AmountMismatchError, + #[error("Sequencer client error: {0:?}")] + SequencerClientError(#[from] SequencerClientError), + #[error("Datebase returned error : {0:?}")] + MonoTreeError(#[from] monotree::Errors), +} + +impl ExecutionFailureKind { + pub fn write_error(err: anyhow::Error) -> Self { + Self::WriteError(err) + } + + pub fn builder_error(err: anyhow::Error) -> Self { + Self::BuilderError(err) + } + + pub fn prove_error(err: anyhow::Error) -> Self { + Self::ProveError(err) + } +} diff --git a/node_core/Cargo.toml b/node_core/Cargo.toml index fd6c25b..0cd711d 100644 --- a/node_core/Cargo.toml +++ b/node_core/Cargo.toml @@ -38,6 +38,9 @@ path = "../zkvm" [dependencies.rpc_primitives] path = "../rpc_primitives" +[dependencies.common] +path = "../common" + [dependencies.secp256k1-zkp] workspace = true features = ["std", "rand-std", "rand", "serde", "global-context"] diff --git a/node_core/src/lib.rs b/node_core/src/lib.rs index 946908c..28c0bb5 100644 --- a/node_core/src/lib.rs +++ b/node_core/src/lib.rs @@ -3,6 +3,7 @@ use std::sync::{ Arc, }; +use common::ExecutionFailureKind; use k256::elliptic_curve::group::GroupEncoding; use ::storage::transaction::{Transaction, TransactionPayload, TxKind}; @@ -23,7 +24,7 @@ use tokio::{sync::RwLock, task::JoinHandle}; use utxo::utxo_core::UTXO; use zkvm::{ prove_mint_utxo, prove_mint_utxo_multiple_assets, prove_send_utxo, prove_send_utxo_deshielded, - prove_send_utxo_multiple_assets_one_receiver, prove_send_utxo_shielded, ExecutionFailureKind, + prove_send_utxo_multiple_assets_one_receiver, prove_send_utxo_shielded, }; pub const BLOCK_GEN_DELAY_SECS: u64 = 20; @@ -603,7 +604,7 @@ impl NodeCore { &self, acc: AccountAddress, amount: u128, - ) -> Result<(SendTxResponse, [u8; 32], [u8; 32])> { + ) -> Result<(SendTxResponse, [u8; 32], [u8; 32]), ExecutionFailureKind> { //Considering proof time, needs to be done before proof let tx_roots = self.get_roots().await; @@ -629,7 +630,7 @@ impl NodeCore { acc: AccountAddress, amount: u128, number_of_assets: usize, - ) -> Result<(SendTxResponse, Vec<[u8; 32]>, Vec<[u8; 32]>)> { + ) -> Result<(SendTxResponse, Vec<[u8; 32]>, Vec<[u8; 32]>), ExecutionFailureKind> { //Considering proof time, needs to be done before proof let tx_roots = self.get_roots().await; @@ -656,7 +657,7 @@ impl NodeCore { &self, acc: AccountAddress, amount: u128, - ) -> Result { + ) -> Result { //Considering proof time, needs to be done before proof let tx_roots = self.get_roots().await; @@ -671,7 +672,7 @@ impl NodeCore { utxo: UTXO, comm_hash: [u8; 32], receivers: Vec<(u128, AccountAddress)>, - ) -> Result<(SendTxResponse, Vec<([u8; 32], [u8; 32])>)> { + ) -> Result<(SendTxResponse, Vec<([u8; 32], [u8; 32])>), ExecutionFailureKind> { //Considering proof time, needs to be done before proof let tx_roots = self.get_roots().await; @@ -697,7 +698,7 @@ impl NodeCore { comm_hashes: Vec<[u8; 32]>, number_to_send: usize, receiver: AccountAddress, - ) -> Result<(SendTxResponse, Vec<[u8; 32]>, Vec<[u8; 32]>)> { + ) -> Result<(SendTxResponse, Vec<[u8; 32]>, Vec<[u8; 32]>), ExecutionFailureKind> { //Considering proof time, needs to be done before proof let tx_roots = self.get_roots().await; @@ -723,7 +724,7 @@ impl NodeCore { acc: AccountAddress, amount: u64, receivers: Vec<(u128, AccountAddress)>, - ) -> Result<(SendTxResponse, Vec<([u8; 32], [u8; 32])>)> { + ) -> Result<(SendTxResponse, Vec<([u8; 32], [u8; 32])>), ExecutionFailureKind> { //Considering proof time, needs to be done before proof let tx_roots = self.get_roots().await; @@ -748,7 +749,7 @@ impl NodeCore { utxo: UTXO, comm_gen_hash: [u8; 32], receivers: Vec<(u128, AccountAddress)>, - ) -> Result { + ) -> Result { //Considering proof time, needs to be done before proof let tx_roots = self.get_roots().await; @@ -769,7 +770,7 @@ impl NodeCore { &mut self, acc_addr: AccountAddress, amount: u128, - ) -> Result<(UTXO, [u8; 32])> { + ) -> Result<(UTXO, [u8; 32]), ExecutionFailureKind> { let (resp, new_utxo_hash, comm_gen_hash) = self.send_private_mint_tx(acc_addr, amount).await?; info!("Response for mint private is {resp:?}"); @@ -804,7 +805,7 @@ impl NodeCore { acc_addr: AccountAddress, amount: u128, number_of_assets: usize, - ) -> Result<(Vec, Vec<[u8; 32]>)> { + ) -> Result<(Vec, Vec<[u8; 32]>), ExecutionFailureKind> { let (resp, new_utxo_hashes, comm_gen_hashes) = self .send_private_mint_multiple_assets_tx(acc_addr, amount, number_of_assets) .await?; @@ -854,7 +855,7 @@ impl NodeCore { acc_addr_rec: AccountAddress, utxo: UTXO, comm_gen_hash: [u8; 32], - ) -> Result<()> { + ) -> Result<(), ExecutionFailureKind> { let amount = utxo.amount; let old_balance = { @@ -900,7 +901,7 @@ impl NodeCore { &mut self, acc_addr: AccountAddress, amount: u128, - ) -> Result<()> { + ) -> Result<(), ExecutionFailureKind> { let old_balance = { let acc_map_read_guard = self.storage.read().await; @@ -942,7 +943,7 @@ impl NodeCore { acc_addr_sender: AccountAddress, acc_addr_rec: AccountAddress, amount: u128, - ) -> Result { + ) -> Result { let (resp, new_utxo_hashes) = self .send_shielded_send_tx(acc_addr_sender, amount as u64, vec![(amount, acc_addr_rec)]) .await?; @@ -980,7 +981,7 @@ impl NodeCore { acc_addr_rec: AccountAddress, utxo: UTXO, comm_gen_hash: [u8; 32], - ) -> Result { + ) -> Result { let amount = utxo.amount; let (resp, new_utxo_hashes) = self @@ -1023,7 +1024,7 @@ impl NodeCore { utxos: Vec, comm_gen_hashes: Vec<[u8; 32]>, number_to_send: usize, - ) -> Result<()> { + ) -> Result<(), ExecutionFailureKind> { let (resp, new_utxo_hashes_rec, new_utxo_hashes_not_sp) = self .send_private_multiple_assets_send_tx( utxos, @@ -1179,7 +1180,8 @@ impl NodeCore { comm_hash: [u8; 32], receivers: Vec<(u128, AccountAddress)>, visibility_list: [bool; 3], - ) -> Result<(SendTxResponse, Vec<([u8; 32], [u8; 32])>, Vec<[u8; 32]>)> { + ) -> Result<(SendTxResponse, Vec<([u8; 32], [u8; 32])>, Vec<[u8; 32]>), ExecutionFailureKind> + { //Considering proof time, needs to be done before proof let tx_roots = self.get_roots().await; @@ -1208,7 +1210,7 @@ impl NodeCore { utxo: UTXO, comm_gen_hash: [u8; 32], visibility_list: [bool; 3], - ) -> Result<(Vec, Vec<[u8; 32]>)> { + ) -> Result<(Vec, Vec<[u8; 32]>), ExecutionFailureKind> { let (resp, new_utxo_hashes, commitments_hashes) = self .send_split_tx( utxo.clone(), @@ -1261,7 +1263,7 @@ impl NodeCore { } ///Mint utxo, make it public - pub async fn subscenario_1(&mut self) -> Result<()> { + pub async fn subscenario_1(&mut self) -> Result<(), ExecutionFailureKind> { let acc_addr = self.create_new_account().await; let (new_utxo, comm_gen_hash) = self.operate_account_mint_private(acc_addr, 100).await?; @@ -1278,7 +1280,7 @@ impl NodeCore { } ///Deposit balance, make it private - pub async fn subscenario_2(&mut self) -> Result<()> { + pub async fn subscenario_2(&mut self) -> Result<(), ExecutionFailureKind> { let acc_addr = self.create_new_account().await; self.operate_account_deposit_public(acc_addr, 100).await?; @@ -1290,7 +1292,7 @@ impl NodeCore { } ///Mint utxo, privately send it to another user - pub async fn subscenario_3(&mut self) -> Result<()> { + pub async fn subscenario_3(&mut self) -> Result<(), ExecutionFailureKind> { let acc_addr = self.create_new_account().await; let acc_addr_rec = self.create_new_account().await; @@ -1303,7 +1305,7 @@ impl NodeCore { } ///Deposit balance, shielded send it to another user - pub async fn subscenario_4(&mut self) -> Result<()> { + pub async fn subscenario_4(&mut self) -> Result<(), ExecutionFailureKind> { let acc_addr = self.create_new_account().await; let acc_addr_rec = self.create_new_account().await; @@ -1316,7 +1318,7 @@ impl NodeCore { } ///Mint utxo, deshielded send it to another user - pub async fn subscenario_5(&mut self) -> Result<()> { + pub async fn subscenario_5(&mut self) -> Result<(), ExecutionFailureKind> { let acc_addr = self.create_new_account().await; let acc_addr_rec = self.create_new_account().await; @@ -1342,7 +1344,7 @@ impl NodeCore { &mut self, visibility_list: [bool; 3], publication_index: usize, - ) -> Result<()> { + ) -> Result<(), ExecutionFailureKind> { let acc_addr_sender = self.create_new_account().await; let acc_addr_rec_1 = self.create_new_account().await; @@ -1380,7 +1382,7 @@ impl NodeCore { &mut self, number_of_assets: usize, number_to_send: usize, - ) -> Result<()> { + ) -> Result<(), ExecutionFailureKind> { let acc_addr_sender = self.create_new_account().await; let acc_addr_receiver = self.create_new_account().await; diff --git a/node_core/src/sequencer_client/json.rs b/node_core/src/sequencer_client/json.rs index 93a3231..5bfeb35 100644 --- a/node_core/src/sequencer_client/json.rs +++ b/node_core/src/sequencer_client/json.rs @@ -1,4 +1,3 @@ -use rpc_primitives::errors::RpcError; use serde::{Deserialize, Serialize}; use storage::transaction::Transaction; @@ -47,10 +46,3 @@ pub struct SequencerRpcResponse { pub result: serde_json::Value, pub id: u64, } - -#[derive(Debug, Clone, Deserialize)] -pub struct SequencerRpcError { - pub jsonrpc: String, - pub error: RpcError, - pub id: u64, -} diff --git a/node_core/src/sequencer_client/mod.rs b/node_core/src/sequencer_client/mod.rs index 60f9d9d..e68872f 100644 --- a/node_core/src/sequencer_client/mod.rs +++ b/node_core/src/sequencer_client/mod.rs @@ -1,8 +1,7 @@ use accounts::account_core::Account; use anyhow::Result; -use json::{ - SendTxRequest, SendTxResponse, SequencerRpcError, SequencerRpcRequest, SequencerRpcResponse, -}; +use common::{SequencerClientError, SequencerRpcError}; +use json::{SendTxRequest, SendTxResponse, SequencerRpcRequest, SequencerRpcResponse}; use k256::elliptic_curve::group::GroupEncoding; use reqwest::Client; use rpc_primitives::requests::{ @@ -22,34 +21,6 @@ pub struct SequencerClient { pub config: NodeConfig, } -#[derive(thiserror::Error, Debug)] -pub enum SequencerClientError { - #[error("HTTP error")] - HTTPError(reqwest::Error), - #[error("Serde error")] - SerdeError(serde_json::Error), - #[error("Internal error")] - InternalError(SequencerRpcError), -} - -impl From for SequencerClientError { - fn from(value: reqwest::Error) -> Self { - SequencerClientError::HTTPError(value) - } -} - -impl From for SequencerClientError { - fn from(value: serde_json::Error) -> Self { - SequencerClientError::SerdeError(value) - } -} - -impl From for SequencerClientError { - fn from(value: SequencerRpcError) -> Self { - SequencerClientError::InternalError(value) - } -} - impl SequencerClient { pub fn new(config: NodeConfig) -> Result { Ok(Self { diff --git a/node_rpc/Cargo.toml b/node_rpc/Cargo.toml index 6188e5a..bba8368 100644 --- a/node_rpc/Cargo.toml +++ b/node_rpc/Cargo.toml @@ -43,3 +43,6 @@ path = "../node_core" [dependencies.rpc_primitives] path = "../rpc_primitives" + +[dependencies.common] +path = "../common" diff --git a/node_rpc/src/process.rs b/node_rpc/src/process.rs index b174619..0168d29 100644 --- a/node_rpc/src/process.rs +++ b/node_rpc/src/process.rs @@ -16,18 +16,21 @@ use rpc_primitives::requests::{ RegisterAccountRequest, RegisterAccountResponse, }; -use crate::types::rpc_structs::{ - ExecuteScenarioMultipleSendRequest, ExecuteScenarioMultipleSendResponse, - ExecuteScenarioSplitRequest, ExecuteScenarioSplitResponse, ExecuteSubscenarioRequest, - ExecuteSubscenarioResponse, ShowAccountPublicBalanceRequest, ShowAccountPublicBalanceResponse, - ShowAccountUTXORequest, ShowAccountUTXOResponse, ShowTransactionRequest, - ShowTransactionResponse, UTXOShortEssentialStruct, WriteDepositPublicBalanceRequest, - WriteDepositPublicBalanceResponse, WriteMintPrivateUTXOMultipleAssetsRequest, - WriteMintPrivateUTXOMultipleAssetsResponse, WriteMintPrivateUTXORequest, - WriteMintPrivateUTXOResponse, WriteSendDeshieldedBalanceRequest, - WriteSendDeshieldedUTXOResponse, WriteSendPrivateUTXORequest, WriteSendPrivateUTXOResponse, - WriteSendShieldedUTXORequest, WriteSendShieldedUTXOResponse, WriteSendSplitUTXOResponse, - WriteSplitUTXORequest, +use crate::types::{ + err_rpc::cast_common_execution_error_into_rpc_error, + rpc_structs::{ + ExecuteScenarioMultipleSendRequest, ExecuteScenarioMultipleSendResponse, + ExecuteScenarioSplitRequest, ExecuteScenarioSplitResponse, ExecuteSubscenarioRequest, + ExecuteSubscenarioResponse, ShowAccountPublicBalanceRequest, + ShowAccountPublicBalanceResponse, ShowAccountUTXORequest, ShowAccountUTXOResponse, + ShowTransactionRequest, ShowTransactionResponse, UTXOShortEssentialStruct, + WriteDepositPublicBalanceRequest, WriteDepositPublicBalanceResponse, + WriteMintPrivateUTXOMultipleAssetsRequest, WriteMintPrivateUTXOMultipleAssetsResponse, + WriteMintPrivateUTXORequest, WriteMintPrivateUTXOResponse, + WriteSendDeshieldedBalanceRequest, WriteSendDeshieldedUTXOResponse, + WriteSendPrivateUTXORequest, WriteSendPrivateUTXOResponse, WriteSendShieldedUTXORequest, + WriteSendShieldedUTXOResponse, WriteSendSplitUTXOResponse, WriteSplitUTXORequest, + }, }; use super::{respond, types::err_rpc::RpcErr, JsonHandler}; @@ -55,11 +58,26 @@ impl JsonHandler { let mut store = self.node_chain_store.lock().await; match req.scenario_id { - 1 => store.subscenario_1().await?, - 2 => store.subscenario_2().await?, - 3 => store.subscenario_3().await?, - 4 => store.subscenario_4().await?, - 5 => store.subscenario_5().await?, + 1 => store + .subscenario_1() + .await + .map_err(cast_common_execution_error_into_rpc_error)?, + 2 => store + .subscenario_2() + .await + .map_err(cast_common_execution_error_into_rpc_error)?, + 3 => store + .subscenario_3() + .await + .map_err(cast_common_execution_error_into_rpc_error)?, + 4 => store + .subscenario_4() + .await + .map_err(cast_common_execution_error_into_rpc_error)?, + 5 => store + .subscenario_5() + .await + .map_err(cast_common_execution_error_into_rpc_error)?, _ => return Err(RpcErr(RpcError::invalid_params("Scenario id not found"))), } } @@ -82,7 +100,8 @@ impl JsonHandler { store .scenario_1(req.visibility_list, req.publication_index) - .await?; + .await + .map_err(cast_common_execution_error_into_rpc_error)?; } let helperstruct = ExecuteScenarioSplitResponse { @@ -103,7 +122,8 @@ impl JsonHandler { store .scenario_2(req.number_of_assets, req.number_to_send) - .await?; + .await + .map_err(cast_common_execution_error_into_rpc_error)?; } let helperstruct = ExecuteScenarioMultipleSendResponse { @@ -335,7 +355,8 @@ impl JsonHandler { cover_guard .operate_account_deposit_public(acc_addr, req.amount as u128) - .await?; + .await + .map_err(cast_common_execution_error_into_rpc_error)?; }; let helperstruct = WriteDepositPublicBalanceResponse { @@ -361,7 +382,8 @@ impl JsonHandler { cover_guard .operate_account_mint_private(acc_addr, req.amount as u128) - .await? + .await + .map_err(cast_common_execution_error_into_rpc_error)? }; let helperstruct = WriteMintPrivateUTXOResponse { @@ -399,7 +421,8 @@ impl JsonHandler { req.amount as u128, req.num_of_assets, ) - .await? + .await + .map_err(cast_common_execution_error_into_rpc_error)? }; let helperstruct = WriteMintPrivateUTXOMultipleAssetsResponse { @@ -481,7 +504,8 @@ impl JsonHandler { cover_guard .operate_account_send_private_one_receiver(acc_addr, utxo_to_send, comm_hash) - .await? + .await + .map_err(cast_common_execution_error_into_rpc_error)? }; let helperstruct = WriteSendPrivateUTXOResponse { @@ -533,7 +557,8 @@ impl JsonHandler { acc_addr_rec, req.amount as u128, ) - .await? + .await + .map_err(cast_common_execution_error_into_rpc_error)? }; let helperstruct = WriteSendShieldedUTXOResponse { @@ -619,7 +644,8 @@ impl JsonHandler { utxo_to_send, comm_hash, ) - .await? + .await + .map_err(cast_common_execution_error_into_rpc_error)? }; let helperstruct = WriteSendDeshieldedUTXOResponse { @@ -711,7 +737,8 @@ impl JsonHandler { comm_hash, req.visibility_list, ) - .await? + .await + .map_err(cast_common_execution_error_into_rpc_error)? }; let helperstruct = WriteSendSplitUTXOResponse { diff --git a/node_rpc/src/types/err_rpc.rs b/node_rpc/src/types/err_rpc.rs index c7ef25b..9eafb93 100644 --- a/node_rpc/src/types/err_rpc.rs +++ b/node_rpc/src/types/err_rpc.rs @@ -1,6 +1,6 @@ +use common::{ExecutionFailureKind, SequencerClientError}; use log::debug; -use node_core::sequencer_client::SequencerClientError; use rpc_primitives::errors::{RpcError, RpcParseError}; pub struct RpcErr(pub RpcError); @@ -59,3 +59,21 @@ pub fn cast_seq_client_error_into_rpc_error(seq_cli_err: SequencerClientError) - ), } } + +pub fn cast_common_execution_error_into_rpc_error(comm_exec_err: ExecutionFailureKind) -> RpcError { + let error_string = comm_exec_err.to_string(); + + match comm_exec_err { + ExecutionFailureKind::BuilderError(_) => RpcError::new_internal_error(None, &error_string), + ExecutionFailureKind::WriteError(_) => RpcError::new_internal_error(None, &error_string), + ExecutionFailureKind::DecodeError(_) => RpcError::new_internal_error(None, &error_string), + ExecutionFailureKind::ProveError(_) => RpcError::new_internal_error(None, &error_string), + ExecutionFailureKind::AmountMismatchError => { + RpcError::new_internal_error(None, &error_string) + } + ExecutionFailureKind::SequencerClientError(seq_cli_err) => { + cast_seq_client_error_into_rpc_error(seq_cli_err) + } + ExecutionFailureKind::MonoTreeError(_) => RpcError::new_internal_error(None, &error_string), + } +} diff --git a/zkvm/Cargo.toml b/zkvm/Cargo.toml index 55d7e15..f0c0576 100644 --- a/zkvm/Cargo.toml +++ b/zkvm/Cargo.toml @@ -23,6 +23,9 @@ path = "../storage" [dependencies.utxo] path = "../utxo" +[dependencies.common] +path = "../common" + [features] cuda = ["risc0-zkvm/cuda"] default = [] diff --git a/zkvm/src/lib.rs b/zkvm/src/lib.rs index a3dcf82..93692ed 100644 --- a/zkvm/src/lib.rs +++ b/zkvm/src/lib.rs @@ -1,35 +1,8 @@ use accounts::account_core::AccountAddress; +use common::ExecutionFailureKind; use risc0_zkvm::{default_executor, default_prover, sha::Digest, ExecutorEnv, Receipt}; use utxo::utxo_core::{UTXOPayload, UTXO}; -#[derive(Debug, thiserror::Error)] -pub enum ExecutionFailureKind { - #[error("Failed to write into builder err: {0:?}")] - WriteError(anyhow::Error), - #[error("Failed to build builder err: {0:?}")] - BuilderError(anyhow::Error), - #[error("Failed prove execution err: {0:?}")] - ProveError(anyhow::Error), - #[error("Failed to decode data from VM: {0:?}")] - DecodeError(#[from] risc0_zkvm::serde::Error), - #[error("Inputs amounts does not match outputs")] - AmountMismatchError, -} - -impl ExecutionFailureKind { - pub fn write_error(err: anyhow::Error) -> Self { - Self::WriteError(err) - } - - pub fn builder_error(err: anyhow::Error) -> Self { - Self::BuilderError(err) - } - - pub fn prove_error(err: anyhow::Error) -> Self { - Self::ProveError(err) - } -} - pub fn prove_mint_utxo( amount_to_mint: u128, owner: AccountAddress,