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
@@ -170,6 +171,8 @@ pub enum OuterConstraintChecker {
     Money(money::MoneyConstraintChecker<0>),
     /// Checks Free Kitty transactions
     FreeKittyConstraintChecker(kitties::FreeKittyConstraintChecker),
+    /// Checks tradable Kitty transactions
+    TradableKittyConstraintChecker(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
@@ -205,6 +208,8 @@ pub enum OuterConstraintChecker {
     Money(money::MoneyConstraintChecker<0>),
     /// Checks Free Kitty transactions
     FreeKittyConstraintChecker(kitties::FreeKittyConstraintChecker),
+    /// Checks Paid Kitty transactions
+    TradableKittyConstraintChecker(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,12 +1,31 @@
 //! 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
+//! This is a game which allows for kitties to be create,bred and update name of kitty.
+//!
+//! ## Features
+//!
+//! - **Create:** Generate a new kitty.
+//!   To submit a valid transaction for creating a kitty, adhere to the following structure:
+//!   1. Input must be empty.
+//!   2. Output must contain only the newly created kittities as a child.
+//!
+//!    **Note 1:** Multiple kitties can be created at the same time in the same txn..
+//!
+//! - **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. Input must be the kitty to be updated.
+//!   2. 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 same order.
+//!
+//! - **Breed:** Breeds a new kitty using mom and dad based on below factors
+//! 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 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
 //!
-//! In order to submit a valid transaction you must strutucture it as follows:
+//! In order to submit a valid transaction you must structure 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:
@@ -25,6 +44,7 @@ use sp_runtime::{
     traits::{BlakeTwo256, Hash as HashT},
     transaction_validity::TransactionPriority,
 };
+use sp_std::collections::btree_set::BTreeSet; // For checking the uniqueness of input and output based on dna.
 use sp_std::prelude::*;
 use tuxedo_core::{
     dynamic_typing::{DynamicallyTypedData, UtxoData},
@@ -36,6 +56,10 @@ use tuxedo_core::{
 #[cfg(test)]
 mod tests;
 
+/// The main constraint checker for the kitty piece. Allows below :
+/// Create : Allows creation of kitty without parents, Multiple kitties can be created in same txn.
+/// UpdateKittyName : Allows updating the name of the kitty s, Multiple kitty name can be updated in same txn.
+/// Breed : Allows breeding of kitty.
 #[derive(
     Serialize,
     Deserialize,
@@ -50,8 +74,16 @@ mod tests;
     Debug,
     TypeInfo,
 )]
-pub struct FreeKittyConstraintChecker;
+pub enum FreeKittyConstraintChecker {
+    /// Txn that creates kitty without parents.Multiple kitties can be created  at the same time.
+    Create,
+    /// Txn that updates kitty Name. Multiple kitty names can be updated. input & output must follow the same order.
+    UpdateKittyName,
+    /// Txn where kitties are consumed and new family(Parents(mom,dad) and child) is created.
+    Breed,
+}
 
+/// Dad kitty status with respect to breeding.
 #[derive(
     Serialize,
     Deserialize,
@@ -69,10 +101,13 @@ pub struct FreeKittyConstraintChecker;
 )]
 pub enum DadKittyStatus {
     #[default]
+    /// Can breed.
     RearinToGo,
+    /// Can't breed due to tired.
     Tired,
 }
 
+/// Mad kitty status with respect to breeding.
 #[derive(
     Serialize,
     Deserialize,
@@ -90,10 +125,13 @@ pub enum DadKittyStatus {
 )]
 pub enum MomKittyStatus {
     #[default]
+    /// Can breed.
     RearinToGo,
+    /// Can't breed due to recent child kitty delivery.
     HadBirthRecently,
 }
 
+/// Parent stuct contains 1 mom kitty and 1 dad kitty.
 #[derive(
     Serialize,
     Deserialize,
@@ -146,6 +184,12 @@ impl Default for Parent {
 )]
 pub struct KittyDNA(pub H256);
 
+/// Kitty data contains basic informationsuch as below :
+/// parent: 1 mom kitty and 1 dad kitty.
+/// free_breedings: Free breeding allowed on a kitty.
+/// dna :Its a unique per kitty.
+/// num_breedings: number of free breedings are remaining.
+/// name: Name of kitty.
 #[derive(
     Serialize,
     Deserialize,
@@ -165,6 +209,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 +232,7 @@ impl KittyData {
                 v,
             )
                 .into()],
-            checker: FreeKittyConstraintChecker.into(),
+            checker: FreeKittyConstraintChecker::Create.into(),
         }
     }
 }
@@ -199,6 +244,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 +253,7 @@ impl UtxoData for KittyData {
     const TYPE_ID: [u8; 4] = *b"Kitt";
 }
 
+/// Reasons that kitty opertaion may go wrong.
 #[derive(
     Serialize,
     Deserialize,
@@ -261,9 +308,27 @@ pub enum ConstraintCheckerError {
     TooManyBreedingsForKitty,
     /// Not enough free breedings available for these parents.
     NotEnoughFreeBreedings,
+    /// The transaction attempts to create no Kitty.
+    CreatingNothing,
+    /// Inputs(Parents) not required for mint.
+    CreatingWithInputs,
+    /// No input for kitty Update.
+    InvalidNumberOfInputOutput,
+    /// Duplicate kitty found i.e based on the DNA.
+    DuplicateKittyFound,
+    /// 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 +565,116 @@ 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);
+        match &self {
+            Self::Create => {
+                // Make sure there are no inputs being consumed
+                ensure!(
+                    input_data.is_empty(),
+                    ConstraintCheckerError::CreatingWithInputs
+                );
+
+                // Make sure there is at least one output being minted
+                ensure!(
+                    !output_data.is_empty(),
+                    ConstraintCheckerError::CreatingNothing
+                );
+
+                // Make sure 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, 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)
+            }
+        }
+    }
+}
 
-        KittyHelpers::check_new_family(&mom, &dad, output_data)?;
+/// Checks:
+///     - Input and output is of kittyType
+///     - Only name is updated and ther basic properties are not updated.
+///     - Order between input and output must be 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::InvalidNumberOfInputOutput }
+    );
+    let mut dna_to_kitty_set: BTreeSet<KittyDNA> = BTreeSet::new();
+
+    for i in 0..input_data.len() {
+        let utxo_input_kitty = input_data[i]
+            .clone()
+            .extract::<KittyData>()
+            .map_err(|_| ConstraintCheckerError::BadlyTyped)?;
+
+        if dna_to_kitty_set.contains(&utxo_input_kitty.dna) {
+            return Err(ConstraintCheckerError::DuplicateKittyFound);
+        } else {
+            dna_to_kitty_set.insert(utxo_input_kitty.clone().dna);
+        }
 
-        Ok(0)
+        let utxo_output_kitty = output_data[i]
+            .clone()
+            .extract::<KittyData>()
+            .map_err(|_| ConstraintCheckerError::BadlyTyped)?;
+        if utxo_input_kitty.dna != utxo_output_kitty.dna {
+            return Err(ConstraintCheckerError::DnaMismatchBetweenInputAndOutput);
+        }
+        check_kitty_name_update(&utxo_input_kitty, &utxo_output_kitty)?;
     }
+    return Ok(0);
+}
+
+/// Checks:
+///     - Private function used by can_kitty_name_be_updated.
+///     - Only name is updated and ther basic properties are not updated.
+///
+fn check_kitty_name_update(
+    original_kitty: &KittyData,
+    updated_kitty: &KittyData,
+) -> Result<TransactionPriority, ConstraintCheckerError> {
+    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
+    );
+    return Ok(0);
 }