Remove un-necessary lifetimes

Remove lifetime parameter concerning `PkH(Pk::Hash)` to `PkH(Pk)`
refactor.

Author: heap-coder

src/interpreter/mod.rs

@@ -590,15 +590,15 @@ where
                 Terminal::PkK(ref pk) => {
                     debug_assert_eq!(node_state.n_evaluated, 0);
                     debug_assert_eq!(node_state.n_satisfied, 0);
-                    let res = self.stack.evaluate_pk(&mut self.verify_sig, pk);
+                    let res = self.stack.evaluate_pk(&mut self.verify_sig, *pk);
                     if res.is_some() {
                         return res;
                     }
                 }
                 Terminal::PkH(ref pkh) => {
                     debug_assert_eq!(node_state.n_evaluated, 0);
                     debug_assert_eq!(node_state.n_satisfied, 0);
-                    let res = self.stack.evaluate_pkh(&mut self.verify_sig, pkh);
+                    let res = self.stack.evaluate_pkh(&mut self.verify_sig, *pkh);
                     if res.is_some() {
                         return res;
                     }
@@ -857,7 +857,7 @@ where
                         // push 1 on satisfied sigs and push 0 on empty sigs
                         match self
                             .stack
-                            .evaluate_pk(&mut self.verify_sig, &subs[node_state.n_evaluated])
+                            .evaluate_pk(&mut self.verify_sig, subs[node_state.n_evaluated])
                         {
                             Some(Ok(x)) => {
                                 self.push_evaluation_state(

src/interpreter/stack.rs

@@ -134,7 +134,7 @@ impl<'txin> Stack<'txin> {
     pub(super) fn evaluate_pk<'intp>(
         &mut self,
         verify_sig: &mut Box<dyn FnMut(&KeySigPair) -> bool + 'intp>,
-        pk: &'intp BitcoinKey,
+        pk: BitcoinKey,
     ) -> Option<Result<SatisfiedConstraint, Error>> {
         if let Some(sigser) = self.pop() {
             match sigser {
@@ -143,7 +143,7 @@ impl<'txin> Stack<'txin> {
                     None
                 }
                 Element::Push(sigser) => {
-                    let key_sig = verify_sersig(verify_sig, pk, sigser);
+                    let key_sig = verify_sersig(verify_sig, &pk, sigser);
                     match key_sig {
                         Ok(key_sig) => {
                             self.push(Element::Satisfied);
@@ -152,9 +152,7 @@ impl<'txin> Stack<'txin> {
                         Err(e) => Some(Err(e)),
                     }
                 }
-                Element::Satisfied => {
-                    Some(Err(Error::PkEvaluationError(PkEvalErrInner::from(*pk))))
-                }
+                Element::Satisfied => Some(Err(Error::PkEvaluationError(PkEvalErrInner::from(pk)))),
             }
         } else {
             Some(Err(Error::UnexpectedStackEnd))
@@ -170,7 +168,7 @@ impl<'txin> Stack<'txin> {
     pub(super) fn evaluate_pkh<'intp>(
         &mut self,
         verify_sig: &mut Box<dyn FnMut(&KeySigPair) -> bool + 'intp>,
-        pkh: &'intp TypedHash160,
+        pkh: TypedHash160,
     ) -> Option<Result<SatisfiedConstraint, Error>> {
         // Parse a bitcoin key from witness data slice depending on hash context
         // when we encounter a pkh(hash)
@@ -189,7 +187,7 @@ impl<'txin> Stack<'txin> {
             if pk_hash != pkh.hash160() {
                 return Some(Err(Error::PkHashVerifyFail(pkh.hash160())));
             }
-            match bitcoin_key_from_slice(pk, *pkh) {
+            match bitcoin_key_from_slice(pk, pkh) {
                 Some(pk) => {
                     if let Some(sigser) = self.pop() {
                         match sigser {