Add features of multithread

Cargo.toml

@@ -22,10 +22,10 @@ zcrypto = { package = "zero-chain-crypto", path = "core/crypto" }
 jubjub = { path = "core/jubjub" }
 zpairing = { package = "zero-chain-pairing", path = "core/pairing" }
 zprimitives = { package = "zero-chain-primitives", path = "core/primitives" }
-proofs = { package = "zero-chain-proofs", path = "core/proofs" }
-scrypto = { package = "sapling-crypto", git = "https://github.com/LayerXcom/librustzcash", branch = "zero-chain" }
+proofs = { package = "zero-chain-proofs", path = "core/proofs", features = ["multithread"] }
+scrypto = { package = "sapling-crypto", git = "https://github.com/LayerXcom/librustzcash", branch = "zero-chain", features = ["multithread"] }
 keys = { path = "core/keys"}
-bellman = { git = "https://github.com/LayerXcom/librustzcash", branch = "zero-chain" }
+bellman = { git = "https://github.com/LayerXcom/librustzcash", branch = "zero-chain", features = ["multithread"] }
 pairing = { git = "https://github.com/LayerXcom/librustzcash", branch = "zero-chain" }
 rand = "0.4"
 lazy_static = "1.3.0"
@@ -113,7 +113,7 @@ path = 'demo/cli/src/main.rs'
 members = [
     "core/bellman-verifier",
     "core/crypto",
-    "demo/cli",    
+    "demo/cli",
     "core/jubjub",
     "core/pairing",
     "core/primitives",
@@ -124,6 +124,6 @@ members = [
     "modules/executive",
 ]
 exclude = [
-    "runtime/wasm",   
-    "demo/wasm-utils", 
+    "runtime/wasm",
+    "demo/wasm-utils",
 ]

demo/cli/Cargo.toml

@@ -20,7 +20,6 @@ zjubjub = { package = "jubjub", path = "../../core/jubjub"}
 lazy_static = "1.3.0"
 byteorder = "1"
 keys = { path = "../../core/keys" }
-wasm-utils = {package = "zerochain-wasm-utils", path = "../wasm-utils", features = ["multithread"]}
 hex = "0.3.2"
 
 [dependencies.blake2-rfc]

demo/cli/src/main.rs

@@ -11,11 +11,12 @@ use std::fs::File;
 use std::path::Path;
 use std::string::String;
 use std::io::{BufWriter, Write, BufReader, Read};
-use wasm_utils::transaction::Transaction;
 use bellman::groth16::{Parameters, PreparedVerifyingKey};
 
 mod setup;
 use setup::setup;
+mod transaction;
+use transaction::Transaction;
 
 #[macro_use]
 extern crate lazy_static;

demo/cli/src/transaction.rs

@@ -0,0 +1,100 @@
+use bellman::groth16::{Parameters, PreparedVerifyingKey};
+use pairing::bls12_381::Bls12;
+use zpairing::io;
+use scrypto::{
+	jubjub::{JubjubBls12, fs},
+	redjubjub::PrivateKey,
+	};
+use proofs::{
+    self,
+	primitives::{		
+		EncryptionKey, 		
+		ProofGenerationKey,		
+		},
+	prover::TransferProof,	   
+};
+use rand::Rng;
+
+pub struct Transaction{    
+    pub rvk: [u8; 32],                   // 32 bytes
+    pub proof: [u8; 192],                // 192 bytes
+    pub address_sender: [u8; 32],        // 32 bytes
+    pub address_recipient: [u8; 32],     // 32 bytes
+    pub enc_val_recipient: [u8; 64],     // 64 bytes
+	pub enc_val_sender: [u8; 64],        // 64 bytes
+	pub enc_bal_sender: [u8; 64],        // 64 bytes	
+	pub rsk: [u8; 32],                   // 32 bytes
+}
+
+impl Transaction {
+    pub fn gen_tx<R: Rng>(
+        value: u32,
+        remaining_balance: u32,
+        alpha: fs::Fs,
+        proving_key: &Parameters<Bls12>,
+		prepared_vk: &PreparedVerifyingKey<Bls12>,		
+		address_recipient: &EncryptionKey<Bls12>,		
+		ok_sender: &fs::Fs,
+        ciphertext_balance: proofs::elgamal::Ciphertext<Bls12>,		
+		rng: &mut R,
+    ) -> Result<Self, io::Error>
+	{		
+		// The pramaters from std environment
+		let params = JubjubBls12::new();
+
+		let proof_generation_key = ProofGenerationKey::from_origin_key(ok_sender, &params);
+
+		// Generate the zk proof
+		let proof_output = TransferProof::gen_proof(
+			value,
+			remaining_balance,        
+			alpha,			
+			proving_key, 
+			prepared_vk,
+			proof_generation_key,
+			address_recipient.clone(),			
+            ciphertext_balance.clone(),
+			rng,
+			&params,
+		).unwrap();		
+
+		// Generate the re-randomized sign key
+		let rsk = PrivateKey::<Bls12>(*ok_sender).randomize(alpha);
+		let mut rsk_bytes = [0u8; 32];
+		rsk.write(&mut rsk_bytes[..]).map_err(|_| io::Error::InvalidData)?;
+
+		let mut rvk_bytes = [0u8; 32];
+		proof_output.rvk.write(&mut rvk_bytes[..]).map_err(|_| io::Error::InvalidData)?;
+
+		let mut proof_bytes = [0u8; 192];
+		proof_output.proof.write(&mut proof_bytes[..]).map_err(|_| io::Error::InvalidData)?;
+
+		let mut b_address_sender = [0u8; 32];
+		proof_output.address_sender.write(&mut b_address_sender[..]).map_err(|_| io::Error::InvalidData)?;
+
+		let mut b_address_recipient = [0u8; 32];
+		proof_output.address_recipient.write(&mut b_address_recipient[..]).map_err(|_| io::Error::InvalidData)?;
+
+		let mut enc_val_recipient = [0u8; 64];
+		proof_output.cipher_val_r.write(&mut enc_val_recipient[..]).map_err(|_| io::Error::InvalidData)?;
+
+		let mut enc_val_sender = [0u8; 64];
+		proof_output.cipher_val_s.write(&mut enc_val_sender[..]).map_err(|_| io::Error::InvalidData)?;
+
+		let mut enc_bal_sender = [0u8; 64];
+		proof_output.cipher_balance.write(&mut enc_bal_sender[..]).map_err(|_| io::Error::InvalidData)?;					
+
+		let tx = Transaction {		
+			proof: proof_bytes,		           			 
+			rvk: rvk_bytes,  			      
+			address_sender: b_address_sender,        
+			address_recipient: b_address_recipient,
+			enc_val_recipient: enc_val_recipient,
+			enc_val_sender: enc_val_sender,
+			enc_bal_sender: enc_bal_sender,
+			rsk: rsk_bytes,					
+		};
+
+		Ok(tx)
+	}
+}

demo/wasm-utils/Cargo.toml

@@ -9,11 +9,6 @@ crate-type = ["cdylib", "rlib"]
 
 [features]
 default = ["console_error_panic_hook"]
-multithread = [
-    "scrypto/multithread",
-    "proofs/multithread",
-    "bellman/multithread",
-]
 
 [dependencies]
 cfg-if = "0.1.2"

demo/wasm-utils/src/transaction.rs

@@ -7,22 +7,22 @@ use scrypto::{
 	};
 use proofs::{
     self,
-	primitives::{		
-		EncryptionKey, 		
-		ProofGenerationKey,		
+	primitives::{
+		EncryptionKey,
+		ProofGenerationKey,
 		},
-	prover::TransferProof,	   
+	prover::TransferProof,
 };
 use rand::Rng;
 
-pub struct Transaction{    
+pub struct Transaction{
     pub rvk: [u8; 32],                   // 32 bytes
     pub proof: [u8; 192],                // 192 bytes
     pub address_sender: [u8; 32],        // 32 bytes
     pub address_recipient: [u8; 32],     // 32 bytes
     pub enc_val_recipient: [u8; 64],     // 64 bytes
 	pub enc_val_sender: [u8; 64],        // 64 bytes
-	pub enc_bal_sender: [u8; 64],        // 64 bytes	
+	pub enc_bal_sender: [u8; 64],        // 64 bytes
 	pub rsk: [u8; 32],                   // 32 bytes
 }
 
@@ -32,37 +32,37 @@ impl Transaction {
         remaining_balance: u32,
         alpha: fs::Fs,
         proving_key: &Parameters<Bls12>,
-		prepared_vk: &PreparedVerifyingKey<Bls12>,		
-		address_recipient: &EncryptionKey<Bls12>,		
+		prepared_vk: &PreparedVerifyingKey<Bls12>,
+		address_recipient: &EncryptionKey<Bls12>,
 		ok_sender: &fs::Fs,
-        ciphertext_balance: proofs::elgamal::Ciphertext<Bls12>,		
+        ciphertext_balance: proofs::elgamal::Ciphertext<Bls12>,
 		rng: &mut R,
     ) -> Result<Self, io::Error>
-	{		
+	{
 		// The pramaters from std environment
 		let params = JubjubBls12::new();
-		
+
 		let proof_generation_key = ProofGenerationKey::from_origin_key(ok_sender, &params);
 
 		// Generate the zk proof
 		let proof_output = TransferProof::gen_proof(
 			value,
-			remaining_balance,        
-			alpha,			
-			proving_key, 
+			remaining_balance,
+			alpha,
+			proving_key,
 			prepared_vk,
 			proof_generation_key,
-			address_recipient.clone(),			
+			address_recipient.clone(),
             ciphertext_balance.clone(),
 			rng,
 			&params,
-		).unwrap();		
+		).unwrap();
 
 		// Generate the re-randomized sign key
 		let rsk = PrivateKey::<Bls12>(*ok_sender).randomize(alpha);
 		let mut rsk_bytes = [0u8; 32];
 		rsk.write(&mut rsk_bytes[..]).map_err(|_| io::Error::InvalidData)?;
-		
+
 		let mut rvk_bytes = [0u8; 32];
 		proof_output.rvk.write(&mut rvk_bytes[..]).map_err(|_| io::Error::InvalidData)?;
 
@@ -82,17 +82,17 @@ impl Transaction {
 		proof_output.cipher_val_s.write(&mut enc_val_sender[..]).map_err(|_| io::Error::InvalidData)?;
 
 		let mut enc_bal_sender = [0u8; 64];
-		proof_output.cipher_balance.write(&mut enc_bal_sender[..]).map_err(|_| io::Error::InvalidData)?;					
+		proof_output.cipher_balance.write(&mut enc_bal_sender[..]).map_err(|_| io::Error::InvalidData)?;
 
-		let tx = Transaction {		
-			proof: proof_bytes,		           			 
-			rvk: rvk_bytes,  			      
-			address_sender: b_address_sender,        
+		let tx = Transaction {
+			proof: proof_bytes,
+			rvk: rvk_bytes,
+			address_sender: b_address_sender,
 			address_recipient: b_address_recipient,
 			enc_val_recipient: enc_val_recipient,
 			enc_val_sender: enc_val_sender,
 			enc_bal_sender: enc_bal_sender,
-			rsk: rsk_bytes,					
+			rsk: rsk_bytes,
 		};
 
 		Ok(tx)