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

fix: test fix 2

Browse Source
This commit is contained in:
Oleksandr Pravdyvyi 2025-08-13 16:17:52 +03:00
parent d7acffd8da
commit e589ddae5a
No known key found for this signature in database
GPG Key ID: 9F8955C63C443871
20 changed files with 3 additions and 2249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@ -8,7 +8,6 @@ members = [
"utxo", "utxo",
"sequencer_rpc", "sequencer_rpc",
"mempool", "mempool",
"zkvm",
"wallet", "wallet",
"sequencer_core", "sequencer_core",
"common", "common",

0
zkvm/src/gas_calculator.rs → nssa/src/gas_calculator.rs
View File

1
nssa/src/lib.rs
View File

@ -1,5 +1,6 @@
pub mod address; pub mod address;
pub mod error; pub mod error;
pub mod gas_calculator;
pub mod program; pub mod program;
pub mod public_transaction; pub mod public_transaction;
mod signature; mod signature;

3
wallet/Cargo.toml
View File

@ -32,9 +32,6 @@ path = "../accounts"
[dependencies.utxo] [dependencies.utxo]
path = "../utxo" path = "../utxo"
[dependencies.zkvm]
path = "../zkvm"
[dependencies.nssa] [dependencies.nssa]
path = "../nssa" path = "../nssa"

4
wallet/src/config.rs
View File

@ -1,8 +1,8 @@
use std::path::PathBuf; use std::path::PathBuf;
use accounts::account_core::Account; use accounts::account_core::Account;
use nssa::gas_calculator::GasCalculator;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use zkvm::gas_calculator::GasCalculator;
#[derive(Debug, Clone, Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GasConfig { pub struct GasConfig {
@ -22,7 +22,7 @@ pub struct GasConfig {
pub gas_limit_runtime: u64, pub gas_limit_runtime: u64,
} }
impl From<GasConfig> for zkvm::gas_calculator::GasCalculator { impl From<GasConfig> for GasCalculator {
fn from(value: GasConfig) -> Self { fn from(value: GasConfig) -> Self {
GasCalculator::new( GasCalculator::new(
value.gas_fee_per_byte_deploy, value.gas_fee_per_byte_deploy,

3
wallet/src/lib.rs
View File

@ -42,9 +42,6 @@ impl WalletCore {
//Persistent accounts take precedence for initial accounts //Persistent accounts take precedence for initial accounts
let persistent_accounts = fetch_persistent_accounts()?; let persistent_accounts = fetch_persistent_accounts()?;
info!("Fetched persistent accoounts {persistent_accounts:#?}");
for acc in persistent_accounts { for acc in persistent_accounts {
storage.acc_map.insert(acc.address, acc); storage.acc_map.insert(acc.address, acc);
} }

33
zkvm/Cargo.toml
View File

@ -1,33 +0,0 @@
[package]
name = "zkvm"
version = "0.1.0"
edition = "2021"
[dependencies]
anyhow.workspace = true
serde_json.workspace = true
env_logger.workspace = true
log.workspace = true
serde.workspace = true
thiserror.workspace = true
rand.workspace = true
risc0-zkvm = "2.3.1"
test-methods = { path = "test_methods" }
[dependencies.accounts]
path = "../accounts"
[dependencies.utxo]
path = "../utxo"
[dependencies.common]
path = "../common"
[dependencies.nssa]
path = "../nssa"
[features]
cuda = ["risc0-zkvm/cuda"]
default = []
prove = ["risc0-zkvm/prove"]

653
zkvm/src/lib.rs
View File

@ -1,653 +0,0 @@
use common::ExecutionFailureKind;
use nssa::Address;
use rand::{rngs::OsRng, RngCore};
use risc0_zkvm::{default_executor, default_prover, sha::Digest, ExecutorEnv, Receipt};
use serde::Serialize;
use utxo::utxo_core::{Randomness, UTXOPayload, UTXO};
pub mod gas_calculator;
pub use test_methods;
#[allow(clippy::result_large_err)]
pub fn gas_limits_check<INP: Serialize>(
input_buffer: INP,
elf: &[u8],
gas_calculator: &gas_calculator::GasCalculator,
attached_funds: u64,
) -> Result<(), ExecutionFailureKind> {
let mut input_buffer_len: usize = 0;
input_buffer_len += serde_json::to_vec(&input_buffer).unwrap().len();
let gas_limit = gas_calculator
.gas_runtime_full(elf, input_buffer_len)
.ok_or(ExecutionFailureKind::InsufficientGasError)?;
let cost = gas_calculator.runtime_cost(gas_limit);
if cost > attached_funds {
return Err(ExecutionFailureKind::InsufficientFundsError);
}
Ok(())
}
#[allow(clippy::result_large_err)]
pub fn prove_mint_utxo(
amount_to_mint: u128,
owner: Address,
) -> Result<(UTXO, Receipt), ExecutionFailureKind> {
let mut builder = ExecutorEnv::builder();
builder
.write(&amount_to_mint)
.map_err(ExecutionFailureKind::write_error)?;
builder
.write(&owner)
.map_err(ExecutionFailureKind::write_error)?;
let mut randomness = Randomness::default();
OsRng.fill_bytes(&mut randomness);
builder
.write(&randomness)
.map_err(ExecutionFailureKind::write_error)?;
let env = builder
.build()
.map_err(ExecutionFailureKind::builder_error)?;
let prover = default_prover();
let receipt = prover
.prove(env, test_methods::MINT_UTXO_ELF)
.map_err(ExecutionFailureKind::prove_error)?
.receipt;
let digest: UTXOPayload = receipt
.journal
.decode()
.map_err(|e| ExecutionFailureKind::DecodeError(e.to_string()))?;
Ok((UTXO::create_utxo_from_payload(digest), receipt))
}
#[allow(clippy::result_large_err)]
pub fn prove_send_utxo(
spent_utxo: UTXO,
owners_parts: Vec<(u128, Address)>,
) -> Result<(Vec<(UTXO, Address)>, Receipt), ExecutionFailureKind> {
let cumulative_spent = owners_parts.iter().fold(0, |acc, item| acc + item.0);
if cumulative_spent != spent_utxo.amount {
return Err(ExecutionFailureKind::AmountMismatchError);
}
let mut builder = ExecutorEnv::builder();
let utxo_payload = spent_utxo.into_payload();
builder
.write(&utxo_payload)
.map_err(ExecutionFailureKind::write_error)?;
let owners_parts_with_randomness = owners_parts
.into_iter()
.map(|(amount, addr)| {
let mut randomness = Randomness::default();
OsRng.fill_bytes(&mut randomness);
(amount, addr, randomness)
})
.collect::<Vec<_>>();
builder
.write(&owners_parts_with_randomness)
.map_err(ExecutionFailureKind::write_error)?;
let env = builder
.build()
.map_err(ExecutionFailureKind::builder_error)?;
let prover = default_prover();
let receipt = prover
.prove(env, test_methods::SEND_UTXO_ELF)
.map_err(ExecutionFailureKind::prove_error)?
.receipt;
let digest: Vec<(UTXOPayload, Address)> = receipt
.journal
.decode()
.map_err(|e| ExecutionFailureKind::DecodeError(e.to_string()))?;
Ok((
digest
.into_iter()
.map(|(payload, addr)| (UTXO::create_utxo_from_payload(payload), addr))
.collect(),
receipt,
))
}
#[allow(clippy::result_large_err)]
pub fn prove_send_utxo_multiple_assets_one_receiver(
spent_utxos: Vec<UTXO>,
number_to_send: usize,
receiver: Address,
) -> Result<(Vec<UTXO>, Vec<UTXO>, Receipt), ExecutionFailureKind> {
if number_to_send > spent_utxos.len() {
return Err(ExecutionFailureKind::AmountMismatchError);
}
let mut builder = ExecutorEnv::builder();
let utxo_payload: Vec<UTXOPayload> = spent_utxos
.into_iter()
.map(|spent_utxo| spent_utxo.into_payload())
.collect();
builder
.write(&utxo_payload)
.map_err(ExecutionFailureKind::write_error)?;
builder
.write(&number_to_send)
.map_err(ExecutionFailureKind::write_error)?;
builder
.write(&receiver)
.map_err(ExecutionFailureKind::write_error)?;
let env = builder
.build()
.map_err(ExecutionFailureKind::builder_error)?;
let prover = default_prover();
let receipt = prover
.prove(env, test_methods::SEND_UTXO_MULTIPLE_ASSETS_ELF)
.map_err(ExecutionFailureKind::prove_error)?
.receipt;
let digest: (Vec<UTXOPayload>, Vec<UTXOPayload>) = receipt
.journal
.decode()
.map_err(|e| ExecutionFailureKind::DecodeError(e.to_string()))?;
Ok((
digest
.0
.into_iter()
.map(UTXO::create_utxo_from_payload)
.collect(),
digest
.1
.into_iter()
.map(UTXO::create_utxo_from_payload)
.collect(),
receipt,
))
}
#[allow(clippy::result_large_err)]
pub fn prove_send_utxo_shielded(
owner: Address,
amount: u128,
owners_parts: Vec<(u128, Address)>,
) -> Result<(Vec<(UTXO, Address)>, Receipt), ExecutionFailureKind> {
let cumulative_spent = owners_parts.iter().fold(0, |acc, item| acc + item.0);
if cumulative_spent != amount {
return Err(ExecutionFailureKind::AmountMismatchError);
}
let temp_utxo_to_spend = UTXO::new(*owner.value(), vec![], amount, true);
let utxo_payload = temp_utxo_to_spend.into_payload();
let mut builder = ExecutorEnv::builder();
builder
.write(&utxo_payload)
.map_err(ExecutionFailureKind::write_error)?;
let owners_parts_with_randomness = owners_parts
.into_iter()
.map(|(amount, addr)| {
let mut randomness = Randomness::default();
OsRng.fill_bytes(&mut randomness);
(amount, addr, randomness)
})
.collect::<Vec<_>>();
builder
.write(&owners_parts_with_randomness)
.map_err(ExecutionFailureKind::write_error)?;
let env = builder
.build()
.map_err(ExecutionFailureKind::builder_error)?;
let prover = default_prover();
let receipt = prover
.prove(env, test_methods::SEND_UTXO_ELF)
.map_err(ExecutionFailureKind::prove_error)?
.receipt;
let digest: Vec<(UTXOPayload, Address)> = receipt
.journal
.decode()
.map_err(|e| ExecutionFailureKind::DecodeError(e.to_string()))?;
Ok((
digest
.into_iter()
.map(|(payload, addr)| (UTXO::create_utxo_from_payload(payload), addr))
.collect(),
receipt,
))
}
#[allow(clippy::result_large_err)]
pub fn prove_send_utxo_deshielded(
spent_utxo: UTXO,
owners_parts: Vec<(u128, Address)>,
) -> Result<(Vec<(u128, Address)>, Receipt), ExecutionFailureKind> {
let cumulative_spent = owners_parts.iter().fold(0, |acc, item| acc + item.0);
if cumulative_spent != spent_utxo.amount {
return Err(ExecutionFailureKind::AmountMismatchError);
}
let mut builder = ExecutorEnv::builder();
let utxo_payload = spent_utxo.into_payload();
builder
.write(&utxo_payload)
.map_err(ExecutionFailureKind::write_error)?;
let owners_parts_with_randomness = owners_parts
.into_iter()
.map(|(amount, addr)| {
let mut randomness = Randomness::default();
OsRng.fill_bytes(&mut randomness);
(amount, addr, randomness)
})
.collect::<Vec<_>>();
builder
.write(&owners_parts_with_randomness)
.map_err(ExecutionFailureKind::write_error)?;
let env = builder
.build()
.map_err(ExecutionFailureKind::builder_error)?;
let prover = default_prover();
let receipt = prover
.prove(env, test_methods::SEND_UTXO_ELF)
.map_err(ExecutionFailureKind::prove_error)?
.receipt;
let digest: Vec<(UTXOPayload, Address)> = receipt
.journal
.decode()
.map_err(|e| ExecutionFailureKind::DecodeError(e.to_string()))?;
Ok((
digest
.into_iter()
.map(|(payload, addr)| (payload.amount, addr))
.collect(),
receipt,
))
}
#[allow(clippy::result_large_err)]
pub fn prove_mint_utxo_multiple_assets(
amount_to_mint: u128,
number_of_assets: usize,
owner: Address,
) -> Result<(Vec<UTXO>, Receipt), ExecutionFailureKind> {
let mut builder = ExecutorEnv::builder();
builder
.write(&amount_to_mint)
.map_err(ExecutionFailureKind::write_error)?;
builder
.write(&number_of_assets)
.map_err(ExecutionFailureKind::write_error)?;
builder
.write(&owner)
.map_err(ExecutionFailureKind::write_error)?;
let env = builder
.build()
.map_err(ExecutionFailureKind::builder_error)?;
let prover = default_prover();
let receipt = prover
.prove(env, test_methods::MINT_UTXO_MULTIPLE_ASSETS_ELF)
.map_err(ExecutionFailureKind::prove_error)?
.receipt;
let digest: Vec<UTXOPayload> = receipt
.journal
.decode()
.map_err(|e| ExecutionFailureKind::DecodeError(e.to_string()))?;
Ok((
digest
.into_iter()
.map(UTXO::create_utxo_from_payload)
.collect(),
receipt,
))
}
pub fn execute_mint_utxo(
amount_to_mint: u128,
owner: Address,
randomness: [u8; 32],
) -> anyhow::Result<UTXO> {
let mut builder = ExecutorEnv::builder();
builder.write(&amount_to_mint)?;
builder.write(owner.value())?;
builder.write(&randomness)?;
let env = builder.build()?;
let executor = default_executor();
let receipt = executor.execute(env, test_methods::MINT_UTXO_ELF)?;
let digest: UTXOPayload = receipt.journal.decode()?;
Ok(UTXO::create_utxo_from_payload(digest))
}
pub fn execute_send_utxo(
spent_utxo: UTXO,
owners_parts: Vec<(u128, Address)>,
) -> anyhow::Result<(UTXO, Vec<(UTXO, Address)>)> {
let mut builder = ExecutorEnv::builder();
let utxo_payload = spent_utxo.into_payload();
builder.write(&utxo_payload)?;
let owners_parts_with_randomness = owners_parts
.into_iter()
.map(|(amount, addr)| {
let mut randomness = Randomness::default();
OsRng.fill_bytes(&mut randomness);
(amount, *addr.value(), randomness)
})
.collect::<Vec<_>>();
builder.write(&owners_parts_with_randomness)?;
let env = builder.build()?;
let executor = default_executor();
let receipt = executor.execute(env, test_methods::SEND_UTXO_ELF)?;
let digest: (UTXOPayload, Vec<(UTXOPayload, Address)>) = receipt.journal.decode()?;
Ok((
UTXO::create_utxo_from_payload(digest.0),
digest
.1
.into_iter()
.map(|(payload, addr)| (UTXO::create_utxo_from_payload(payload), addr))
.collect(),
))
}
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)?;
}
let env = builder.build()?;
let prover = default_prover();
let receipt = prover.prove(env, elf)?.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],
) -> anyhow::Result<T> {
let mut builder = ExecutorEnv::builder();
for input in input_vec {
builder.write(&input)?;
}
let env = builder.build()?;
let exec = default_executor();
let session = exec.execute(env, elf)?;
// We read the result committed to the journal by the guest code.
let result: T = session.journal.decode()?;
Ok(result)
}
pub fn verify(receipt: Receipt, image_id: impl Into<Digest>) -> anyhow::Result<()> {
Ok(receipt.verify(image_id)?)
}
#[cfg(test)]
mod tests {
use crate::gas_calculator::GasCalculator;
use super::*;
use test_methods::BIG_CALCULATION_ELF;
use test_methods::{MULTIPLICATION_ELF, MULTIPLICATION_ID};
use test_methods::{SUMMATION_ELF, SUMMATION_ID};
#[test]
fn prove_simple_sum() {
let message = 1;
let message_2 = 2;
let (digest, receipt) = prove(vec![message, message_2], SUMMATION_ELF).unwrap();
verify(receipt, SUMMATION_ID).unwrap();
assert_eq!(digest, message + message_2);
}
#[test]
fn prove_bigger_sum() {
let message = 123476;
let message_2 = 2342384;
let (digest, receipt) = prove(vec![message, message_2], SUMMATION_ELF).unwrap();
verify(receipt, SUMMATION_ID).unwrap();
assert_eq!(digest, message + message_2);
}
#[test]
fn prove_simple_multiplication() {
let message = 1;
let message_2 = 2;
let (digest, receipt) = prove(vec![message, message_2], MULTIPLICATION_ELF).unwrap();
verify(receipt, MULTIPLICATION_ID).unwrap();
assert_eq!(digest, message * message_2);
}
#[test]
fn prove_bigger_multiplication() {
let message = 3498;
let message_2 = 438563;
let (digest, receipt) = prove(vec![message, message_2], MULTIPLICATION_ELF).unwrap();
verify(receipt, MULTIPLICATION_ID).unwrap();
assert_eq!(digest, message * message_2);
}
#[test]
fn execute_simple_sum() {
let message: u64 = 1;
let message_2: u64 = 2;
let result = execute(vec![message, message_2], SUMMATION_ELF).unwrap();
assert_eq!(result, message + message_2);
}
#[test]
fn execute_bigger_sum() {
let message: u64 = 123476;
let message_2: u64 = 2342384;
let result = execute(vec![message, message_2], SUMMATION_ELF).unwrap();
assert_eq!(result, message + message_2);
}
#[test]
fn execute_big_calculation() {
let message: u128 = 1;
let message_2: u128 = 2;
let result = execute(vec![message, message_2], BIG_CALCULATION_ELF).unwrap();
assert_eq!(result, big_calculation(message, message_2));
}
#[test]
fn execute_big_calculation_long() {
let message: u128 = 20;
let message_2: u128 = 10;
let result = execute(vec![message, message_2], BIG_CALCULATION_ELF).unwrap();
assert_eq!(result, big_calculation(message, message_2));
}
fn big_calculation(lhs: u128, rhs: u128) -> u128 {
let mut res = 1_u128;
for _ in 0..lhs {
res *= rhs;
res += lhs;
}
res
}
#[test]
fn test_gas_limits_check_sufficient_funds() {
let message = 1;
let message_2 = 2;
let gas_calc = GasCalculator::new(1, 1, 1, 1, 1, 1000000, 1000000);
let result = gas_limits_check(vec![message, message_2], SUMMATION_ELF, &gas_calc, 1000000);
assert!(result.is_ok());
}
#[test]
fn test_gas_limits_check_insufficient_funds() {
let message = 1;
let message_2 = 2;
let gas_calc = GasCalculator::new(1, 1, 1, 1, 1, 1000000, 1000000);
let result = gas_limits_check(vec![message, message_2], SUMMATION_ELF, &gas_calc, 1);
assert!(matches!(
result,
Err(ExecutionFailureKind::InsufficientFundsError)
));
}
#[test]
fn test_execute_mint_utxo() {
let owner = Address::default();
let amount = 123456789;
let mut randomness = [0u8; 32];
OsRng.fill_bytes(&mut randomness);
let utxo_exec = execute_mint_utxo(amount, owner, randomness).expect("execution failed");
assert_eq!(utxo_exec.amount, amount);
assert_eq!(utxo_exec.owner, *owner.value());
}
#[test]
fn test_prove_mint_utxo() {
let owner = Address::default();
let amount = 123456789;
let (utxo, _) = prove_mint_utxo(amount, owner).expect("proof failed");
assert_eq!(utxo.amount, amount);
assert_eq!(utxo.owner, *owner.value());
}
#[test]
fn test_prove_send_utxo() {
let owner = Address::default();
let amount = 100;
let (input_utxo, _) = prove_mint_utxo(amount, owner).expect("mint failed");
let parts = vec![(40, owner), (60, owner)];
let (outputs, _receipt) = prove_send_utxo(input_utxo, parts.clone()).expect("send failed");
let total: u128 = outputs.iter().map(|(utxo, _)| utxo.amount).sum();
assert_eq!(total, amount);
assert_eq!(outputs.len(), 2);
}
#[test]
fn test_prove_send_utxo_deshielded() {
let owner = Address::default();
let amount = 100;
let (utxo, _) = prove_mint_utxo(amount, owner).unwrap();
let parts = vec![(60, owner), (40, owner)];
let (outputs, _) = prove_send_utxo_deshielded(utxo, parts.clone()).unwrap();
let total: u128 = outputs.iter().map(|(amt, _)| amt).sum();
assert_eq!(total, amount);
assert_eq!(outputs.len(), 2);
}
#[test]
fn test_prove_send_utxo_shielded() {
let owner = Address::default();
let amount = 100;
let parts = vec![(60, owner), (40, owner)];
let (outputs, _) = prove_send_utxo_shielded(owner, amount, parts.clone()).unwrap();
let total: u128 = outputs.iter().map(|(utxo, _)| utxo.amount).sum();
assert_eq!(total, amount);
assert_eq!(outputs.len(), 2);
}
#[test]
fn test_prove_send_utxo_multiple_assets_one_receiver() {
let owner = Address::default();
let receiver = Address::default();
let utxos = vec![
prove_mint_utxo(100, owner).unwrap().0,
prove_mint_utxo(50, owner).unwrap().0,
];
let (to_receiver, to_change, _receipt) =
prove_send_utxo_multiple_assets_one_receiver(utxos, 1, receiver).unwrap();
let total_to_receiver: u128 = to_receiver.iter().map(|u| u.amount).sum();
assert!(total_to_receiver > 0);
assert_eq!(to_receiver.len() + to_change.len(), 2);
}
}

10
zkvm/test_methods/Cargo.toml
View File

@ -1,10 +0,0 @@
[package]
name = "test-methods"
version = "0.1.0"
edition = "2021"
[build-dependencies]
risc0-build = { version = "2.3.1" }
[package.metadata.risc0]
methods = ["guest"]

3
zkvm/test_methods/build.rs
View File

@ -1,3 +0,0 @@
fn main() {
risc0_build::embed_methods();
}

1348
zkvm/test_methods/guest/Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

14
zkvm/test_methods/guest/Cargo.toml
View File

@ -1,14 +0,0 @@
[package]
name = "test"
version = "0.1.0"
edition = "2021"
[workspace]
[dependencies]
serde_json = "1.0.81"
risc0-zkvm = { version = "2.3.1", default-features = false, features = ['std'] }
[dependencies.serde]
features = ["derive"]
version = "1.0.60"

14
zkvm/test_methods/guest/src/bin/big_calculation.rs
View File

@ -1,14 +0,0 @@
use risc0_zkvm::{
guest::env,
};
fn main() {
let lhs: u128 = env::read();
let rhs: u128 = env::read();
let mut res = 1;
for i in 0..lhs {
res *= rhs;
res += lhs;
}
env::commit(&(res));
}

32
zkvm/test_methods/guest/src/bin/mint_utxo.rs
View File

@ -1,32 +0,0 @@
use risc0_zkvm::{
guest::env,
};
use serde::{Deserialize, Serialize};
type AccountAddr = [u8; 32];
#[derive(Serialize, Deserialize)]
pub struct UTXOPayload {
pub owner: AccountAddr,
pub asset: Vec<u8>,
// TODO: change to u256
pub amount: u128,
pub privacy_flag: bool,
pub randomness: [u8; 32],
}
fn main() {
let amount_to_mint: u128 = env::read();
let owner: AccountAddr = env::read();
let randomness: [u8; 32] = env::read();
let payload = UTXOPayload {
owner,
asset: vec![],
amount: amount_to_mint,
privacy_flag: true,
randomness,
};
env::commit(&(payload));
}

39
zkvm/test_methods/guest/src/bin/mint_utxo_multiple_assets.rs
View File

@ -1,39 +0,0 @@
use risc0_zkvm::{
guest::env,
};
use serde::{Deserialize, Serialize};
type AccountAddr = [u8; 32];
#[derive(Serialize, Deserialize)]
pub struct UTXOPayload {
pub owner: AccountAddr,
pub asset: Vec<u8>,
// TODO: change to u256
pub amount: u128,
pub privacy_flag: bool,
pub randomness: [u8; 32],
}
fn main() {
let amount_to_mint: u128 = env::read();
let number_of_assets: usize = env::read();
let owner: AccountAddr = env::read();
let randomness: [u8; 32] = env::read();
let mut asseted_utxos = vec![];
for i in 0..number_of_assets {
let payload = UTXOPayload {
owner,
asset: vec![i as u8],
amount: amount_to_mint,
privacy_flag: true,
randomness
};
asseted_utxos.push(payload);
}
env::commit(&(asseted_utxos));
}

9
zkvm/test_methods/guest/src/bin/multiplication.rs
View File

@ -1,9 +0,0 @@
use risc0_zkvm::{
guest::env,
};
fn main() {
let lhs: u64 = env::read();
let rhs: u64 = env::read();
env::commit(&(lhs * rhs));
}

34
zkvm/test_methods/guest/src/bin/send_utxo.rs
View File

@ -1,34 +0,0 @@
use risc0_zkvm::{
guest::env,
};
use serde::{Deserialize, Serialize};
type AccountAddr = [u8; 32];
#[derive(Serialize, Deserialize)]
pub struct UTXOPayload {
pub owner: AccountAddr,
pub asset: Vec<u8>,
// TODO: change to u256
pub amount: u128,
pub privacy_flag: bool,
pub randomness: [u8; 32],
}
fn main() {
let utxo_spent: UTXOPayload = env::read();
let owners_parts: Vec<(u128, AccountAddr, [u8; 32])> = env::read();
let res: Vec<(UTXOPayload, AccountAddr)> = owners_parts.into_iter().map(|(amount, addr, randomness)| (
UTXOPayload {
owner: addr.clone(),
asset: vec![],
amount,
privacy_flag: true,
randomness,
},
addr
)).collect();
env::commit(&(res));
}

41
zkvm/test_methods/guest/src/bin/send_utxo_multiple_assets.rs
View File

@ -1,41 +0,0 @@
use risc0_zkvm::{
guest::env,
};
use serde::{Deserialize, Serialize};
type AccountAddr = [u8; 32];
#[derive(Clone, Serialize, Deserialize)]
pub struct UTXOPayload {
pub owner: AccountAddr,
pub asset: Vec<u8>,
// TODO: change to u256
pub amount: u128,
pub privacy_flag: bool,
pub randomness: [u8; 32],
}
fn main() {
let utxo_spent: Vec<UTXOPayload> = env::read();
let number_to_send = env::read();
let receiver: AccountAddr = env::read();
let mut utxo_received = vec![];
let mut utxo_not_spent = vec![];
for i in 0..utxo_spent.len() {
let mut utxo_payload = utxo_spent[i].clone();
if i < number_to_send {
utxo_payload.owner = receiver;
utxo_received.push(utxo_payload);
} else {
utxo_payload.asset.push(0);
utxo_not_spent.push(utxo_payload);
}
}
env::commit(&(utxo_received, utxo_not_spent));
}

9
zkvm/test_methods/guest/src/bin/summation.rs
View File

@ -1,9 +0,0 @@
use risc0_zkvm::{
guest::env,
};
fn main() {
let data: u64 = env::read();
let data_2: u64 = env::read();
env::commit(&(data + data_2));
}

1
zkvm/test_methods/src/lib.rs
View File

@ -1 +0,0 @@
include!(concat!(env!("OUT_DIR"), "/methods.rs"));