logos-blockchain/lssa
1
0
Fork 0
mirror of https://github.com/logos-blockchain/lssa.git synced 2026-01-02 13:23:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Oleksandr Pravdyvyi 2025-02-14 10:49:34 +02:00
commit 620aefec23
17 changed files with 127 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.lock generated
View File

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

10
accounts/src/account_core/mod.rs
View File

@ -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 utxo2 = generate_dummy_utxo(account.address, 200);
let utxo1 = generate_dummy_utxo(account.address, 100).unwrap();
let utxo2 = generate_dummy_utxo(account.address, 200).unwrap();
let result = account.add_new_utxo_outputs(vec![utxo1.clone(), utxo2.clone()]);

37
node_core/src/lib.rs
View File

@ -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
.get_item(new_utxo_hash)
.unwrap()
.unwrap()
.clone()
acc.utxo_tree.get_item(new_utxo_hash)?.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
.get_item(new_utxo_hash)
.unwrap()
.unwrap()
.clone()
acc.utxo_tree.get_item(new_utxo_hash)?.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
.get_item(new_utxo_hash)
.unwrap()
.unwrap()
.clone()
acc.utxo_tree.get_item(new_utxo_hash)?.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
.utxo_tree
.get_item(new_utxo_hash)
.unwrap()
.unwrap()
.clone();
let new_utxo = acc.utxo_tree.get_item(new_utxo_hash)?.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
.utxo_tree
.get_item(new_utxo_hash)
.unwrap()
.unwrap()
.clone();
let new_utxo = acc.utxo_tree.get_item(new_utxo_hash)?.unwrap().clone();
new_utxo.log();
info!(

32
node_core/src/sequencer_client/json.rs
View File

@ -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)]

4
node_core/src/sequencer_client/mod.rs
View File

@ -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;

34
node_rpc/src/process.rs
View File

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

1
node_rpc/src/types/mod.rs
View File

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

1
node_rpc/src/types/parse.rs
View File

@ -1 +0,0 @@

58
node_rpc/src/types/rpc_structs.rs
View File

@ -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!(SendTxRequest);
parse_request!(GetBlockDataRequest);
parse_request!(GetGenesisIdRequest);
// 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,

6
rpc_primitives/Cargo.toml
View File

@ -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"

1
rpc_primitives/src/lib.rs
View File

@ -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 {

8
sequencer_rpc/src/types/rpc_structs.rs → rpc_primitives/src/requests.rs
View File

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

2
sequencer_rpc/src/process.rs
View File

@ -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,

1
sequencer_rpc/src/types/mod.rs
View File

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

16
utxo/src/utxo_core.rs
View File

@ -29,8 +29,8 @@ pub struct UTXOPayload {
}
impl UTXO {
pub fn create_utxo_from_payload(payload_with_asset: UTXOPayload) -> Self {
let raw_payload = serde_json::to_vec(&payload_with_asset).unwrap();
pub fn create_utxo_from_payload(payload_with_asset: UTXOPayload) -> anyhow::Result<Self> {
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();

14
utxo/src/utxo_tree.rs
View File

@ -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 utxo2 = sample_utxo();
let utxo1 = sample_utxo().unwrap();
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();

112
zkvm/src/lib.rs
View File

@ -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))
.collect(),
.map(|(payload, addr)| (UTXO::create_utxo_from_payload(payload).map(|sel| (sel, addr))))
.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))
.collect(),
.map(|(payload, addr)| (UTXO::create_utxo_from_payload(payload).map(|sel| (sel, addr))))
.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(&owner).unwrap();
builder.write(&amount_to_mint)?;
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(&owners_parts).unwrap();
builder.write(&utxo_payload)?;
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)>) =
receipt.journal.decode().unwrap();
let digest: (UTXOPayload, Vec<(UTXOPayload, AccountAddress)>) = receipt.journal.decode()?;
(
UTXO::create_utxo_from_payload(digest.0),
Ok((
UTXO::create_utxo_from_payload(digest.0)?,
digest
.1
.into_iter()
.map(|(payload, addr)| (UTXO::create_utxo_from_payload(payload), addr))
.collect(),
)
.map(|(payload, addr)| (UTXO::create_utxo_from_payload(payload).map(|sel| (sel, addr))))
.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();
(digest, receipt)
let digest = receipt.journal.decode()?;
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>) {
receipt
.verify(image_id)
.expect("receipt verification failed");
pub fn verify(receipt: Receipt, image_id: impl Into<Digest>) -> anyhow::Result<()> {
Ok(receipt.verify(image_id)?)
}
#[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));
}