TradableKitty piece

tuxedo-template-runtime/Cargo.toml

@@ -40,6 +40,7 @@ money = { default-features = false, path = "../wardrobe/money" }
 poe = { default-features = false, path = "../wardrobe/poe" }
 runtime-upgrade = { default-features = false, path = "../wardrobe/runtime_upgrade" }
 timestamp = { default-features = false, path = "../wardrobe/timestamp" }
+tradable-kitties = { default-features = false, path = "../wardrobe/tradable_kitties" }
 tuxedo-core = { default-features = false, path = "../tuxedo-core" }
 
 # Parachain related ones

tuxedo-template-runtime/src/lib.rs

@@ -45,6 +45,7 @@ pub use money;
 pub use poe;
 pub use runtime_upgrade;
 pub use timestamp;
+pub use tradable_kitties;
 
 /// Opaque types. These are used by the CLI to instantiate machinery that don't need to know
 /// the specifics of the runtime. They can then be made to be agnostic over specific formats
@@ -169,7 +170,9 @@ pub enum OuterConstraintChecker {
     /// Checks monetary transactions in a basic fungible cryptocurrency
     Money(money::MoneyConstraintChecker<0>),
     /// Checks Free Kitty transactions
-    FreeKittyConstraintChecker(kitties::FreeKittyConstraintChecker),
+    FreeKitty(kitties::FreeKittyConstraintChecker),
+    /// Checks tradable Kitty transactions
+    TradableKitty(tradable_kitties::TradableKittyConstraintChecker<0>),
     /// Checks that an amoeba can split into two new amoebas
     AmoebaMitosis(amoeba::AmoebaMitosis),
     /// Checks that a single amoeba is simply removed from the state
@@ -204,7 +207,9 @@ pub enum OuterConstraintChecker {
     /// Checks monetary transactions in a basic fungible cryptocurrency
     Money(money::MoneyConstraintChecker<0>),
     /// Checks Free Kitty transactions
-    FreeKittyConstraintChecker(kitties::FreeKittyConstraintChecker),
+    FreeKitty(kitties::FreeKittyConstraintChecker),
+    /// Checks Paid Kitty transactions
+    TradableKitty(tradable_kitties::TradableKittyConstraintChecker<0>),
     /// Checks that an amoeba can split into two new amoebas
     AmoebaMitosis(amoeba::AmoebaMitosis),
     /// Checks that a single amoeba is simply removed from the state

wardrobe/kitties/src/lib.rs

@@ -1,18 +1,36 @@
-//! An NFT game inspired by cryptokitties.
-//! This is a game which allows for kitties to be bred based on a few factors
-//! 1.) Mom and Tired have to be in a state where they are ready to breed
-//! 2.) Each Mom and Dad have some DNA and the child will have unique DNA combined from the both of them
-//!     Linkable back to the Mom and Dad
-//! 3.) The game also allows Kitties to have a cooling off period inbetween breeding before they can be bred again.
-//! 4.) A rest operation allows for a Mom Kitty and a Dad Kitty to be cooled off
+//! An NFT game inspired by Cryptokitties.
+//! This is a game that allows for the creation, breeding, and updating of the name of kitties.
 //!
-//! In order to submit a valid transaction you must strutucture it as follows:
-//! 1.) Input must contain 1 mom and 1 dad
-//! 2.) Output must contain Mom, Dad, and newly created Child
-//! 3.) A child's DNA is calculated by:
+//! ## Features
+//!
+//! - **Create:** Generate a new kitty.
+//!   To submit a valid transaction for creating a kitty, adhere to the following structure:
+//!   1. The input must be empty.
+//!   2. The output must contain only the newly created kitties as a child.
+//!
+//!    **Note 1:** Multiple kitties can be created at the same time in the same transaction.
+//!
+//! - **Update Name:** Modify the name of a kitty.
+//!   To submit a valid transaction for updating a kitty's name, adhere to the following structure:
+//!   1. The input must be the kitty to be updated.
+//!   2. The output must contain the kitty with the updated name.
+//!
+//!    **Note 1:** All other properties, such as DNA, parents, free breedings, etc., must remain unaltered in the output.
+//!    **Note 2:** The input and output kitties must follow the same order.
+//!
+//! - **Breed:** Breed a new kitty using mom and dad based on the factors below:
+//!   1. Mom and Dad have to be in a state where they are ready to breed.
+//!   2. Each Mom and Dad have some DNA, and the child will have unique DNA combined from both of them, linkable back to the Mom and Dad.
+//!   3. The game also allows kitties to have a cooling-off period in between breeding before they can be bred again.
+//!   4. A rest operation allows for a Mom Kitty and a Dad Kitty to cool off.
+//!
+//! In order to submit a valid breed transaction, you must structure it as follows:
+//!   1. The input must contain 1 mom and 1 dad.
+//!   2. The output must contain Mom, Dad, and the newly created Child.
+//!   3. A child's DNA is calculated by:
 //!         BlakeTwo256::hash_of(MomDna, DadDna, MomCurrNumBreedings, DadCurrNumberBreedings)
 //!
-//! There are a only a finite amount of free breedings available before it starts to cost money
+//! There are only a finite amount of free breedings available before it starts to cost money
 //! to breed kitties.
 
 #![cfg_attr(not(feature = "std"), no_std)]
@@ -36,6 +54,10 @@ use tuxedo_core::{
 #[cfg(test)]
 mod tests;
 
+/// The main constraint checker for the kitty piece. Allows the following:
+/// Create: Allows the creation of a kitty without parents. Multiple kitties can be created in the same transaction.
+/// UpdateKittyName: Allows updating the names of the kitties. Multiple kitty names can be updated in the same transaction.
+/// Breed: Allows the breeding of kitties.
 #[derive(
     Serialize,
     Deserialize,
@@ -50,8 +72,16 @@ mod tests;
     Debug,
     TypeInfo,
 )]
-pub struct FreeKittyConstraintChecker;
+pub enum FreeKittyConstraintChecker {
+    /// Transaction that creates a kitty without parents. Multiple kitties can be created at the same time
+    Create,
+    /// Transaction that updates kitty names. Multiple kitty names can be updated. Input and output must follow the same order
+    UpdateKittyName,
+    /// Transaction where kitties are consumed, and a new family (parents: mom, dad, and child) is created.
+    Breed,
+}
 
+/// Dad Kitty's breeding status.
 #[derive(
     Serialize,
     Deserialize,
@@ -69,10 +99,13 @@ pub struct FreeKittyConstraintChecker;
 )]
 pub enum DadKittyStatus {
     #[default]
+    /// Can breed.
     RearinToGo,
+    /// Can't breed due to tired.
     Tired,
 }
 
+/// Mom Kitty's breeding status.
 #[derive(
     Serialize,
     Deserialize,
@@ -90,10 +123,13 @@ pub enum DadKittyStatus {
 )]
 pub enum MomKittyStatus {
     #[default]
+    /// Can breed.
     RearinToGo,
+    /// Can't breed due to a recent delivery of kittens.
     HadBirthRecently,
 }
 
+/// The parent structure contains 1 mom kitty and 1 dad kitty.
 #[derive(
     Serialize,
     Deserialize,
@@ -146,6 +182,12 @@ impl Default for Parent {
 )]
 pub struct KittyDNA(pub H256);
 
+/// Kitty data contains basic information such as below:
+/// parent: 1 mom kitty and 1 dad kitty.
+/// free_breedings: Free breeding allowed on a kitty.
+/// dna: It's unique per kitty.
+/// num_breedings: Number of free breedings remaining.
+/// name: Name of kitty.
 #[derive(
     Serialize,
     Deserialize,
@@ -165,6 +207,7 @@ pub struct KittyData {
     pub free_breedings: u64, // Ignore in breed for money case
     pub dna: KittyDNA,
     pub num_breedings: u128,
+    pub name: [u8; 4],
 }
 
 impl KittyData {
@@ -187,7 +230,7 @@ impl KittyData {
                 v,
             )
                 .into()],
-            checker: FreeKittyConstraintChecker.into(),
+            checker: FreeKittyConstraintChecker::Create.into(),
         }
     }
 }
@@ -199,6 +242,7 @@ impl Default for KittyData {
             free_breedings: 2,
             dna: KittyDNA(H256::from_slice(b"mom_kitty_1asdfasdfasdfasdfasdfa")),
             num_breedings: 3,
+            name: *b"kity",
         }
     }
 }
@@ -207,6 +251,7 @@ impl UtxoData for KittyData {
     const TYPE_ID: [u8; 4] = *b"Kitt";
 }
 
+/// Reasons that kitty opertaion may go wrong.
 #[derive(
     Serialize,
     Deserialize,
@@ -261,9 +306,25 @@ pub enum ConstraintCheckerError {
     TooManyBreedingsForKitty,
     /// Not enough free breedings available for these parents.
     NotEnoughFreeBreedings,
+    /// The transaction attempts to create no Kitty.
+    CreatingNothing,
+    /// Inputs (Parents) are not required for kitty creation.
+    CreatingWithInputs,
+    /// The number of inputs does not match the number of outputs for a transaction.
+    NumberOfInputOutputMismatch,
+    /// DNA mismatch between input and output.
+    DnaMismatchBetweenInputAndOutput,
+    /// Name is not updated
+    KittyNameUnAltered,
+    /// Kitty FreeBreeding cannot be updated.
+    FreeBreedingCannotBeUpdated,
+    /// Kitty NumOfBreeding cannot be updated.
+    NumOfBreedingCannotBeUpdated,
+    /// Gender cannot be updated.
+    KittyGenderCannotBeUpdated,
 }
 
-trait Breed {
+pub trait Breed {
     /// The Cost to breed a kitty if it is not free.
     const COST: u128;
     /// Number of free breedings a kitty will have.
@@ -500,28 +561,111 @@ impl TryFrom<&DynamicallyTypedData> for KittyData {
 
 impl SimpleConstraintChecker for FreeKittyConstraintChecker {
     type Error = ConstraintCheckerError;
-    /// Checks:
-    ///     - `input_data` is of length 2
-    ///     - `output_data` is of length 3
-    ///
+
     fn check(
         &self,
         input_data: &[DynamicallyTypedData],
         _peeks: &[DynamicallyTypedData],
         output_data: &[DynamicallyTypedData],
     ) -> Result<TransactionPriority, Self::Error> {
-        // Input must be a Mom and a Dad
-        ensure!(input_data.len() == 2, Self::Error::TwoParentsDoNotExist);
-
-        let mom = KittyData::try_from(&input_data[0])?;
-        let dad = KittyData::try_from(&input_data[1])?;
-        KittyHelpers::can_breed(&mom, &dad)?;
-
-        // Output must be Mom, Dad, Child
-        ensure!(output_data.len() == 3, Self::Error::NotEnoughFamilyMembers);
-
-        KittyHelpers::check_new_family(&mom, &dad, output_data)?;
+        match &self {
+            Self::Create => {
+                // Ensure that no inputs are being consumed.
+                ensure!(
+                    input_data.is_empty(),
+                    ConstraintCheckerError::CreatingWithInputs
+                );
+
+                // Ensure that at least one kitty is being created.
+                ensure!(
+                    !output_data.is_empty(),
+                    ConstraintCheckerError::CreatingNothing
+                );
+
+                // Ensure the outputs are the right type.
+                for utxo in output_data {
+                    let _utxo_kitty = utxo
+                        .extract::<KittyData>()
+                        .map_err(|_| ConstraintCheckerError::BadlyTyped)?;
+                }
+                Ok(0)
+            }
+            Self::Breed => {
+                // Check that we are consuming at least one input.
+                ensure!(input_data.len() == 2, Self::Error::TwoParentsDoNotExist);
+
+                let mom = KittyData::try_from(&input_data[0])?;
+                let dad = KittyData::try_from(&input_data[1])?;
+                KittyHelpers::can_breed(&mom, &dad)?;
+                // Output must be Mom, Dad, and Child.
+                ensure!(output_data.len() == 3, Self::Error::NotEnoughFamilyMembers);
+                KittyHelpers::check_new_family(&mom, &dad, output_data)?;
+                Ok(0)
+            }
+            Self::UpdateKittyName => {
+                can_kitty_name_be_updated(input_data, output_data)?;
+                Ok(0)
+            }
+        }
+    }
+}
 
-        Ok(0)
+/// Checks:
+///     - Input and output are of kittyType.
+///     - Only the name is updated, and other basic properties are not modified.
+///     - The order between input and output must be the same.
+pub fn can_kitty_name_be_updated(
+    input_data: &[DynamicallyTypedData],
+    output_data: &[DynamicallyTypedData],
+) -> Result<TransactionPriority, ConstraintCheckerError> {
+    ensure!(
+        input_data.len() == output_data.len() && !input_data.is_empty(),
+        { ConstraintCheckerError::NumberOfInputOutputMismatch }
+    );
+
+    for (input, output) in input_data.iter().zip(output_data.iter()) {
+        let utxo_input_kitty = input
+            .clone()
+            .extract::<KittyData>()
+            .map_err(|_| ConstraintCheckerError::BadlyTyped)?;
+
+        let utxo_output_kitty = output
+            .clone()
+            .extract::<KittyData>()
+            .map_err(|_| ConstraintCheckerError::BadlyTyped)?;
+
+        check_kitty_name_update(&utxo_input_kitty, &utxo_output_kitty)?;
     }
+    Ok(0)
+}
+
+/// Checks:
+///     - This is a private function used by can_kitty_name_be_updated.
+///     - Only the name is updated, and other basic properties are not updated.
+///
+fn check_kitty_name_update(
+    original_kitty: &KittyData,
+    updated_kitty: &KittyData,
+) -> Result<TransactionPriority, ConstraintCheckerError> {
+    ensure!(
+        original_kitty.dna == updated_kitty.dna,
+        ConstraintCheckerError::DnaMismatchBetweenInputAndOutput
+    );
+    ensure!(
+        original_kitty != updated_kitty,
+        ConstraintCheckerError::KittyNameUnAltered
+    );
+    ensure!(
+        original_kitty.free_breedings == updated_kitty.free_breedings,
+        ConstraintCheckerError::FreeBreedingCannotBeUpdated
+    );
+    ensure!(
+        original_kitty.num_breedings == updated_kitty.num_breedings,
+        ConstraintCheckerError::NumOfBreedingCannotBeUpdated
+    );
+    ensure!(
+        original_kitty.parent == updated_kitty.parent,
+        ConstraintCheckerError::KittyGenderCannotBeUpdated
+    );
+    Ok(0)
 }