fixed ser/de

Cargo.lock

@@ -865,6 +865,7 @@ dependencies = [
  "primitives 0.1.0",
  "rpc 0.1.0",
  "script 0.1.0",
+ "serialization 0.1.0",
  "storage 0.1.0",
  "sync 0.1.0",
  "verification 0.1.0",

Cargo.toml

@@ -26,14 +26,13 @@ import = { path = "import" }
 logs = { path = "logs" }
 rpc = { path = "rpc" }
 primitives = { path = "primitives" }
+serialization = { path = "serialization" }
 
 [profile.dev]
 debug = true
-panic = 'abort'
 
 [profile.release]
 debug = true
-panic = 'abort'
 
 [profile.test]
 debug = true

chain/src/block_header.rs

@@ -61,7 +61,6 @@ impl From<&'static str> for BlockHeader {
 impl Serializable for BlockHeader {
 	fn serialize(&self, stream: &mut Stream) {
 		let is_zcash_format = stream.is_zcash_stream();
-println!("=== is_zcash_format = {}", is_zcash_format);
 		stream
 			.append(&self.version)
 			.append(&self.previous_header_hash)

chain/src/join_split.rs

@@ -1,49 +1,8 @@
 use std::io;
 use rustc_serialize::hex::ToHex;
 use hash::{H256, H512};
-use ser::{Error, Serializable, Deserializable, Stream, Reader};
-
-#[derive(Clone, Serializable, Deserializable)]
-pub struct ZKProof(pub Vec<u8>); // TODO: len == 296
-
-impl ::std::fmt::Debug for ZKProof {
-	fn fmt(&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
-		write!(f, "ZKProof({})", self.0.to_hex())
-	}
-}
-
-impl Default for ZKProof {
-	fn default() -> Self {
-		ZKProof([0; 296].to_vec())
-	}
-}
-
-impl PartialEq for ZKProof {
-	fn eq(&self, c: &ZKProof) -> bool {
-		self.0.iter().zip(c.0.iter()).all(|(l, r)| l == r)
-	}
-}
-
-#[derive(Clone, Serializable, Deserializable)]
-pub struct CipherText(pub Vec<u8>); // TODO: len == 601
-
-impl PartialEq for CipherText {
-	fn eq(&self, c: &CipherText) -> bool {
-		self.0.iter().zip(c.0.iter()).all(|(l, r)| l == r)
-	}
-}
-
-impl ::std::fmt::Debug for CipherText {
-	fn fmt(&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
-		write!(f, "CipherText({})", self.0.to_hex())
-	}
-}
-
-impl Default for CipherText {
-	fn default() -> Self {
-		CipherText([0; 601].to_vec())
-	}
-}
+use ser::{Error, Serializable, Deserializable, Stream, Reader, FixedArray_H256_2,
+	FixedArray_u8_296, FixedArray_u8_601_2};
 
 #[derive(Debug, PartialEq, Default, Clone)]
 pub struct JointSplit {
@@ -57,13 +16,21 @@ pub struct JointSplitDescription {
 	pub value_pub_old: u64,
 	pub value_pub_new: u64,
 	pub anchor: H256,
-	pub nullifiers: Vec<H256>,
-	pub commitments: Vec<H256>,
+	pub nullifiers: FixedArray_H256_2,
+	pub commitments: FixedArray_H256_2,
 	pub ephemeral_key: H256,
 	pub random_seed: H256,
-	pub macs: Vec<H256>,
-	pub zkproof: ZKProof,
-	pub ciphertexts: CipherText,
+	pub macs: FixedArray_H256_2,
+	pub zkproof: FixedArray_u8_296,
+	pub ciphertexts: FixedArray_u8_601_2,
+}
+
+pub fn serialize_joint_split(stream: &mut Stream, joint_split: &Option<JointSplit>) {
+	if let &Some(ref joint_split) = joint_split {
+		stream.append_list(&joint_split.descriptions)
+			.append(&joint_split.pubkey)
+			.append(&joint_split.sig);
+	}
 }
 
 pub fn deserialize_joint_split<T>(reader: &mut Reader<T>) -> Result<Option<JointSplit>, Error> where T: io::Read {

chain/src/transaction.rs

@@ -9,7 +9,7 @@ use ser::{deserialize, serialize, serialize_with_flags, SERIALIZE_TRANSACTION_WI
 use crypto::dhash256;
 use hash::H256;
 use constants::{SEQUENCE_FINAL, LOCKTIME_THRESHOLD};
-use join_split::{JointSplit, deserialize_joint_split};
+use join_split::{JointSplit, deserialize_joint_split, serialize_joint_split};
 use ser::{Error, Serializable, Deserializable, Stream, Reader};
 
 /// Must be zero.
@@ -207,6 +207,16 @@ impl Deserializable for TransactionInput {
 
 impl Serializable for Transaction {
 	fn serialize(&self, stream: &mut Stream) {
+		if stream.is_zcash_stream() {
+			stream
+				.append(&self.version)
+				.append_list(&self.inputs)
+				.append_list(&self.outputs)
+				.append(&self.lock_time);
+			serialize_joint_split(stream, &self.joint_split);
+			return;
+		}
+
 		let include_transaction_witness = stream.include_transaction_witness() && self.has_witness();
 		match include_transaction_witness {
 			false => stream
@@ -234,8 +244,8 @@ impl Deserializable for Transaction {
 	fn deserialize<T>(reader: &mut Reader<T>) -> Result<Self, Error> where Self: Sized, T: io::Read {
 		let version = reader.read()?;
 		let mut inputs: Vec<TransactionInput> = reader.read_list()?;
-
-		let read_witness = if inputs.is_empty() {
+		// TODO: default flags must be: ZCASH, WITNESS, ...
+		let read_witness = if inputs.is_empty() && !reader.is_zcash_reader() {
 			let witness_flag: u8 = reader.read()?;
 			if witness_flag != WITNESS_FLAG {
 				return Err(Error::MalformedData);
@@ -252,7 +262,7 @@ impl Deserializable for Transaction {
 				input.script_witness = reader.read_list()?;
 			}
 		}
-
+		let lock_time = reader.read()?;
 		let joint_split = if version >= 2 && reader.is_zcash_reader() {
 			deserialize_joint_split(reader)?
 		} else {
@@ -263,7 +273,7 @@ impl Deserializable for Transaction {
 			version: version,
 			inputs: inputs,
 			outputs: outputs,
-			lock_time: reader.read()?,
+			lock_time: lock_time,
 			joint_split: joint_split,
 		})
 	}

network/src/network.rs

@@ -112,7 +112,6 @@ impl Network {
 				let origin = "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";
 				let origin = origin.from_hex().unwrap();
 				let genesis: chain::Block = serialization::deserialize_with_flags(&origin as &[u8], serialization::DESERIALIZE_ZCASH).unwrap();
-println!("=== ZCash genesis hash: {:?}", genesis.hash());
 				genesis
 			},
 			(&ConsensusFork::ZCash, Network::Testnet) =>

p2p/src/io/handshake.rs

@@ -104,24 +104,20 @@ impl<A> Future for Handshake<A> where A: AsyncRead + AsyncWrite {
 			let next_state = match self.state {
 				HandshakeState::SendVersion(ref mut future) => {
 					let (stream, _) = try_ready!(future.poll());
-println!("=== 1");
 					HandshakeState::ReceiveVersion(read_message(stream, self.flags, self.magic, 0))
 				},
 				HandshakeState::ReceiveVersion(ref mut future) => {
 					let (stream, version) = try_ready!(future.poll());
-println!("=== 2: {:?}", version);
 					let version = match version {
 						Ok(version) => version,
 						Err(err) => return Ok((stream, Err(err.into())).into()),
 					};
 
 					if version.version() < self.min_version {
-println!("=== 2.1: {} < {}", version.version(), self.min_version);
 						return Ok((stream, Err(Error::InvalidVersion)).into());
 					}
 					if let (Some(self_nonce), Some(nonce)) = (self.nonce, version.nonce()) {
 						if self_nonce == nonce {
-println!("=== 2.2: {} == {}", self_nonce, nonce);
 							return Ok((stream, Err(Error::InvalidVersion)).into());
 						}
 					}
@@ -133,7 +129,6 @@ println!("=== 2.2: {} == {}", self_nonce, nonce);
 				},
 				HandshakeState::SendVerack { ref mut version, ref mut future } => {
 					let (stream, _) = try_ready!(future.poll());
-println!("=== 3");
 					let version = version.take().expect("verack must be preceded by version");
 
 					HandshakeState::ReceiveVerack {
@@ -143,7 +138,6 @@ println!("=== 3");
 				},
 				HandshakeState::ReceiveVerack { ref mut version, ref mut future } => {
 					let (stream, _verack) = try_ready!(future.poll());
-println!("=== 4");
 					let version = version.take().expect("verack must be preceded by version");
 
 					let result = HandshakeResult {

p2p/src/io/read_message.rs

@@ -43,13 +43,11 @@ impl<M, A> Future for ReadMessage<M, A> where A: AsyncRead, M: Payload {
 			let next_state = match self.state {
 				ReadMessageState::ReadHeader { version, ref mut future } => {
 					let (read, header) = try_ready!(future.poll());
-println!("=== 10: {:?}", header);
 					let header = match header {
 						Ok(header) => header,
 						Err(err) => return Ok((read, Err(err)).into()),
 					};
-let s: String = header.command.clone().into();
-println!("=== 11: {}", s);
+
 					if header.command != M::command() {
 						return Ok((read, Err(Error::InvalidCommand)).into());
 					}

pbtc/config.rs

@@ -9,6 +9,7 @@ use seednodes::{mainnet_seednodes, testnet_seednodes, bitcoin_cash_seednodes,
 use rpc_apis::ApiSet;
 use {USER_AGENT, REGTEST_USER_AGENT};
 use primitives::hash::H256;
+use ser;
 use rpc::HttpConfiguration as RpcHttpConfig;
 use verification::VerificationLevel;
 use sync::VerificationParameters;
@@ -61,6 +62,11 @@ pub fn parse(matches: &clap::ArgMatches) -> Result<Config, String> {
 	let consensus_fork = parse_consensus_fork(network, &db, &matches)?;
 	let consensus = ConsensusParams::new(network, consensus_fork);
 
+	match consensus.fork {
+		ConsensusFork::ZCash => ser::set_default_flags(ser::SERIALIZE_ZCASH),
+		_ => (),
+	};
+
 	let (in_connections, out_connections) = match network {
 		Network::Testnet | Network::Mainnet | Network::Other(_) => (10, 10),
 		Network::Regtest | Network::Unitest => (1, 0),

pbtc/main.rs

@@ -22,6 +22,7 @@ extern crate import;
 extern crate rpc as ethcore_rpc;
 extern crate primitives;
 extern crate verification;
+extern crate serialization as ser;
 
 mod commands;
 mod config;

serialization/src/fixed_array.rs

@@ -0,0 +1,91 @@
+use std::{fmt, io};
+use primitives::hash::H256;
+use primitives::hex::ToHex;
+use {
+	Serializable, Stream,
+	Deserializable, Reader, Error as ReaderError
+};
+
+macro_rules! impl_fixed_array {
+	($name: ident, $type: ty, $len: expr) => {
+
+		/// A type for fixed-length array.
+		#[derive(Default, Debug, Clone, PartialEq)]
+		pub struct $name(pub [$type; $len]);
+
+		impl Serializable for $name {
+			fn serialize(&self, stream: &mut Stream) {
+				for i in 0..$len {
+					stream.append(&self.0[i]);
+				}
+			}
+
+			fn serialized_size(&self) -> usize {
+				$len * ::std::mem::size_of::<$type>()
+			}
+		}
+
+		impl Deserializable for $name {
+			fn deserialize<T>(reader: &mut Reader<T>) -> Result<Self, ReaderError> where T: io::Read {
+				//let mut array = [Default::default(); $len];
+				let mut array: [$type; $len] = Default::default();
+				for i in 0..$len {
+					array[i] = reader.read()?;
+				}
+				Ok($name(array))
+			}
+		}
+
+	}
+}
+
+macro_rules! impl_fixed_array_u8 {
+	($name: ident, $len: expr) => {
+
+		/// A type for fixed-length array.
+		#[derive(Clone)]
+		pub struct $name(pub [u8; $len]);
+
+		impl PartialEq for $name {
+			fn eq(&self, other: &Self) -> bool {
+				self.0.iter().zip(other.0.iter()).all(|(l, r)| l == r)
+			}
+		}
+
+		impl Default for $name {
+			fn default() -> Self {
+				$name([0; $len])
+			}
+		}
+
+		impl fmt::Debug for $name {
+			fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+				self.0.to_hex().fmt(f)
+			}
+		}
+
+		impl Serializable for $name {
+			fn serialize(&self, stream: &mut Stream) {
+				stream.append_slice(&self.0);
+			}
+
+			fn serialized_size(&self) -> usize {
+				$len
+			}
+		}
+
+		impl Deserializable for $name {
+			fn deserialize<T>(reader: &mut Reader<T>) -> Result<Self, ReaderError> where T: io::Read {
+				let mut array = [0; $len];
+				reader.read_slice(&mut array)?;
+				Ok($name(array))
+			}
+		}
+
+	}
+}
+
+impl_fixed_array!(FixedArray_H256_2, H256, 2);
+impl_fixed_array_u8!(FixedArray_u8_296, 296);
+impl_fixed_array_u8!(FixedArray_u8_601, 601);
+impl_fixed_array!(FixedArray_u8_601_2, FixedArray_u8_601, 2);

serialization/src/lib.rs

@@ -2,6 +2,7 @@ extern crate byteorder;
 extern crate primitives;
 
 mod compact_integer;
+mod fixed_array;
 mod flags;
 mod impls;
 mod list;
@@ -12,6 +13,7 @@ pub use primitives::{hash, bytes, compact};
 
 // TODO: use same flags for both serialization && deserialization (they're used this way on network layer)
 
+pub use fixed_array::*;
 pub use flags::{set_default_flags, get_default_flags};
 pub use compact_integer::CompactInteger;
 pub use list::List;

serialization/src/reader.rs

@@ -94,7 +94,7 @@ impl<T> io::Read for Reader<T> where T: io::Read {
 
 impl<R> Reader<R> where R: io::Read {
 	pub fn from_read(read: R) -> Self {
-		Self::from_read_with_flags(read, 0)
+		Self::from_read_with_flags(read, get_default_flags())
 	}
 
 	pub fn from_read_with_flags(read: R, flags: u32) -> Self {