Separate Mint from Spend

Author: JoshOrndorff

wardrobe/money/src/lib.rs

@@ -26,9 +26,28 @@ impl<const ID: u8> Cash for Coin<ID> {
     const ID: u8 = ID;
 }
 
-// use log::info;
+#[derive(
+    Serialize,
+    Deserialize,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Encode,
+    Decode,
+    Hash,
+    Debug,
+    TypeInfo,
+)]
+/// A typical spend transaction where some coins are consumed and others are created.
+/// Input value must exceed output value. The difference is burned and reflected in the
+/// transaction's priority.
+///
+/// This is the primary way to move money around the economy. Allows managing your own
+/// coins as well as paying others.
+pub struct Spend<const ID: u8>;
 
-/// The main constraint checker for the money piece. Allows spending and minting tokens.
 #[derive(
     Serialize,
     Deserialize,
@@ -43,16 +62,9 @@ impl<const ID: u8> Cash for Coin<ID> {
     Debug,
     TypeInfo,
 )]
-pub enum MoneyConstraintChecker<const ID: u8> {
-    /// A typical spend transaction where some coins are consumed and others are created.
-    /// Input value must exceed output value. The difference is burned and reflected in the
-    /// transaction's priority.
-    Spend,
-    /// A mint transaction that creates no coins out of the void. In a real-world chain,
-    /// this should be protected somehow, or not included at all. For now it is publicly
-    /// available. I'm adding it to explore multiple validation paths in a single piece.
-    Mint,
-}
+/// A mint transaction that creates no coins out of the void. In a real-world chain,
+/// this should be protected somehow, or not included at all.
+pub struct Mint<const ID: u8>;
 
 /// A single coin in the fungible money system.
 /// A new-type wrapper around a `u128` value.
@@ -82,13 +94,15 @@ impl<const ID: u8> Coin<ID> {
     where
         V: Verifier,
         OV: Verifier + From<V>,
-        OC: tuxedo_core::ConstraintChecker<OV> + From<MoneyConstraintChecker<ID>>,
+        // FIXME https://github.com/Off-Narrative-Labs/Tuxedo/issues/177
+        // Do these bounds respect nested piece aggregation?
+        OC: tuxedo_core::ConstraintChecker<OV> + From<Mint<ID>>,
     {
         Transaction {
             inputs: vec![],
             peeks: vec![],
             outputs: vec![(Self::new(amt), v).into()],
-            checker: MoneyConstraintChecker::Mint.into(),
+            checker: Mint.into(),
         }
     }
 }
@@ -135,7 +149,7 @@ pub enum ConstraintCheckerError {
     ZeroValueCoin,
 }
 
-impl<const ID: u8> SimpleConstraintChecker for MoneyConstraintChecker<ID> {
+impl<const ID: u8> SimpleConstraintChecker for Spend<ID> {
     type Error = ConstraintCheckerError;
 
     fn check(
@@ -144,78 +158,84 @@ impl<const ID: u8> SimpleConstraintChecker for MoneyConstraintChecker<ID> {
         _peeks: &[DynamicallyTypedData],
         output_data: &[DynamicallyTypedData],
     ) -> Result<TransactionPriority, Self::Error> {
-        match &self {
-            Self::Spend => {
-                // Check that we are consuming at least one input
-                ensure!(
-                    !input_data.is_empty(),
-                    ConstraintCheckerError::SpendingNothing
-                );
-
-                let mut total_input_value: u128 = 0;
-                let mut total_output_value: u128 = 0;
-
-                // Check that sum of input values < output values
-                for input in input_data {
-                    let utxo_value = input
-                        .extract::<Coin<ID>>()
-                        .map_err(|_| ConstraintCheckerError::BadlyTyped)?
-                        .0;
-                    total_input_value = total_input_value
-                        .checked_add(utxo_value)
-                        .ok_or(ConstraintCheckerError::ValueOverflow)?;
-                }
-
-                for utxo in output_data {
-                    let utxo_value = utxo
-                        .extract::<Coin<ID>>()
-                        .map_err(|_| ConstraintCheckerError::BadlyTyped)?
-                        .0;
-                    ensure!(utxo_value > 0, ConstraintCheckerError::ZeroValueCoin);
-                    total_output_value = total_output_value
-                        .checked_add(utxo_value)
-                        .ok_or(ConstraintCheckerError::ValueOverflow)?;
-                }
-
-                ensure!(
-                    total_output_value <= total_input_value,
-                    ConstraintCheckerError::OutputsExceedInputs
-                );
-
-                // Priority is based on how many token are burned
-                // Type stuff is kinda ugly. Maybe division would be better?
-                let burned = total_input_value - total_output_value;
-                Ok(if burned < u64::max_value() as u128 {
-                    burned as u64
-                } else {
-                    u64::max_value()
-                })
-            }
-            Self::Mint => {
-                // Make sure there are no inputs being consumed
-                ensure!(
-                    input_data.is_empty(),
-                    ConstraintCheckerError::MintingWithInputs
-                );
-
-                // Make sure there is at least one output being minted
-                ensure!(
-                    !output_data.is_empty(),
-                    ConstraintCheckerError::MintingNothing
-                );
-
-                // Make sure the outputs are the right type
-                for utxo in output_data {
-                    let utxo_value = utxo
-                        .extract::<Coin<ID>>()
-                        .map_err(|_| ConstraintCheckerError::BadlyTyped)?
-                        .0;
-                    ensure!(utxo_value > 0, ConstraintCheckerError::ZeroValueCoin);
-                }
-
-                // No priority for minting
-                Ok(0)
-            }
+        // Check that we are consuming at least one input
+        ensure!(
+            !input_data.is_empty(),
+            ConstraintCheckerError::SpendingNothing
+        );
+
+        let mut total_input_value: u128 = 0;
+        let mut total_output_value: u128 = 0;
+
+        // Check that sum of input values < output values
+        for input in input_data {
+            let utxo_value = input
+                .extract::<Coin<ID>>()
+                .map_err(|_| ConstraintCheckerError::BadlyTyped)?
+                .0;
+            total_input_value = total_input_value
+                .checked_add(utxo_value)
+                .ok_or(ConstraintCheckerError::ValueOverflow)?;
         }
+
+        for utxo in output_data {
+            let utxo_value = utxo
+                .extract::<Coin<ID>>()
+                .map_err(|_| ConstraintCheckerError::BadlyTyped)?
+                .0;
+            ensure!(utxo_value > 0, ConstraintCheckerError::ZeroValueCoin);
+            total_output_value = total_output_value
+                .checked_add(utxo_value)
+                .ok_or(ConstraintCheckerError::ValueOverflow)?;
+        }
+
+        ensure!(
+            total_output_value <= total_input_value,
+            ConstraintCheckerError::OutputsExceedInputs
+        );
+
+        // Priority is based on how many token are burned
+        // Type stuff is kinda ugly. Maybe division would be better?
+        let burned = total_input_value - total_output_value;
+        Ok(if burned < u64::max_value() as u128 {
+            burned as u64
+        } else {
+            u64::max_value()
+        })
+    }
+}
+
+impl<const ID: u8> SimpleConstraintChecker for Mint<ID> {
+    type Error = ConstraintCheckerError;
+
+    fn check(
+        &self,
+        input_data: &[DynamicallyTypedData],
+        _peeks: &[DynamicallyTypedData],
+        output_data: &[DynamicallyTypedData],
+    ) -> Result<TransactionPriority, Self::Error> {
+        // Make sure there are no inputs being consumed
+        ensure!(
+            input_data.is_empty(),
+            ConstraintCheckerError::MintingWithInputs
+        );
+
+        // Make sure there is at least one output being minted
+        ensure!(
+            !output_data.is_empty(),
+            ConstraintCheckerError::MintingNothing
+        );
+
+        // Make sure the outputs are the right type
+        for utxo in output_data {
+            let utxo_value = utxo
+                .extract::<Coin<ID>>()
+                .map_err(|_| ConstraintCheckerError::BadlyTyped)?
+                .0;
+            ensure!(utxo_value > 0, ConstraintCheckerError::ZeroValueCoin);
+        }
+
+        // No priority for minting
+        Ok(0)
     }
 }

wardrobe/money/src/tests.rs

@@ -10,7 +10,7 @@ fn spend_valid_transaction_work() {
     let expected_priority = 1u64;
 
     assert_eq!(
-        MoneyConstraintChecker::<0>::Spend.check(&input_data, &[], &output_data),
+        Spend::<0>.check(&input_data, &[], &output_data),
         Ok(expected_priority),
     );
 }
@@ -25,7 +25,7 @@ fn spend_with_zero_value_output_fails() {
     ]; // total 11
 
     assert_eq!(
-        MoneyConstraintChecker::<0>::Spend.check(&input_data, &[], &output_data),
+        Spend::<0>.check(&input_data, &[], &output_data),
         Err(ConstraintCheckerError::ZeroValueCoin),
     );
 }
@@ -37,7 +37,7 @@ fn spend_no_outputs_is_a_burn() {
     let expected_priority = 12u64;
 
     assert_eq!(
-        MoneyConstraintChecker::<0>::Spend.check(&input_data, &[], &output_data),
+        Spend::<0>.check(&input_data, &[], &output_data),
         Ok(expected_priority),
     );
 }
@@ -48,7 +48,7 @@ fn spend_no_inputs_fails() {
     let output_data = vec![Coin::<0>(10).into(), Coin::<0>(1).into()];
 
     assert_eq!(
-        MoneyConstraintChecker::<0>::Spend.check(&input_data, &[], &output_data),
+        Spend::<0>.check(&input_data, &[], &output_data),
         Err(ConstraintCheckerError::SpendingNothing),
     );
 }
@@ -59,7 +59,7 @@ fn spend_wrong_input_type_fails() {
     let output_data = vec![Coin::<0>(10).into(), Coin::<0>(1).into()];
 
     assert_eq!(
-        MoneyConstraintChecker::<0>::Spend.check(&input_data, &[], &output_data),
+        Spend::<0>.check(&input_data, &[], &output_data),
         Err(ConstraintCheckerError::BadlyTyped),
     );
 }
@@ -70,7 +70,7 @@ fn spend_wrong_output_type_fails() {
     let output_data = vec![Bogus.into()];
 
     assert_eq!(
-        MoneyConstraintChecker::<0>::Spend.check(&input_data, &[], &output_data),
+        Spend::<0>.check(&input_data, &[], &output_data),
         Err(ConstraintCheckerError::BadlyTyped),
     );
 }
@@ -81,7 +81,7 @@ fn spend_output_value_exceeds_input_value_fails() {
     let output_data = vec![Coin::<0>(5).into(), Coin::<0>(7).into()]; // total 12
 
     assert_eq!(
-        MoneyConstraintChecker::<0>::Spend.check(&input_data, &[], &output_data),
+        Spend::<0>.check(&input_data, &[], &output_data),
         Err(ConstraintCheckerError::OutputsExceedInputs),
     );
 }
@@ -91,10 +91,7 @@ fn mint_valid_transaction_works() {
     let input_data = vec![];
     let output_data = vec![Coin::<0>(10).into(), Coin::<0>(1).into()];
 
-    assert_eq!(
-        MoneyConstraintChecker::<0>::Mint.check(&input_data, &[], &output_data),
-        Ok(0),
-    );
+    assert_eq!(Mint::<0>.check(&input_data, &[], &output_data), Ok(0),);
 }
 
 #[test]
@@ -103,7 +100,7 @@ fn mint_with_zero_value_output_fails() {
     let output_data = vec![Coin::<0>(0).into()];
 
     assert_eq!(
-        MoneyConstraintChecker::<0>::Mint.check(&input_data, &[], &output_data),
+        Mint::<0>.check(&input_data, &[], &output_data),
         Err(ConstraintCheckerError::ZeroValueCoin),
     );
 }
@@ -114,7 +111,7 @@ fn mint_with_inputs_fails() {
     let output_data = vec![Coin::<0>(10).into(), Coin::<0>(1).into()];
 
     assert_eq!(
-        MoneyConstraintChecker::<0>::Mint.check(&input_data, &[], &output_data),
+        Mint::<0>.check(&input_data, &[], &output_data),
         Err(ConstraintCheckerError::MintingWithInputs),
     );
 }
@@ -125,7 +122,7 @@ fn mint_with_no_outputs_fails() {
     let output_data = vec![];
 
     assert_eq!(
-        MoneyConstraintChecker::<0>::Mint.check(&input_data, &[], &output_data),
+        Mint::<0>.check(&input_data, &[], &output_data),
         Err(ConstraintCheckerError::MintingNothing),
     );
 }
@@ -136,7 +133,7 @@ fn mint_wrong_output_type_fails() {
     let output_data = vec![Coin::<0>(10).into(), Bogus.into()];
 
     assert_eq!(
-        MoneyConstraintChecker::<0>::Mint.check(&input_data, &[], &output_data),
+        Mint::<0>.check(&input_data, &[], &output_data),
         Err(ConstraintCheckerError::BadlyTyped),
     );
 }