fmt

core_primitives/src/transaction.rs

@@ -6,8 +6,8 @@ use elliptic_curve::{
     consts::{B0, B1},
     generic_array::GenericArray,
 };
-use sha2::digest::typenum::{UInt, UTerm};
 use secp256k1_zkp::PedersenCommitment;
+use sha2::digest::typenum::{UInt, UTerm};
 
 pub type CipherText = Vec<u8>;
 pub type Nonce = GenericArray<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>;

node_core/src/executions/de.rs

@@ -155,10 +155,7 @@ pub fn verify_commitment(
 }
 
 // new_commitment
-pub fn new_commitment(
+pub fn new_commitment(public_info: u64, secret_r: &[u8]) -> (Tweak, &[u8], PedersenCommitment) {
-    public_info: u64,
-    secret_r: &[u8],
-) -> (Tweak, &[u8], PedersenCommitment) {
     let generator_blinding_factor = Tweak::new(&mut thread_rng());
     let commitment_secrets = CommitmentSecrets {
         value: public_info,
@@ -180,15 +177,18 @@ pub fn new_commitment_vec(
     let generator_blinding_factor = Tweak::new(&mut thread_rng());
     let tag = tag_random();
 
-    let vec_commitments = public_info_vec.into_iter().map(|public_info|   {
+    let vec_commitments = public_info_vec
-        let commitment_secrets = CommitmentSecrets {
+        .into_iter()
-            value: public_info,
+        .map(|public_info| {
-            value_blinding_factor: Tweak::from_slice(secret_r).unwrap(),
+            let commitment_secrets = CommitmentSecrets {
-            generator_blinding_factor,
+                value: public_info,
-        };
+                value_blinding_factor: Tweak::from_slice(secret_r).unwrap(),
+                generator_blinding_factor,
+            };
 
-        commit(&commitment_secrets, tag)
+            commit(&commitment_secrets, tag)
-    }).collect();
+        })
+        .collect();
 
     (generator_blinding_factor, secret_r, vec_commitments)
 }

node_core/src/lib.rs

@@ -5,13 +5,16 @@ use std::sync::{
 
 use common::ExecutionFailureKind;
 
-use rand::Rng;
 use ::storage::transaction::{Transaction, TransactionPayload, TxKind};
 use accounts::account_core::{Account, AccountAddress};
 use anyhow::Result;
 use config::NodeConfig;
-use executions::{de::new_commitment_vec, private_exec::{generate_commitments, generate_nullifiers}};
+use executions::{
+    de::new_commitment_vec,
+    private_exec::{generate_commitments, generate_nullifiers},
+};
 use log::info;
+use rand::Rng;
 use sequencer_client::{json::SendTxResponse, SequencerClient};
 use serde::{Deserialize, Serialize};
 use storage::NodeChainStore;
@@ -216,9 +219,15 @@ impl NodeCore {
         let mut rng = rand::thread_rng();
         let secret_r: [u8; 32] = rng.gen();
 
-        let sc_state = acc_map_read_guard.block_store.get_sc_sc_state(sc_addr).map_err(ExecutionFailureKind::db_error)?;
+        let sc_state = acc_map_read_guard
+            .block_store
+            .get_sc_sc_state(sc_addr)
+            .map_err(ExecutionFailureKind::db_error)?;
 
-        let mut vec_values_u64: Vec<Vec<u64>> =  sc_state.into_iter().map(|slice| vec_u8_to_vec_u64(slice.to_vec())).collect();
+        let mut vec_values_u64: Vec<Vec<u64>> = sc_state
+            .into_iter()
+            .map(|slice| vec_u8_to_vec_u64(slice.to_vec()))
+            .collect();
 
         let context = acc_map_read_guard.produce_context(account.address);
 
@@ -258,9 +267,6 @@ impl NodeCore {
         ))
     }
 
-
-
-    
     pub async fn mint_utxo_multiple_assets_private(
         &self,
         acc: AccountAddress,
@@ -302,9 +308,15 @@ impl NodeCore {
         let mut rng = rand::thread_rng();
         let secret_r: [u8; 32] = rng.gen();
 
-        let sc_state = acc_map_read_guard.block_store.get_sc_sc_state(sc_addr).map_err(ExecutionFailureKind::db_error)?;
+        let sc_state = acc_map_read_guard
+            .block_store
+            .get_sc_sc_state(sc_addr)
+            .map_err(ExecutionFailureKind::db_error)?;
 
-        let mut vec_values_u64: Vec<Vec<u64>> =  sc_state.into_iter().map(|slice| vec_u8_to_vec_u64(slice.to_vec())).collect();
+        let mut vec_values_u64: Vec<Vec<u64>> = sc_state
+            .into_iter()
+            .map(|slice| vec_u8_to_vec_u64(slice.to_vec()))
+            .collect();
 
         let context = acc_map_read_guard.produce_context(account.address);
 
@@ -399,15 +411,21 @@ impl NodeCore {
             .collect();
 
         let commitments = generate_commitments(&utxos);
-        
+
         // TODO: fix address when correspoding method will be added
         let sc_addr = "";
         let mut rng = rand::thread_rng();
         let secret_r: [u8; 32] = rng.gen();
 
-        let sc_state = acc_map_read_guard.block_store.get_sc_sc_state(sc_addr).map_err(ExecutionFailureKind::db_error)?;
+        let sc_state = acc_map_read_guard
+            .block_store
+            .get_sc_sc_state(sc_addr)
+            .map_err(ExecutionFailureKind::db_error)?;
 
-        let mut vec_values_u64: Vec<Vec<u64>> =  sc_state.into_iter().map(|slice| vec_u8_to_vec_u64(slice.to_vec())).collect();
+        let mut vec_values_u64: Vec<Vec<u64>> = sc_state
+            .into_iter()
+            .map(|slice| vec_u8_to_vec_u64(slice.to_vec()))
+            .collect();
 
         let context = acc_map_read_guard.produce_context(account.address);
 
@@ -536,9 +554,15 @@ impl NodeCore {
         let mut rng = rand::thread_rng();
         let secret_r: [u8; 32] = rng.gen();
 
-        let sc_state = acc_map_read_guard.block_store.get_sc_sc_state(sc_addr).map_err(ExecutionFailureKind::db_error)?;
+        let sc_state = acc_map_read_guard
+            .block_store
+            .get_sc_sc_state(sc_addr)
+            .map_err(ExecutionFailureKind::db_error)?;
 
-        let mut vec_values_u64: Vec<Vec<u64>> =  sc_state.into_iter().map(|slice| vec_u8_to_vec_u64(slice.to_vec())).collect();
+        let mut vec_values_u64: Vec<Vec<u64>> = sc_state
+            .into_iter()
+            .map(|slice| vec_u8_to_vec_u64(slice.to_vec()))
+            .collect();
 
         let context = acc_map_read_guard.produce_context(account.address);
 
@@ -647,11 +671,19 @@ impl NodeCore {
         let mut rng = rand::thread_rng();
         let secret_r: [u8; 32] = rng.gen();
 
-        let sc_state = acc_map_read_guard.block_store.get_sc_sc_state(sc_addr).map_err(ExecutionFailureKind::db_error)?;
+        let sc_state = acc_map_read_guard
+            .block_store
+            .get_sc_sc_state(sc_addr)
+            .map_err(ExecutionFailureKind::db_error)?;
 
-        let mut vec_values_u64: Vec<Vec<u64>> =  sc_state.into_iter().map(|slice| vec_u8_to_vec_u64(slice.to_vec())).collect();
+        let mut vec_values_u64: Vec<Vec<u64>> = sc_state
+            .into_iter()
+            .map(|slice| vec_u8_to_vec_u64(slice.to_vec()))
+            .collect();
 
-        let serialized_context_u64 = vec_u8_to_vec_u64(serde_json::to_vec(&acc_map_read_guard.produce_context(account.address)).unwrap());
+        let serialized_context_u64 = vec_u8_to_vec_u64(
+            serde_json::to_vec(&acc_map_read_guard.produce_context(account.address)).unwrap(),
+        );
 
         vec_values_u64.push(serialized_context_u64);
 
@@ -724,9 +756,15 @@ impl NodeCore {
         let mut rng = rand::thread_rng();
         let secret_r: [u8; 32] = rng.gen();
 
-        let sc_state = acc_map_read_guard.block_store.get_sc_sc_state(sc_addr).map_err(ExecutionFailureKind::db_error)?;
+        let sc_state = acc_map_read_guard
+            .block_store
+            .get_sc_sc_state(sc_addr)
+            .map_err(ExecutionFailureKind::db_error)?;
 
-        let mut vec_values_u64: Vec<Vec<u64>> =  sc_state.into_iter().map(|slice| vec_u8_to_vec_u64(slice.to_vec())).collect();
+        let mut vec_values_u64: Vec<Vec<u64>> = sc_state
+            .into_iter()
+            .map(|slice| vec_u8_to_vec_u64(slice.to_vec()))
+            .collect();
 
         let context = acc_map_read_guard.produce_context(account.address);
 
@@ -1332,9 +1370,15 @@ impl NodeCore {
         let mut rng = rand::thread_rng();
         let secret_r: [u8; 32] = rng.gen();
 
-        let sc_state = acc_map_read_guard.block_store.get_sc_sc_state(sc_addr).map_err(ExecutionFailureKind::db_error)?;
+        let sc_state = acc_map_read_guard
+            .block_store
+            .get_sc_sc_state(sc_addr)
+            .map_err(ExecutionFailureKind::db_error)?;
 
-        let mut vec_values_u64: Vec<Vec<u64>> =  sc_state.into_iter().map(|slice| vec_u8_to_vec_u64(slice.to_vec())).collect();
+        let mut vec_values_u64: Vec<Vec<u64>> = sc_state
+            .into_iter()
+            .map(|slice| vec_u8_to_vec_u64(slice.to_vec()))
+            .collect();
 
         let context = acc_map_read_guard.produce_context(account.address);
 

node_core/src/storage/block_store.rs

@@ -1,8 +1,8 @@
 use std::path::Path;
 
 use anyhow::{anyhow, Result};
-use storage::{block::Block, RocksDBIO};
 use storage::sc_db_utils::DataBlob;
+use storage::{block::Block, RocksDBIO};
 
 pub struct NodeBlockStore {
     dbio: RocksDBIO,

node_core/src/storage/public_context.rs

@@ -1,7 +1,7 @@
 use std::collections::BTreeMap;
 
 use accounts::account_core::{AccountAddress, AccountPublicMask};
-use serde::{Serialize};
+use serde::Serialize;
 use storage::merkle_tree_public::TreeHashType;
 
 ///Strucutre, representing context, given to a smart contract on a call

sc_core/src/transaction_payloads_tools.rs

@@ -13,7 +13,7 @@ pub fn create_public_transaction_payload(execution_input: Vec<u8>) -> Transactio
     let unblinded_gen = Generator::new_unblinded(SECP256K1, tag);
 
     let mut rng = rand::thread_rng();
-    
+
     TransactionPayload {
         tx_kind: TxKind::Public,
         execution_input,
@@ -24,7 +24,11 @@ pub fn create_public_transaction_payload(execution_input: Vec<u8>) -> Transactio
         execution_proof_private: "".to_string(),
         encoded_data: vec![],
         ephemeral_pub_key: vec![],
-        commitment: vec![PedersenCommitment::new_unblinded(SECP256K1, 0, unblinded_gen)],
+        commitment: vec![PedersenCommitment::new_unblinded(
+            SECP256K1,
+            0,
+            unblinded_gen,
+        )],
         tweak: Tweak::new(&mut rng),
         secret_r: [0; 32],
     }

storage/src/transaction.rs

@@ -1,7 +1,7 @@
 use log::info;
+use secp256k1_zkp::{rand, PedersenCommitment, Tweak};
 use serde::{Deserialize, Serialize};
 use sha2::{digest::FixedOutput, Digest};
-use secp256k1_zkp::{rand, PedersenCommitment, Tweak};
 
 use crate::merkle_tree_public::TreeHashType;