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

minor refactor

Browse Source
This commit is contained in:
Sergio Chouhy 2025-08-22 13:42:37 -03:00
parent 75211903d7
commit d00c551027
3 changed files with 65 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
nssa/src/merkle_tree/mod.rs
View File

@ -124,13 +124,13 @@ impl MerkleTree {
true
}
pub fn new(values: Vec<Value>) -> Self {
let mut deduplicated_values = Vec::with_capacity(values.len());
pub fn new(values: &[Value]) -> Self {
let mut deduplicated_values: Vec<Value> = Vec::with_capacity(values.len());
let mut seen = HashSet::new();
for value in values.into_iter() {
if !seen.contains(&value) {
deduplicated_values.push(value);
seen.insert(value);
if !seen.contains(value) {
deduplicated_values.push(*value);
seen.insert(*value);
}
}
let mut this = Self::with_capacity(deduplicated_values.len());
@ -191,8 +191,8 @@ mod tests {
#[test]
fn test_merkle_tree_1() {
let values = vec![[1; 32], [2; 32], [3; 32], [4; 32]];
let tree = MerkleTree::new(values.clone());
let values = [[1; 32], [2; 32], [3; 32], [4; 32]];
let tree = MerkleTree::new(&values);
let expected_root = [
72, 199, 63, 120, 33, 165, 138, 141, 42, 112, 62, 91, 57, 197, 113, 192, 170, 32, 207,
20, 171, 205, 10, 248, 242, 185, 85, 188, 32, 41, 152, 222,
@ -208,8 +208,8 @@ mod tests {
#[test]
fn test_merkle_tree_2() {
let values = vec![[1; 32], [2; 32], [3; 32], [0; 32]];
let tree = MerkleTree::new(values.clone());
let values = [[1; 32], [2; 32], [3; 32], [0; 32]];
let tree = MerkleTree::new(&values);
let expected_root = [
201, 187, 184, 48, 150, 223, 133, 21, 122, 20, 110, 125, 119, 4, 85, 169, 132, 18, 222,
224, 99, 49, 135, 238, 134, 254, 230, 200, 164, 91, 131, 26,
@ -225,8 +225,8 @@ mod tests {
#[test]
fn test_merkle_tree_3() {
let values = vec![[1; 32], [2; 32], [3; 32]];
let tree = MerkleTree::new(values.clone());
let values = [[1; 32], [2; 32], [3; 32]];
let tree = MerkleTree::new(&values);
let expected_root = [
200, 211, 216, 210, 177, 63, 39, 206, 236, 205, 198, 153, 17, 152, 113, 249, 243, 46,
167, 237, 134, 255, 69, 208, 173, 17, 247, 123, 40, 205, 117, 104,
@ -242,8 +242,8 @@ mod tests {
#[test]
fn test_merkle_tree_4() {
let values = vec![[11; 32], [12; 32], [13; 32], [14; 32], [15; 32]];
let tree = MerkleTree::new(values.clone());
let values = [[11; 32], [12; 32], [13; 32], [14; 32], [15; 32]];
let tree = MerkleTree::new(&values);
let expected_root = [
239, 65, 138, 237, 90, 162, 7, 2, 212, 217, 76, 146, 218, 121, 164, 1, 47, 46, 54, 241,
0, 139, 253, 179, 205, 30, 56, 116, 157, 202, 36, 153,
@ -260,11 +260,11 @@ mod tests {
#[test]
fn test_merkle_tree_5() {
let values = vec![
let values = [
[11; 32], [12; 32], [12; 32], [13; 32], [14; 32], [15; 32], [15; 32], [13; 32],
[13; 32], [15; 32], [11; 32],
];
let tree = MerkleTree::new(values);
let tree = MerkleTree::new(&values);
let expected_root = [
239, 65, 138, 237, 90, 162, 7, 2, 212, 217, 76, 146, 218, 121, 164, 1, 47, 46, 54, 241,
0, 139, 253, 179, 205, 30, 56, 116, 157, 202, 36, 153,
@ -281,8 +281,8 @@ mod tests {
#[test]
fn test_merkle_tree_6() {
let values = vec![[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
let tree = MerkleTree::new(values);
let values = [[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
let tree = MerkleTree::new(&values);
let expected_root = [
6, 156, 184, 37, 154, 6, 254, 110, 219, 63, 167, 255, 121, 51, 166, 221, 125, 202, 111,
202, 41, 147, 20, 55, 151, 148, 166, 136, 146, 108, 55, 146,
@ -328,7 +328,7 @@ mod tests {
fn test_with_capacity_6() {
let mut tree = MerkleTree::with_capacity(100);
let values = vec![[1; 32], [2; 32], [3; 32], [4; 32]];
let values = [[1; 32], [2; 32], [3; 32], [4; 32]];
let expected_root = [
72, 199, 63, 120, 33, 165, 138, 141, 42, 112, 62, 91, 57, 197, 113, 192, 170, 32, 207,
@ -347,7 +347,7 @@ mod tests {
fn test_with_capacity_7() {
let mut tree = MerkleTree::with_capacity(599);
let values = vec![[1; 32], [2; 32], [3; 32]];
let values = [[1; 32], [2; 32], [3; 32]];
let expected_root = [
200, 211, 216, 210, 177, 63, 39, 206, 236, 205, 198, 153, 17, 152, 113, 249, 243, 46,
@ -365,7 +365,7 @@ mod tests {
fn test_with_capacity_8() {
let mut tree = MerkleTree::with_capacity(1);
let values = vec![[1; 32], [2; 32], [3; 32]];
let values = [[1; 32], [2; 32], [3; 32]];
let expected_root = [
200, 211, 216, 210, 177, 63, 39, 206, 236, 205, 198, 153, 17, 152, 113, 249, 243, 46,
@ -383,8 +383,8 @@ mod tests {
fn test_insert_value_1() {
let mut tree = MerkleTree::with_capacity(1);
let values = vec![[1; 32], [2; 32], [3; 32]];
let expected_tree = MerkleTree::new(values.clone());
let values = [[1; 32], [2; 32], [3; 32]];
let expected_tree = MerkleTree::new(&values);
tree.insert(values[0]);
tree.insert(values[1]);
@ -397,8 +397,8 @@ mod tests {
fn test_insert_value_2() {
let mut tree = MerkleTree::with_capacity(1);
let values = vec![[1; 32], [2; 32], [3; 32], [4; 32]];
let expected_tree = MerkleTree::new(values.clone());
let values = [[1; 32], [2; 32], [3; 32], [4; 32]];
let expected_tree = MerkleTree::new(&values);
tree.insert(values[0]);
tree.insert(values[1]);
@ -412,8 +412,8 @@ mod tests {
fn test_insert_value_3() {
let mut tree = MerkleTree::with_capacity(1);
let values = vec![[11; 32], [12; 32], [13; 32], [14; 32], [15; 32]];
let expected_tree = MerkleTree::new(values.clone());
let values = [[11; 32], [12; 32], [13; 32], [14; 32], [15; 32]];
let expected_tree = MerkleTree::new(&values);
tree.insert(values[0]);
tree.insert(values[1]);
@ -428,8 +428,8 @@ mod tests {
fn test_insert_value_4() {
let mut tree = MerkleTree::with_capacity(1);
let values = vec![[11; 32], [12; 32], [13; 32], [14; 32], [15; 32]];
let expected_tree = MerkleTree::new(values.clone());
let values = [[11; 32], [12; 32], [13; 32], [14; 32], [15; 32]];
let expected_tree = MerkleTree::new(&values);
tree.insert(values[0]);
tree.insert(values[0]);
@ -448,8 +448,8 @@ mod tests {
#[test]
fn test_authentication_path_1() {
let values = vec![[1; 32], [2; 32], [3; 32], [4; 32]];
let tree = MerkleTree::new(values);
let values = [[1; 32], [2; 32], [3; 32], [4; 32]];
let tree = MerkleTree::new(&values);
let expected_authentication_path = (
2,
vec![
@ -470,8 +470,8 @@ mod tests {
#[test]
fn test_authentication_path_2() {
let values = vec![[1; 32], [2; 32], [3; 32]];
let tree = MerkleTree::new(values);
let values = [[1; 32], [2; 32], [3; 32]];
let tree = MerkleTree::new(&values);
let expected_authentication_path = (
0,
vec![
@ -492,8 +492,8 @@ mod tests {
#[test]
fn test_authentication_path_3() {
let values = vec![[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
let tree = MerkleTree::new(values);
let values = [[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
let tree = MerkleTree::new(&values);
let expected_authentication_path = (
4,
vec![
@ -518,8 +518,8 @@ mod tests {
#[test]
fn test_authentication_path_4() {
let values = vec![[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
let tree = MerkleTree::new(values);
let values = [[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
let tree = MerkleTree::new(&values);
let value = [6; 32];
assert!(tree.get_authentication_path_for(&value).is_none());
}
@ -527,15 +527,15 @@ mod tests {
#[test]
fn test_authentication_path_5() {
let values = vec![[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
let tree = MerkleTree::new(values);
let tree = MerkleTree::new(&values);
let value = [0; 32];
assert!(tree.get_authentication_path_for(&value).is_none());
}
#[test]
fn test_authentication_path_6() {
let values = vec![[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
let tree = MerkleTree::new(values);
let values = [[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
let tree = MerkleTree::new(&values);
let value = [5; 32];
let (index, path) = tree.get_authentication_path_for(&value).unwrap();
assert!(verify_authentication_path(

31
nssa/src/privacy_preserving_transaction/circuit.rs
View File

@ -105,7 +105,10 @@ mod tests {
merkle_tree::MerkleTree,
privacy_preserving_transaction::circuit::{Proof, execute_and_prove},
program::Program,
state::CommitmentSet,
state::{
CommitmentSet,
tests::{test_private_account_keys_1, test_private_account_keys_2},
},
};
use rand::{Rng, RngCore, rngs::OsRng};
@ -163,7 +166,7 @@ mod tests {
#[test]
fn prove_privacy_preserving_execution_circuit_fully_private() {
let sender = AccountWithMetadata {
let sender_pre = AccountWithMetadata {
account: Account {
balance: 100,
nonce: 0xdeadbeef,
@ -171,18 +174,16 @@ mod tests {
},
is_authorized: true,
};
let private_key_1 = [1; 32];
let Npk1 = NullifierPublicKey::from(&private_key_1);
let commitment_sender = Commitment::new(&Npk1, &sender.account);
let sender_keys = test_private_account_keys_1();
let recipient_keys = test_private_account_keys_2();
let commitment_sender = Commitment::new(&sender_keys.npk(), &sender_pre.account);
let recipient = AccountWithMetadata {
account: Account::default(),
is_authorized: false,
};
let Npk2 = NullifierPublicKey::from(&[99; 32]);
let balance_to_move: u128 = 37;
let commitment_set =
CommitmentSet(MerkleTree::new(vec![commitment_sender.to_byte_array()]));
let commitment_set = CommitmentSet(MerkleTree::new(&[commitment_sender.to_byte_array()]));
let program = Program::authenticated_transfer_program();
let expected_private_account_1 = Account {
@ -198,22 +199,22 @@ mod tests {
..Default::default()
};
let expected_new_commitments = vec![
Commitment::new(&Npk1, &expected_private_account_1),
Commitment::new(&Npk2, &expected_private_account_2),
Commitment::new(&sender_keys.npk(), &expected_private_account_1),
Commitment::new(&recipient_keys.npk(), &expected_private_account_2),
];
let expected_new_nullifiers = vec![Nullifier::new(&commitment_sender, &private_key_1)];
let expected_new_nullifiers = vec![Nullifier::new(&commitment_sender, &sender_keys.nsk)];
let (output, proof) = execute_and_prove(
&[sender.clone(), recipient],
&[sender_pre.clone(), recipient],
&Program::serialize_instruction(balance_to_move).unwrap(),
&[1, 2],
&[0xdeadbeef1, 0xdeadbeef2],
&[
(Npk1.clone(), [2; 32], [3; 32]),
(Npk2.clone(), [4; 32], [5; 32]),
(sender_keys.npk(), sender_keys.ivk, [3; 32]),
(recipient_keys.npk(), recipient_keys.ivk, [5; 32]),
],
&[(
private_key_1,
sender_keys.nsk,
commitment_set.get_proof_for(&commitment_sender).unwrap(),
)],
&program,

20
nssa/src/state.rs
View File

@ -22,7 +22,7 @@ impl CommitmentSet {
.get_authentication_path_for(&commitment.to_byte_array())
}
fn extend(&mut self, commitments: &[Commitment]) {
pub(crate) fn extend(&mut self, commitments: &[Commitment]) {
for commitment in commitments {
self.0.insert(commitment.to_byte_array());
}
@ -693,12 +693,12 @@ pub mod tests {
assert!(matches!(result, Err(NssaError::InvalidProgramBehavior)));
}
struct TestPublicKeys {
signing_key: PrivateKey,
pub struct TestPublicKeys {
pub signing_key: PrivateKey,
}
impl TestPublicKeys {
fn address(&self) -> Address {
pub fn address(&self) -> Address {
Address::from(&PublicKey::new_from_private_key(&self.signing_key))
}
}
@ -709,25 +709,25 @@ pub mod tests {
}
}
struct TestPrivateKeys {
nsk: NullifierSecretKey,
ivk: IncomingViewingPublicKey,
pub struct TestPrivateKeys {
pub nsk: NullifierSecretKey,
pub ivk: IncomingViewingPublicKey,
}
impl TestPrivateKeys {
fn npk(&self) -> NullifierPublicKey {
pub fn npk(&self) -> NullifierPublicKey {
NullifierPublicKey::from(&self.nsk)
}
}
fn test_private_account_keys_1() -> TestPrivateKeys {
pub fn test_private_account_keys_1() -> TestPrivateKeys {
TestPrivateKeys {
nsk: [13; 32],
ivk: [31; 32],
}
}
fn test_private_account_keys_2() -> TestPrivateKeys {
pub fn test_private_account_keys_2() -> TestPrivateKeys {
TestPrivateKeys {
nsk: [38; 32],
ivk: [83; 32],