confidential: directly use Read/Write in Encodable/Decodable

We eventually want to remove Encodable and Decodable. To help with that,
start by cleaning up a few things:

* don't use the traits on u8 or u64
* especially don't use the trait on u64 then call `swap_bytes` to deal
  with the fact that we want a BE encoding

Author: apoelstra

src/confidential/asset.rs

@@ -120,10 +120,14 @@ impl fmt::Display for Asset {
 impl Encodable for Asset {
     fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
         match *self {
-            Self::Null => 0u8.consensus_encode(s),
+            Self::Null => {
+                s.write_all(&[0u8])?;
+                Ok(1)
+            }
             Self::Explicit(n) => {
-                1u8.consensus_encode(&mut s)?;
-                Ok(1 + n.consensus_encode(&mut s)?)
+                s.write_all(&[1u8])?;
+                s.write_all(n.as_byte_array())?;
+                Ok(1 + EXPLICIT_LEN)
             }
             Self::Confidential(generator) => {
                 s.write_all(&generator.serialize())?;
@@ -135,19 +139,19 @@ impl Encodable for Asset {
 
 impl Decodable for Asset {
     fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        let prefix = u8::consensus_decode(&mut d)?;
+        let mut buf = [0u8; CONFIDENTIAL_LEN];
+        d.read_exact(&mut buf[0..1])?;
 
-        match prefix {
+        match buf[0] {
             0 => Ok(Self::Null),
             1 => {
-                let explicit = Decodable::consensus_decode(&mut d)?;
-                Ok(Self::Explicit(explicit))
+                let mut buf = [0; EXPLICIT_LEN];
+                d.read_exact(&mut buf)?;
+                Ok(Self::Explicit(AssetId::from_byte_array(buf)))
             }
             p if p == CONF_PREFIX_1 || p == CONF_PREFIX_2 => {
-                let mut comm = [0u8; CONFIDENTIAL_LEN];
-                comm[0] = p;
-                d.read_exact(&mut comm[1..])?;
-                Ok(Self::Confidential(ConfInner::from_slice(&comm[..])?))
+                d.read_exact(&mut buf[1..])?;
+                Ok(Self::Confidential(ConfInner::from_slice(&buf[..])?))
             }
             p => Err(encode::Error::InvalidConfidentialPrefix(p)),
         }

src/confidential/nonce.rs

@@ -150,10 +150,14 @@ impl fmt::Display for Nonce {
 impl Encodable for Nonce {
     fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
         match *self {
-            Self::Null => 0u8.consensus_encode(s),
+            Self::Null => {
+                s.write_all(&[0u8])?;
+                Ok(1)
+            }
             Self::Explicit(n) => {
-                1u8.consensus_encode(&mut s)?;
-                Ok(1 + n.consensus_encode(&mut s)?)
+                s.write_all(&[1u8])?;
+                s.write_all(&n)?;
+                Ok(1 + EXPLICIT_LEN)
             }
             Self::Confidential(commitment) => {
                 s.write_all(&commitment.serialize())?;
@@ -165,19 +169,19 @@ impl Encodable for Nonce {
 
 impl Decodable for Nonce {
     fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        let prefix = u8::consensus_decode(&mut d)?;
+        let mut buf = [0u8; CONFIDENTIAL_LEN];
+        d.read_exact(&mut buf[0..1])?;
 
-        match prefix {
+        match buf[0] {
             0 => Ok(Self::Null),
             1 => {
-                let explicit = Decodable::consensus_decode(&mut d)?;
-                Ok(Self::Explicit(explicit))
+                let mut buf = [0; EXPLICIT_LEN];
+                d.read_exact(&mut buf)?;
+                Ok(Self::Explicit(buf))
             }
             p if p == CONF_PREFIX_1 || p == CONF_PREFIX_2 => {
-                let mut comm = [0u8; CONFIDENTIAL_LEN];
-                comm[0] = p;
-                d.read_exact(&mut comm[1..])?;
-                Ok(Self::Confidential(ConfInner::from_slice(&comm)?))
+                d.read_exact(&mut buf[1..])?;
+                Ok(Self::Confidential(ConfInner::from_slice(&buf)?))
             }
             p => Err(encode::Error::InvalidConfidentialPrefix(p)),
         }

src/confidential/value.rs

@@ -123,10 +123,14 @@ impl fmt::Display for Value {
 impl Encodable for Value {
     fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
         match *self {
-            Self::Null => 0u8.consensus_encode(s),
+            Self::Null => {
+                s.write_all(&[0u8])?;
+                Ok(1)
+            }
             Self::Explicit(n) => {
-                1u8.consensus_encode(&mut s)?;
-                Ok(1 + u64::swap_bytes(n).consensus_encode(&mut s)?)
+                s.write_all(&[1u8])?;
+                s.write_all(&n.to_be_bytes())?;
+                Ok(1 + EXPLICIT_LEN)
             }
             Self::Confidential(commitment) => {
                 s.write_all(&commitment.serialize())?;
@@ -138,19 +142,19 @@ impl Encodable for Value {
 
 impl Decodable for Value {
     fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        let prefix = u8::consensus_decode(&mut d)?;
+        let mut buf = [0u8; CONFIDENTIAL_LEN];
+        d.read_exact(&mut buf[0..1])?;
 
-        match prefix {
+        match buf[0] {
             0 => Ok(Self::Null),
             1 => {
-                let explicit = u64::swap_bytes(Decodable::consensus_decode(&mut d)?);
-                Ok(Self::Explicit(explicit))
+                let mut buf = [0; EXPLICIT_LEN];
+                d.read_exact(&mut buf)?;
+                Ok(Self::Explicit(u64::from_be_bytes(buf)))
             }
             p if p == CONF_PREFIX_1 || p == CONF_PREFIX_2 => {
-                let mut comm = [0u8; CONFIDENTIAL_LEN];
-                comm[0] = p;
-                d.read_exact(&mut comm[1..])?;
-                Ok(Self::Confidential(ConfInner::from_slice(&comm)?))
+                d.read_exact(&mut buf[1..])?;
+                Ok(Self::Confidential(ConfInner::from_slice(&buf)?))
             }
             p => Err(encode::Error::InvalidConfidentialPrefix(p)),
         }