logos-blockchain/lssa
1
0
Fork 0
mirror of https://github.com/logos-blockchain/lssa.git synced 2026-01-04 22:33:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #45 from vacp2p/error-handling

Browse Source 
Error handling
This commit is contained in:
tyshko-rostyslav 2025-02-14 05:51:57 +01:00 committed by GitHub
commit 09835b0462
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 89 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -7,7 +7,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},
@ -475,7 +475,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()),
};
@ -781,11 +782,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();
@ -962,11 +959,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!(
@ -1006,11 +999,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!(
@ -1055,12 +1044,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!(
@ -1080,12 +1064,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!(

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

@ -56,7 +56,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(
@ -95,8 +98,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,
))
}
@ -144,12 +148,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,
))
}
@ -170,7 +176,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();
@ -198,8 +205,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,
))
}
@ -280,24 +288,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)
}
@ -305,76 +314,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)]
@ -389,7 +399,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);
@ -400,7 +410,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);
@ -411,7 +421,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);
@ -422,7 +432,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);
@ -433,7 +443,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);
}
@ -442,7 +452,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);
}
@ -451,7 +461,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));
}
@ -460,7 +470,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));
}