SigHash -> Sighash

Author: RCasatta

src/hash_types.rs

@@ -44,7 +44,7 @@ hash_newtype! {
     pub struct BlockHash(sha256d::Hash); 
 
     /// "Hash of the transaction according to the signature algorithm"
-    pub struct SigHash(sha256d::Hash); 
+    pub struct Sighash(sha256d::Hash); 
 
     /// A hash of a public key.
     pub struct PubkeyHash(hash160::Hash);
@@ -62,11 +62,11 @@ hash_newtype! {
 
 impl_hashencode!(Txid);
 impl_hashencode!(Wtxid);
-impl_hashencode!(SigHash);
+impl_hashencode!(Sighash);
 impl_hashencode!(BlockHash);
 impl_hashencode!(TxMerkleNode);
 
-impl ThirtyTwoByteHash for SigHash {
+impl ThirtyTwoByteHash for Sighash {
     fn into_32(self) -> [u8; 32] {
         self.0.to_byte_array()
     }

src/pset/error.rs

@@ -64,7 +64,7 @@ pub enum Error {
         /// Actual
         actual: Txid,
     },
-    /// Unable to parse as a standard SigHash type.
+    /// Unable to parse as a standard Sighash type.
     NonStandardSighashType(u32),
     /// Parsing errors from bitcoin_hashes
     HashParseError(hashes::Error),

src/pset/mod.rs

@@ -16,7 +16,7 @@
 //!
 //! Implementation of BIP174 Partially Signed Bitcoin Transaction Format as
 //! defined at <https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki>
-//! except we define PSETs containing non-standard SigHash types as invalid.
+//! except we define PSETs containing non-standard Sighash types as invalid.
 //! Extension for PSET is based on PSET defined in BIP370.
 //! <https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki>
 

src/sighash.rs

@@ -21,7 +21,7 @@
 
 use std::borrow::Borrow;
 use crate::encode::{self, Encodable};
-use crate::hash_types::SigHash;
+use crate::hash_types::Sighash;
 use crate::hashes::{sha256d, Hash, sha256};
 use crate::script::Script;
 use std::ops::{Deref, DerefMut};
@@ -552,9 +552,9 @@ impl<R: Deref<Target = Transaction>> SighashCache<R> {
         if sighash != EcdsaSighashType::Single && sighash != EcdsaSighashType::None {
             self.segwit_cache().outputs.consensus_encode(&mut writer)?;
         } else if sighash == EcdsaSighashType::Single && input_index < self.tx.output.len() {
-            let mut single_enc = SigHash::engine();
+            let mut single_enc = Sighash::engine();
             self.tx.output[input_index].consensus_encode(&mut single_enc)?;
-            SigHash::from_engine(single_enc).consensus_encode(&mut writer)?;
+            Sighash::from_engine(single_enc).consensus_encode(&mut writer)?;
         } else {
             zero_hash.consensus_encode(&mut writer)?;
         }
@@ -579,11 +579,11 @@ impl<R: Deref<Target = Transaction>> SighashCache<R> {
         script_code: &Script,
         value: confidential::Value,
         sighash_type: EcdsaSighashType
-    ) -> SigHash {
-        let mut enc = SigHash::engine();
+    ) -> Sighash {
+        let mut enc = Sighash::engine();
         self.encode_segwitv0_signing_data_to(&mut enc, input_index, script_code, value, sighash_type)
             .expect("engines don't error");
-        SigHash::from_engine(enc)
+        Sighash::from_engine(enc)
     }
 
     /// Encodes the signing data from which a signature hash for a given input index with a given
@@ -692,11 +692,11 @@ impl<R: Deref<Target = Transaction>> SighashCache<R> {
         input_index: usize,
         script_pubkey: &Script,
         sighash_type: EcdsaSighashType,
-    ) -> SigHash {
-        let mut engine = SigHash::engine();
+    ) -> Sighash {
+        let mut engine = Sighash::engine();
         self.encode_legacy_signing_data_to(&mut engine, input_index, script_pubkey, sighash_type)
             .expect("engines don't error");
-        SigHash::from_engine(engine)
+        Sighash::from_engine(engine)
     }
 
     #[inline]
@@ -977,7 +977,7 @@ mod tests{
         let script = Script::from(Vec::<u8>::from_hex(script).unwrap());
         // A hack to parse sha256d strings are sha256 so that we don't reverse them...
         let raw_expected = crate::hashes::sha256::Hash::from_str(expected_result).unwrap();
-        let expected_result = SigHash::from_slice(&raw_expected[..]).unwrap();
+        let expected_result = Sighash::from_slice(&raw_expected[..]).unwrap();
 
         let mut cache = SighashCache::new(&tx);
         let value : confidential::Value = deserialize(&Vec::<u8>::from_hex(value).unwrap()[..]).unwrap();
@@ -1011,7 +1011,7 @@ mod tests{
         let script = Script::from(Vec::<u8>::from_hex(script).unwrap());
         // A hack to parse sha256d strings are sha256 so that we don't reverse them...
         let raw_expected = crate::hashes::sha256::Hash::from_str(expected_result).unwrap();
-        let expected_result = SigHash::from_slice(&raw_expected[..]).unwrap();
+        let expected_result = Sighash::from_slice(&raw_expected[..]).unwrap();
         let sighash_cache = SighashCache::new(&tx);
         let actual_result = sighash_cache.legacy_sighash(input_index, &script, hash_type);
         assert_eq!(actual_result, expected_result);

src/taproot.rs

@@ -44,7 +44,7 @@ const MIDSTATE_TAPTWEAK: [u8; 32] = [
 ];
 // (rev) 09fb0cfc0dd530c6cb0821906b00201b9d6daec928ad42fbf5072e8a793fb707
 
-/// The SHA-256 midstate value for the TapSigHash hash.
+/// The SHA-256 midstate value for the TapSighash hash.
 const MIDSTATE_TAPSIGHASH: [u8; 32] = [
     166, 230, 6, 120, 41, 228, 53, 167, 211, 20, 34, 171, 34, 191, 116, 23, 134,
     105, 138, 238, 229, 146, 92, 206, 255, 57, 14, 164, 52, 159, 126, 13