Use AssetId as inner type for confidential::Asset

Author: stevenroose

src/confidential.rs

@@ -25,6 +25,7 @@ use std::{io, fmt};
 use bitcoin::hashes::sha256d;
 
 use encode::{self, Encodable, Decodable};
+use issuance::AssetId;
 
 // Helper macro to implement various things for the various confidential
 // commitment types
@@ -207,7 +208,7 @@ pub enum Asset {
     /// No value
     Null,
     /// Asset entropy is explicitly encoded
-    Explicit(sha256d::Hash),
+    Explicit(AssetId),
     /// Asset is committed
     Confidential(u8, [u8; 32]),
 }
@@ -233,7 +234,7 @@ impl Asset {
 
     /// Returns the explicit asset.
     /// Returns [None] if [is_explicit] returns false.
-    pub fn explicit(&self) -> Option<sha256d::Hash> {
+    pub fn explicit(&self) -> Option<AssetId> {
         match *self {
             Asset::Explicit(v) => Some(v),
             _ => None,
@@ -286,7 +287,7 @@ impl Nonce {
 
 #[cfg(test)]
 mod tests {
-    use bitcoin::hashes::Hash;
+    use bitcoin::hashes::{Hash, sha256};
     use super::*;
 
     #[test]
@@ -315,7 +316,7 @@ mod tests {
 
         let assets = [
             Asset::Null,
-            Asset::Explicit(sha256d::Hash::from_inner([0; 32])),
+            Asset::Explicit(AssetId::from_inner(sha256::Midstate::from_inner([0; 32]))),
             Asset::Confidential(0x0a, [1; 32]),
         ];
         for v in &assets[..] {

src/encode.rs

@@ -18,11 +18,12 @@
 use std::io::Cursor;
 use std::{error, fmt, io, mem};
 
-use ::bitcoin::consensus::encode as btcenc;
+use bitcoin::consensus::encode as btcenc;
+use bitcoin::hashes::sha256;
 
 use transaction::{Transaction, TxIn, TxOut};
 
-pub use ::bitcoin::consensus::encode::MAX_VEC_SIZE;
+pub use bitcoin::consensus::encode::MAX_VEC_SIZE;
 
 /// Encoding error
 #[derive(Debug)]
@@ -122,6 +123,18 @@ pub fn deserialize_partial<'a, T: Decodable>(data: &'a [u8]) -> Result<(T, usize
     Ok((rv, consumed))
 }
 
+impl Encodable for sha256::Midstate {
+    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, Error> {
+        self.into_inner().consensus_encode(e)
+    }
+}
+
+impl Decodable for sha256::Midstate {
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
+        Ok(Self::from_inner(<[u8; 32]>::consensus_decode(d)?))
+    }
+}
+
 /// Implement Elements encodable traits for Bitcoin encodable types.
 macro_rules! impl_upstream {
     ($type: ty) => {

src/issuance.rs

@@ -14,10 +14,13 @@
 
 //! Asset Issuance
 
+use std::io;
 use std::str::FromStr;
 
 use bitcoin::util::hash::BitcoinHash;
 use bitcoin::hashes::{hex, sha256, Hash};
+
+use encode::{self, Encodable, Decodable};
 use fast_merkle_root::fast_merkle_root;
 use transaction::OutPoint;
 
@@ -119,6 +122,18 @@ impl FromStr for AssetId {
 	}
 }
 
+impl Encodable for AssetId {
+    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, encode::Error> {
+        self.0.consensus_encode(e)
+    }
+}
+
+impl Decodable for AssetId {
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
+        Ok(Self::from_inner(sha256::Midstate::consensus_decode(d)?))
+    }
+}
+
 #[cfg(feature = "serde")]
 impl ::serde::Serialize for AssetId {
     fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {

src/transaction.rs

@@ -21,7 +21,7 @@ use std::collections::HashMap;
 use bitcoin::{self, BitcoinHash, Txid, VarInt};
 use bitcoin::blockdata::opcodes;
 use bitcoin::blockdata::script::{Script, Instruction};
-use bitcoin::hashes::{Hash, sha256, sha256d};
+use bitcoin::hashes::Hash;
 
 use confidential;
 use encode::{self, Encodable, Decodable};
@@ -280,7 +280,7 @@ impl TxIn {
             },
             value: opt_try!(bitcoin::consensus::deserialize(&self.witness.pegin_witness[0])),
             asset: confidential::Asset::Explicit(
-                opt_try!(bitcoin::consensus::deserialize(&self.witness.pegin_witness[1])),
+                opt_try!(encode::deserialize(&self.witness.pegin_witness[1])),
             ),
             genesis_hash: opt_try!(bitcoin::consensus::deserialize(&self.witness.pegin_witness[2])),
             claim_script: &self.witness.pegin_witness[3],
@@ -617,7 +617,6 @@ impl Transaction {
 
     /// Get the total transaction fee in the given asset.
     pub fn fee_in(&self, asset: AssetId) -> u64 {
-        let asset = sha256d::Hash::from_inner(asset.into_inner().into_inner());
         // is_fee checks for explicit asset and value, so we can unwrap them here.
         self.output.iter()
             .filter(|o| o.is_fee() && o.asset.explicit().expect("is_fee") == asset)
@@ -630,8 +629,7 @@ impl Transaction {
         let mut fees = HashMap::new();
         for out in self.output.iter().filter(|o| o.is_fee()) {
             // is_fee checks for explicit asset and value, so we can unwrap them here.
-            let asset = out.asset.explicit().expect("is_fee").into_inner();
-            let asset = AssetId::from_inner(sha256::Midstate::from_inner(asset));
+            let asset = out.asset.explicit().expect("is_fee");
             let entry = fees.entry(asset).or_insert(0);
             *entry += out.value.explicit().expect("is_fee");
         }
@@ -719,7 +717,6 @@ impl Decodable for Transaction {
 mod tests {
     use bitcoin::{self, BitcoinHash};
     use bitcoin::hashes::hex::FromHex;
-    use bitcoin::hashes::sha256d;
 
     use encode::serialize;
     use confidential;
@@ -1222,7 +1219,7 @@ mod tests {
             })
         );
 
-        let expected_asset_id = sha256d::Hash::from_hex("630ed6f9b176af03c0cd3f8aa430f9e7b4d988cf2d0b2f204322488f03b00bf8").unwrap();
+        let expected_asset_id = AssetId::from_hex("630ed6f9b176af03c0cd3f8aa430f9e7b4d988cf2d0b2f204322488f03b00bf8").unwrap();
         if let confidential::Asset::Explicit(asset_id) = tx.output[0].asset {
             assert_eq!(expected_asset_id, asset_id);
         } else {