cargo fmt

Author: JoshOrndorff

tuxedo-core/src/executive.rs

@@ -80,9 +80,11 @@ where
         for input in transaction.inputs.iter() {
             if let Some(input_utxo) = TransparentUtxoSet::<V>::peek_utxo(&input.output_ref) {
                 ensure!(
-                    input_utxo
-                        .verifier
-                        .verify(&stripped_encoded, Self::block_height(), &input.redeemer),
+                    input_utxo.verifier.verify(
+                        &stripped_encoded,
+                        Self::block_height(),
+                        &input.redeemer
+                    ),
                     UtxoError::VerifierError
                 );
                 input_utxos.push(input_utxo);

tuxedo-core/src/verifier/htlc.rs

@@ -1,6 +1,6 @@
 //! This module contains `Verifier` implementations related to Hash Time Lock Contracts.
 //! It contains a simple hash lock, a simple time lock, and a hash time lock.
-//! 
+//!
 //! These could be used as the base of an atomic swap protocol with a similarly expressive
 //! utxo chain like Bitcoin. For atomic swaps with less expressive counter party chains,
 //! such as Monero, see the Farcaster protocol.
@@ -72,19 +72,25 @@ mod test {
 
     #[test]
     fn time_lock_too_soon() {
-        let time_lock = TimeLock { unlock_block_height: 100 };
+        let time_lock = TimeLock {
+            unlock_block_height: 100,
+        };
         assert!(!time_lock.verify(&[], 10, &[]));
     }
 
     #[test]
     fn time_lock_exactly_on_time() {
-        let time_lock = TimeLock { unlock_block_height: 100 };
+        let time_lock = TimeLock {
+            unlock_block_height: 100,
+        };
         assert!(time_lock.verify(&[], 100, &[]));
     }
 
     #[test]
     fn time_lock_past_threshold() {
-        let time_lock = TimeLock { unlock_block_height: 100 };
+        let time_lock = TimeLock {
+            unlock_block_height: 100,
+        };
         assert!(time_lock.verify(&[], 200, &[]));
     }
 
@@ -104,5 +110,4 @@ mod test {
         let hash_lock = BlakeTwoHashLock::new_from_secret(secret);
         assert!(!hash_lock.verify(&[], 0, &incorrect.encode()));
     }
-
-}
+}

tuxedo-core/src/verifier/multi_signature.rs

@@ -5,12 +5,14 @@
 /// guarded by this verifier. A valid redeemer must supply valid signatures by at least
 /// `threshold` of the signatories. If the threshold is greater than the number of signatories
 /// the input can never be consumed.
-
 use super::Verifier;
 use parity_scale_codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use serde::{Deserialize, Serialize};
-use sp_core::{H256, sr25519::{Public, Signature}};
+use sp_core::{
+    sr25519::{Public, Signature},
+    H256,
+};
 use sp_std::collections::{btree_map::BTreeMap, btree_set::BTreeSet};
 
 #[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone, TypeInfo)]
@@ -255,4 +257,4 @@ mod test {
             bogus.encode().as_slice()
         ))
     }
-}
+}

tuxedo-core/src/verifier/simple_signature.rs

@@ -1,22 +1,33 @@
 //! This module contains `Verifier` implementations for simple signature checking.
 //! This is the most common way to implement private ownership in a UTXO chain and will
 //! likely be used by most chains.
-//! 
-//! Currently there is only an implementation for SR25519 signatures that makes use of
+//!
+//! Directly locking a UTXO to a public key is supported as well as locking behind a
+//! public key hash like bitcoin's P2PKH. For the merits of each approach see:
+//! https://bitcoin.stackexchange.com/q/72184
+//!
+//! Currently there are only implementations for SR25519 signatures that makes use of
 //! Substrate's host functions to do the actual cryptography. Other signature schemes or
 //! pure wasm implementations are also welcome here.
 
 /// A very commonly used verifier that checks an sr25519 signature.
-/// 
+///
 /// This verifier relies on Substrate's host functions to perform the signature checking
 /// natively and gain performance.
-
 use super::Verifier;
 use parity_scale_codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use serde::{Deserialize, Serialize};
-use sp_core::{H256, sr25519::{Public, Signature}};
+use sp_core::{
+    sr25519::{Public, Signature},
+    H256,
+};
 
+/// Require a signature from the private key corresponding to the given public key.
+/// This is the simplest way to require a signature. If you prefer not to expose the
+/// public key until spend time, use P2PKH instead.
+///
+/// Uses the Sr25519 signature scheme and Substrate's host functions.
 #[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone, TypeInfo)]
 pub struct Sr25519Signature {
     pub owner_pubkey: H256,
@@ -42,6 +53,28 @@ impl Verifier for Sr25519Signature {
     }
 }
 
+/// Pay To Public Key Hash (P2PKH)
+///
+/// Require a signature from the private key corresponding to the public key whose _hash_ is given.
+/// This is the most common way to represent private ownership in UTXO networks like Bitcoin.
+/// It is more complex than providing the public key directly but does not reveal the public key until spend time.
+///
+/// Uses the Sr25519 signature scheme and Substrate's host functions.
+#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone, TypeInfo)]
+pub struct Sr25519P2PKH {
+    pub owner_pubkey_hash: H256,
+}
+
+impl Verifier for Sr25519P2PKH {
+    fn verify(&self, simplified_tx: &[u8], _: u32, redeemer: &[u8]) -> bool {
+        //TODO verifier trait should have associated type for decoding the redeemer. Otherwise each and every redeemer impl has to do it.
+        // Decode the redeemer and expect to find both a pubkey and a signature.
+        // Check that the hash stored matches the pubkey given.
+        // Check that the signature given is valid over the tx from the pubkey given.
+        todo!()
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -61,7 +94,6 @@ mod test {
         assert!(sr25519_signature.verify(simplified_tx, 0, redeemer));
     }
 
-
     #[test]
     fn sr25519_signature_with_bad_sig() {
         let simplified_tx = b"hello world".as_slice();
@@ -73,5 +105,4 @@ mod test {
 
         assert!(!sr25519_signature.verify(simplified_tx, 0, redeemer));
     }
-
-}
+}