fix: update 1

2026-08-25 14:51:14 +00:00 · 2024-12-22 16:14:52 +02:00
parent 7845af0fc8
commit 52a3ff9cbf
11 changed files with 689 additions and 48 deletions
@@ -1,2 +1,3 @@
-mod de;
-mod se;
+pub mod de;
+pub mod private_exec;
+pub mod se;
@@ -0,0 +1,141 @@
+use bincode;
+use k256::Scalar;
+use monotree::hasher::Blake3;
+use monotree::{Hasher, Monotree, Proof};
+use rand::thread_rng;
+use secp256k1_zkp::{
+    compute_adaptive_blinding_factor, verify_commitments_sum_to_equal, CommitmentSecrets,
+    Generator, PedersenCommitment, Tag, Tweak, SECP256K1,
+};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use storage::{
+    commitment::Commitment, commitments_sparse_merkle_tree::CommitmentsSparseMerkleTree,
+    nullifier::UTXONullifier, nullifier_sparse_merkle_tree::NullifierSparseMerkleTree,
+};
+use utxo::{
+    utxo_core::{UTXOPayload, UTXO},
+    utxo_tree::UTXOSparseMerkleTree,
+};
+
+fn hash(input: &[u8]) -> Vec<u8> {
+    Sha256::digest(input).to_vec()
+}
+
+// Generate nullifiers
+
+// takes the input_utxo and nsk
+// returns the nullifiers[i], where the nullifier[i] = hash(in_commitments[i] || nsk) where the hash function
+pub fn generate_nullifiers(input_utxo: &UTXO, nsk: &[u8]) -> Vec<u8> {
+    let mut input = bincode::serialize(input_utxo).unwrap().to_vec();
+    input.extend_from_slice(nsk);
+    hash(&input)
+}
+
+// Generate commitments for output UTXOs
+
+//  uses the list of input_utxos[]
+//  returns in_commitments[] where each in_commitments[i] = Commitment(in_utxos[i]) where the commitment
+pub fn generate_commitments(input_utxos: &[UTXO]) -> Vec<Vec<u8>> {
+    input_utxos
+        .iter()
+        .map(|utxo| {
+            let serialized = bincode::serialize(utxo).unwrap(); // Serialize UTXO.
+            hash(&serialized)
+        })
+        .collect()
+}
+
+// Validate inclusion proof for in_commitments
+
+// takes the in_commitments[i] as a leaf, the root hash root_commitment and the path in_commitments_proofs[i][],
+// returns True if the in_commitments[i] is in the tree with root hash root_commitment otherwise returns False, as membership proof.
+pub fn validate_in_commitments_proof(
+    in_commitment: &Vec<u8>,
+    root_commitment: Vec<u8>,
+    in_commitments_proof: &[Vec<u8>],
+) -> bool {
+    // Placeholder implementation.
+    // Replace with Merkle proof verification logic.
+    // hash(&[pedersen_commitment.serialize().to_vec(), in_commitments_proof.concat()].concat()) == root_commitment
+
+    let mut nsmt = CommitmentsSparseMerkleTree {
+        curr_root: Option::Some(root_commitment),
+        tree: Monotree::default(),
+        hasher: Blake3::new(),
+    };
+
+    let commitments: Vec<_> = in_commitments_proof
+        .into_iter()
+        .map(|n_p| Commitment {
+            commitment_hash: n_p.clone(),
+        })
+        .collect();
+    nsmt.insert_items(commitments).unwrap();
+
+    nsmt.get_non_membership_proof(in_commitment.clone())
+        .unwrap()
+        .1
+        .is_some()
+}
+
+// Validate non-membership proof for nullifiers
+
+// takes the nullifiers[i], path nullifiers_proof[i][] and the root hash root_nullifier,
+// returns True if the nullifiers[i] is not in the tree with root hash root_nullifier otherwise returns False, as non-membership proof.
+pub fn validate_nullifiers_proof(
+    nullifier: [u8; 32],
+    root_nullifier: [u8; 32],
+    nullifiers_proof: &[[u8; 32]],
+) -> bool {
+    let mut nsmt = NullifierSparseMerkleTree {
+        curr_root: Option::Some(root_nullifier),
+        tree: Monotree::default(),
+        hasher: Blake3::new(),
+    };
+
+    let nullifiers: Vec<_> = nullifiers_proof
+        .into_iter()
+        .map(|n_p| UTXONullifier { utxo_hash: *n_p })
+        .collect();
+    nsmt.insert_items(nullifiers).unwrap();
+
+    nsmt.get_non_membership_proof(nullifier)
+        .unwrap()
+        .1
+        .is_none()
+}
+
+fn private_kernel(
+    root_commitment: &[u8],
+    root_nullifier: [u8; 32],
+    input_utxos: &[UTXO],
+    in_commitments_proof: &[Vec<u8>],
+    nullifiers_proof: &[[u8; 32]],
+    nullifier_secret_key: Scalar,
+) -> (Vec<u8>, Vec<Vec<u8>>) {
+    let nullifiers: Vec<_> = input_utxos
+        .into_iter()
+        .map(|utxo| generate_nullifiers(&utxo, &nullifier_secret_key.to_bytes()))
+        .collect();
+
+    let in_commitments = generate_commitments(&input_utxos);
+
+    for in_commitment in in_commitments {
+        validate_in_commitments_proof(
+            &in_commitment,
+            root_commitment.to_vec(),
+            in_commitments_proof,
+        );
+    }
+
+    for nullifier in nullifiers.iter() {
+        validate_nullifiers_proof(
+            nullifier[0..32].try_into().unwrap(),
+            root_nullifier,
+            nullifiers_proof,
+        );
+    }
+
+    (vec![], nullifiers)
+}
@@ -1,24 +1,63 @@
-use std::sync::{
-    atomic::{AtomicU64, Ordering},
-    Arc,
+use std::{
+    collections::HashMap,
+    sync::{
+        atomic::{AtomicU64, Ordering},
+        Arc,
+    },
 };

-use accounts::account_core::Account;
+use ::storage::transaction::{Transaction, TransactionPayload, TxKind};
+use accounts::account_core::{Account, AccountAddress};
 use anyhow::Result;
 use config::NodeConfig;
-use sequencer_client::SequencerClient;
+use executions::{
+    private_exec::{generate_commitments, generate_nullifiers},
+    se::{commit, tag_random},
+};
+use rand::thread_rng;
+use secp256k1_zkp::{CommitmentSecrets, Tweak};
+use sequencer_client::{json::SendTxResponse, SequencerClient};
+use serde::{Deserialize, Serialize};
 use storage::NodeChainStore;
 use tokio::{sync::Mutex, task::JoinHandle};
+use utxo::utxo_core::UTXO;
+use zkvm::{
+    prove_mint_utxo, prove_send_utxo, prove_send_utxo_deshielded, prove_send_utxo_shielded,
+};

 pub mod config;
 pub mod executions;
 pub mod sequencer_client;
 pub mod storage;

+#[derive(Debug, Serialize, Deserialize)]
+pub struct MintMoneyPublicTx {
+    pub acc: AccountAddress,
+    pub amount: u128,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SendMoneyShieldedTx {
+    pub acc_sender: AccountAddress,
+    pub amount: u128,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SendMoneyDeshieldedTx {
+    pub receiver_data: Vec<(u128, AccountAddress)>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum ActionData {
+    MintMoneyPublicTx(MintMoneyPublicTx),
+    SendMoneyShieldedTx(SendMoneyShieldedTx),
+    SendMoneyDeshieldedTx(SendMoneyDeshieldedTx),
+}
+
 pub struct NodeCore {
    pub storage: Arc<Mutex<NodeChainStore>>,
    pub curr_height: Arc<AtomicU64>,
-    pub main_acc: Account,
+    pub acc_map: HashMap<AccountAddress, Account>,
    pub node_config: NodeConfig,
    pub db_updater_handle: JoinHandle<Result<()>>,
    pub sequencer_client: Arc<SequencerClient>,
@@ -33,7 +72,7 @@ impl NodeCore {

        let mut storage = NodeChainStore::new_with_genesis(&config.home, genesis_block);

-        let account = Account::new();
+        let account_map = HashMap::new();

        let mut chain_height = genesis_id.genesis_id;

@@ -81,10 +120,299 @@ impl NodeCore {
        Ok(Self {
            storage: wrapped_storage,
            curr_height: chain_height_wrapped,
-            main_acc: account,
+            acc_map: account_map,
            node_config: config.clone(),
            db_updater_handle: updater_handle,
            sequencer_client: client.clone(),
        })
    }
+
+    pub fn mint_utxo_private(&self, acc: AccountAddress, amount: u128) -> Transaction {
+        let (utxo, receipt) = prove_mint_utxo(amount, acc);
+
+        let accout = self.acc_map.get(&acc).unwrap();
+
+        let encoded_data = Account::encrypt_data(
+            &accout.produce_ephemeral_key_holder(),
+            accout.key_holder.viewing_public_key,
+            &serde_json::to_vec(&utxo).unwrap(),
+        );
+
+        let comm = generate_commitments(&vec![utxo]);
+
+        TransactionPayload {
+            tx_kind: TxKind::Private,
+            execution_input: vec![],
+            execution_output: vec![],
+            utxo_commitments_spent_hashes: vec![],
+            utxo_commitments_created_hashes: comm
+                .into_iter()
+                .map(|hash_data| hash_data.try_into().unwrap())
+                .collect(),
+            nullifier_created_hashes: vec![],
+            execution_proof_private: serde_json::to_string(&receipt).unwrap(),
+            encoded_data: vec![(encoded_data.0, encoded_data.1.to_vec())],
+        }
+        .into()
+    }
+
+    pub fn deposit_money_public(&self, acc: AccountAddress, amount: u128) -> Transaction {
+        TransactionPayload {
+            tx_kind: TxKind::Public,
+            execution_input: serde_json::to_vec(&ActionData::MintMoneyPublicTx(
+                MintMoneyPublicTx { acc, amount },
+            ))
+            .unwrap(),
+            execution_output: vec![],
+            utxo_commitments_spent_hashes: vec![],
+            utxo_commitments_created_hashes: vec![],
+            nullifier_created_hashes: vec![],
+            execution_proof_private: "".to_string(),
+            encoded_data: vec![],
+        }
+        .into()
+    }
+
+    pub async fn transfer_utxo_private(
+        &self,
+        utxo: UTXO,
+        receivers: Vec<(u128, AccountAddress)>,
+    ) -> Transaction {
+        let accout = self.acc_map.get(&utxo.owner).unwrap();
+
+        let commitment_in = {
+            let guard = self.storage.lock().await;
+
+            guard.utxo_commitments_store.get_tx(utxo.hash).unwrap().hash
+        };
+
+        let nullifier = generate_nullifiers(
+            &utxo,
+            &accout
+                .key_holder
+                .utxo_secret_key_holder
+                .nullifier_secret_key
+                .to_bytes()
+                .to_vec(),
+        );
+
+        let (resulting_utxos, receipt) = prove_send_utxo(utxo, receivers);
+
+        let utxos: Vec<UTXO> = resulting_utxos
+            .iter()
+            .map(|(utxo, _)| utxo.clone())
+            .collect();
+
+        let encoded_data: Vec<(Vec<u8>, Vec<u8>)> = utxos
+            .iter()
+            .map(|utxo_enc| {
+                let accout_enc = self.acc_map.get(&utxo_enc.owner).unwrap();
+
+                let (ciphertext, nonce) = Account::encrypt_data(
+                    &accout.produce_ephemeral_key_holder(),
+                    accout_enc.key_holder.viewing_public_key,
+                    &serde_json::to_vec(&utxo_enc).unwrap(),
+                );
+
+                (ciphertext, nonce.to_vec())
+            })
+            .collect();
+
+        let commitments = generate_commitments(&utxos);
+
+        TransactionPayload {
+            tx_kind: TxKind::Private,
+            execution_input: vec![],
+            execution_output: vec![],
+            utxo_commitments_spent_hashes: vec![commitment_in],
+            utxo_commitments_created_hashes: commitments
+                .into_iter()
+                .map(|hash_data| hash_data.try_into().unwrap())
+                .collect(),
+            nullifier_created_hashes: vec![nullifier.try_into().unwrap()],
+            execution_proof_private: serde_json::to_string(&receipt).unwrap(),
+            encoded_data,
+        }
+        .into()
+    }
+
+    pub async fn transfer_balance_shielded(
+        &self,
+        acc: AccountAddress,
+        balance: u64,
+        receivers: Vec<(u128, AccountAddress)>,
+    ) -> Transaction {
+        let accout = self.acc_map.get(&acc).unwrap();
+
+        let commitment_secrets = CommitmentSecrets {
+            value: balance,
+            value_blinding_factor: Tweak::from_slice(
+                &accout
+                    .key_holder
+                    .utxo_secret_key_holder
+                    .viewing_secret_key
+                    .to_bytes()
+                    .to_vec(),
+            )
+            .unwrap(),
+            generator_blinding_factor: Tweak::new(&mut thread_rng()),
+        };
+
+        let tag = tag_random();
+        let commitment = commit(&commitment_secrets, tag);
+
+        let nullifier = executions::se::generate_nullifiers(
+            &commitment,
+            &accout
+                .key_holder
+                .utxo_secret_key_holder
+                .nullifier_secret_key
+                .to_bytes()
+                .to_vec(),
+        );
+
+        let (resulting_utxos, receipt) = prove_send_utxo_shielded(acc, balance as u128, receivers);
+
+        let utxos: Vec<UTXO> = resulting_utxos
+            .iter()
+            .map(|(utxo, _)| utxo.clone())
+            .collect();
+
+        let encoded_data: Vec<(Vec<u8>, Vec<u8>)> = utxos
+            .iter()
+            .map(|utxo_enc| {
+                let accout_enc = self.acc_map.get(&utxo_enc.owner).unwrap();
+
+                let (ciphertext, nonce) = Account::encrypt_data(
+                    &accout.produce_ephemeral_key_holder(),
+                    accout_enc.key_holder.viewing_public_key,
+                    &serde_json::to_vec(&utxo_enc).unwrap(),
+                );
+
+                (ciphertext, nonce.to_vec())
+            })
+            .collect();
+
+        let commitments = generate_commitments(&utxos);
+
+        TransactionPayload {
+            tx_kind: TxKind::Private,
+            execution_input: serde_json::to_vec(&ActionData::SendMoneyShieldedTx(
+                SendMoneyShieldedTx {
+                    acc_sender: acc,
+                    amount: balance as u128,
+                },
+            ))
+            .unwrap(),
+            execution_output: vec![],
+            utxo_commitments_spent_hashes: vec![],
+            utxo_commitments_created_hashes: commitments
+                .into_iter()
+                .map(|hash_data| hash_data.try_into().unwrap())
+                .collect(),
+            nullifier_created_hashes: vec![nullifier.try_into().unwrap()],
+            execution_proof_private: serde_json::to_string(&receipt).unwrap(),
+            encoded_data,
+        }
+        .into()
+    }
+
+    pub async fn transfer_utxo_deshielded(
+        &self,
+        utxo: UTXO,
+        receivers: Vec<(u128, AccountAddress)>,
+    ) -> Transaction {
+        let accout = self.acc_map.get(&utxo.owner).unwrap();
+
+        let commitment_in = {
+            let guard = self.storage.lock().await;
+
+            guard.utxo_commitments_store.get_tx(utxo.hash).unwrap().hash
+        };
+
+        let nullifier = generate_nullifiers(
+            &utxo,
+            &accout
+                .key_holder
+                .utxo_secret_key_holder
+                .nullifier_secret_key
+                .to_bytes()
+                .to_vec(),
+        );
+
+        let (resulting_utxos, receipt) = prove_send_utxo_deshielded(utxo, receivers);
+
+        TransactionPayload {
+            tx_kind: TxKind::Private,
+            execution_input: vec![],
+            execution_output: serde_json::to_vec(&ActionData::SendMoneyDeshieldedTx(
+                SendMoneyDeshieldedTx {
+                    receiver_data: resulting_utxos,
+                },
+            ))
+            .unwrap(),
+            utxo_commitments_spent_hashes: vec![commitment_in],
+            utxo_commitments_created_hashes: vec![],
+            nullifier_created_hashes: vec![nullifier.try_into().unwrap()],
+            execution_proof_private: serde_json::to_string(&receipt).unwrap(),
+            encoded_data: vec![],
+        }
+        .into()
+    }
+
+    pub async fn send_private_mint_tx(
+        &self,
+        acc: AccountAddress,
+        amount: u128,
+    ) -> Result<SendTxResponse> {
+        Ok(self
+            .sequencer_client
+            .send_tx(self.mint_utxo_private(acc, amount))
+            .await?)
+    }
+
+    pub async fn send_public_deposit(
+        &self,
+        acc: AccountAddress,
+        amount: u128,
+    ) -> Result<SendTxResponse> {
+        Ok(self
+            .sequencer_client
+            .send_tx(self.deposit_money_public(acc, amount))
+            .await?)
+    }
+
+    pub async fn send_private_send_tx(
+        &self,
+        utxo: UTXO,
+        receivers: Vec<(u128, AccountAddress)>,
+    ) -> Result<SendTxResponse> {
+        Ok(self
+            .sequencer_client
+            .send_tx(self.transfer_utxo_private(utxo, receivers).await)
+            .await?)
+    }
+
+    pub async fn send_shielded_send_tx(
+        &self,
+        acc: AccountAddress,
+        amount: u64,
+        receivers: Vec<(u128, AccountAddress)>,
+    ) -> Result<SendTxResponse> {
+        Ok(self
+            .sequencer_client
+            .send_tx(self.transfer_balance_shielded(acc, amount, receivers).await)
+            .await?)
+    }
+
+    pub async fn send_deshielded_send_tx(
+        &self,
+        utxo: UTXO,
+        receivers: Vec<(u128, AccountAddress)>,
+    ) -> Result<SendTxResponse> {
+        Ok(self
+            .sequencer_client
+            .send_tx(self.transfer_utxo_deshielded(utxo, receivers).await)
+            .await?)
+    }
 }