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

rename input visibility to account visibility

Browse Source
This commit is contained in:
Sergio Chouhy 2025-07-19 17:02:26 -03:00
parent 54927ddd70
commit 8482a1b182
9 changed files with 38 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
risc0-selective-privacy-poc/core/src/visibility.rs
View File

@ -2,7 +2,7 @@ use crate::types::{AuthenticationPath, Key};
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize)]
pub enum InputVisibiility {
pub enum AccountVisibility {
// A public account
Public,
// A private account

4
risc0-selective-privacy-poc/examples/happy_path.rs
View File

@ -1,4 +1,4 @@
use core::{bytes_to_words, types::Address, visibility::InputVisibiility};
use core::{bytes_to_words, types::Address, visibility::AccountVisibility};
use nssa::program::PinataProgram;
@ -60,7 +60,7 @@ fn main() {
// All of this is executed locally by the User1
let pinata_account = sequencer.get_account(&PINATA_ADDRESS).unwrap();
let receiver_account = MockedClient::fresh_account_for_mint(USER_CLIENTS[1].user_address());
let visibilities = [InputVisibiility::Public, InputVisibiility::Private(None)];
let visibilities = [AccountVisibility::Public, AccountVisibility::Private(None)];
let preimage = bytes_to_words(b"NSSA Selective privacy is great!").to_vec();
let private_outputs = MockedClient::prove_and_send_to_sequencer::<PinataProgram>(

4
risc0-selective-privacy-poc/examples/mocked_components/client/mod.rs
View File

@ -2,7 +2,7 @@ use crate::mocked_components::sequencer::MockedSequencer;
use core::{
account::Account,
types::{Address, Key},
visibility::InputVisibiility,
visibility::AccountVisibility,
};
pub mod transfer_deshielded;
@ -29,7 +29,7 @@ impl MockedClient {
pub fn prove_and_send_to_sequencer<P: nssa::Program>(
input_accounts: &[Account],
instruction_data: P::InstructionData,
visibilities: &[InputVisibiility],
visibilities: &[AccountVisibility],
commitment_tree_root: [u32; 8],
sequencer: &mut MockedSequencer,
) -> Result<Vec<Account>, ()> {

8
risc0-selective-privacy-poc/examples/mocked_components/client/transfer_deshielded.rs
View File

@ -1,6 +1,6 @@
use core::account::Account;
use core::types::Address;
use core::visibility::InputVisibiility;
use core::visibility::AccountVisibility;
use nssa::program::TransferProgram;
@ -24,11 +24,11 @@ impl MockedClient {
// Fetch public account to deshield to
let to_account = sequencer.get_account(&to_address).unwrap();
// Set input visibilities
// Set account visibilities
// First entry is the private sender. Second entry is the public receiver
let visibilities = vec![
InputVisibiility::Private(Some((self.user_private_key, sender_commitment_auth_path))),
InputVisibiility::Public,
AccountVisibility::Private(Some((self.user_private_key, sender_commitment_auth_path))),
AccountVisibility::Public,
];
// Execute privately (off-chain) and submit it to the sequencer

6
risc0-selective-privacy-poc/examples/mocked_components/client/transfer_private.rs
View File

@ -1,6 +1,6 @@
use core::account::Account;
use core::types::Address;
use core::visibility::InputVisibiility;
use core::visibility::AccountVisibility;
use nssa::program::TransferProgram;
@ -26,8 +26,8 @@ impl MockedClient {
// Set visibilities. Both private accounts.
let visibilities = vec![
InputVisibiility::Private(Some((self.user_private_key, sender_commitment_auth_path))),
InputVisibiility::Private(None),
AccountVisibility::Private(Some((self.user_private_key, sender_commitment_auth_path))),
AccountVisibility::Private(None),
];
// Execute privately (off-chain) and submit it to the sequencer

6
risc0-selective-privacy-poc/examples/mocked_components/client/transfer_shielded.rs
View File

@ -1,6 +1,6 @@
use core::account::Account;
use core::types::Address;
use core::visibility::InputVisibiility;
use core::visibility::AccountVisibility;
use nssa::program::TransferProgram;
@ -24,10 +24,10 @@ impl MockedClient {
// Create a new default private account for the receiver
let to_account = Self::fresh_account_for_mint(*to_address);
// Set input visibilities
// Set account visibilities
// First is the public account of the sender. Second is the private account minted in this
// execution
let visibilities = [InputVisibiility::Public, InputVisibiility::Private(None)];
let visibilities = [AccountVisibility::Public, AccountVisibility::Private(None)];
// Execute privately (off-chain) and submit it to the sequencer
let private_outputs = Self::prove_and_send_to_sequencer::<TransferProgram>(

10
risc0-selective-privacy-poc/examples/private_execution.rs
View File

@ -2,7 +2,7 @@ use core::{
account::Account,
bytes_to_words,
types::{Address, AuthenticationPath, Commitment, Nullifier},
visibility::InputVisibiility,
visibility::AccountVisibility,
};
use nssa::program::TransferMultipleProgram;
use sparse_merkle_tree::SparseMerkleTree;
@ -38,11 +38,11 @@ fn main() {
let receiver_address_2 = [100; 8];
let receiver_2 = new_default_account(receiver_address_2);
// Setup input visibilites. All accounts are private for this execution.
// Setup input account visibilites. All accounts are private for this execution.
let visibilities = vec![
InputVisibiility::Private(Some((sender_private_key, auth_path))),
InputVisibiility::Private(None),
InputVisibiility::Private(None),
AccountVisibility::Private(Some((sender_private_key, auth_path))),
AccountVisibility::Private(None),
AccountVisibility::Private(None),
];
// Set the balances to be sent to the two receiver addresses.

28
risc0-selective-privacy-poc/program_methods/guest/src/bin/outer.rs
View File

@ -2,7 +2,7 @@ use core::{
account::Account,
compute_nullifier, hash, is_in_tree,
types::{Nonce, ProgramId},
visibility::InputVisibiility,
visibility::AccountVisibility,
};
use risc0_zkvm::{guest::env, serde::to_vec};
@ -14,7 +14,7 @@ use risc0_zkvm::{guest::env, serde::to_vec};
/// - Vec<Account>: The output of the inner program. This is assumed to include the accounts pre and
/// post-states of the execution of the inner program.
///
/// - Vec<InputVisibility>: A vector indicating which accounts are private and which are public.
/// - Vec<AccountVisibility>: A vector indicating which accounts are private and which are public.
///
/// - Vec<Nonce>: The vector of nonces to be used for the output accounts. This is assumed to be
/// sampled at random by the host program.
@ -35,8 +35,8 @@ fn main() {
assert_eq!(inputs_outputs.len() as u32, num_inputs * 2);
// Read visibilities
let input_visibilities: Vec<InputVisibiility> = env::read();
assert_eq!(input_visibilities.len() as u32, num_inputs);
let account_visibilities: Vec<AccountVisibility> = env::read();
assert_eq!(account_visibilities.len() as u32, num_inputs);
// Read nonces for outputs
let output_nonces: Vec<Nonce> = env::read();
@ -57,9 +57,9 @@ fn main() {
};
let mut nullifiers = Vec::new();
for (visibility, input_account) in input_visibilities.iter().zip(inputs.iter()) {
for (visibility, input_account) in account_visibilities.iter().zip(inputs.iter()) {
match visibility {
InputVisibiility::Private(Some((private_key, auth_path))) => {
AccountVisibility::Private(Some((private_key, auth_path))) => {
// Prove ownership of input accounts by proving knowledge of the pre-image of their addresses.
assert_eq!(hash(private_key), input_account.address);
// Check the input account was created by a previous transaction by checking it belongs to the commitments tree.
@ -69,14 +69,14 @@ fn main() {
let nullifier = compute_nullifier(&commitment, private_key);
nullifiers.push(nullifier);
}
InputVisibiility::Private(None) => {
AccountVisibility::Private(None) => {
// Private accounts without a companion private key are enforced to have default values
// Used for executions that need to create a new private account.
assert_eq!(input_account.balance, 0);
assert_eq!(input_account.nonce, [0; 8]);
}
// No checks on public accounts
InputVisibiility::Public => continue,
AccountVisibility::Public => continue,
}
}
@ -101,10 +101,10 @@ fn main() {
// Compute commitments for every private output
let mut private_outputs = Vec::new();
for (output, visibility) in outputs.iter().zip(input_visibilities.iter()) {
for (output, visibility) in outputs.iter().zip(account_visibilities.iter()) {
match visibility {
InputVisibiility::Public => continue,
InputVisibiility::Private(_) => private_outputs.push(output),
AccountVisibility::Public => continue,
AccountVisibility::Private(_) => private_outputs.push(output),
}
}
let private_output_commitments: Vec<_> = private_outputs.iter().map(|account| account.commitment()).collect();
@ -114,13 +114,13 @@ fn main() {
for (account, visibility) in inputs
.iter()
.chain(outputs.iter())
.zip(input_visibilities.iter().chain(input_visibilities.iter()))
.zip(account_visibilities.iter().chain(account_visibilities.iter()))
{
match visibility {
InputVisibiility::Public => {
AccountVisibility::Public => {
public_inputs_outputs.push(account);
}
InputVisibiility::Private(_) => continue,
AccountVisibility::Private(_) => continue,
}
}

8
risc0-selective-privacy-poc/src/lib.rs
View File

@ -1,7 +1,7 @@
use core::{
account::Account,
types::{Commitment, Nonce, Nullifier},
visibility::InputVisibiility,
visibility::AccountVisibility,
};
use program_methods::{OUTER_ELF, OUTER_ID};
use rand::{rngs::OsRng, Rng};
@ -55,7 +55,7 @@ fn execute_and_prove_inner<P: Program>(
fn build_private_outputs_from_inner_results(
inputs_outputs: &[Account],
num_inputs: usize,
visibilities: &[InputVisibiility],
visibilities: &[AccountVisibility],
nonces: &[Nonce],
) -> Vec<Account> {
inputs_outputs
@ -63,7 +63,7 @@ fn build_private_outputs_from_inner_results(
.skip(num_inputs)
.zip(visibilities)
.zip(nonces)
.filter(|((_, visibility), _)| matches!(visibility, InputVisibiility::Private(_)))
.filter(|((_, visibility), _)| matches!(visibility, AccountVisibility::Private(_)))
.map(|((account, _), nonce)| {
let mut this = account.clone();
this.nonce = *nonce;
@ -99,7 +99,7 @@ pub fn execute_onchain<P: Program>(
pub fn execute_offchain<P: Program>(
inputs: &[Account],
instruction_data: P::InstructionData,
visibilities: &[InputVisibiility],
visibilities: &[AccountVisibility],
commitment_tree_root: [u32; 8],
) -> Result<(Receipt, Vec<Account>), ()> {
// Prove inner program and get post state of the accounts