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,5 +1,21 @@
 //! An NFT game inspired by cryptokitties.
-//! This is a game which allows for kitties to be bred based on a few factors
+//! 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 kitty as a child.
+
+//! - **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:** All other properties such as DNA, parents, free breedings, etc., must remain unaltered in the output.
+//!
+//! - **Breed:** Breeds a new kitty using mom and dad based on below 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
@@ -25,6 +41,7 @@ use sp_runtime::{
     traits::{BlakeTwo256, Hash as HashT},
     transaction_validity::TransactionPriority,
 };
+use sp_std::collections::btree_map::BTreeMap;
 use sp_std::prelude::*;
 use tuxedo_core::{
     dynamic_typing::{DynamicallyTypedData, UtxoData},
@@ -50,7 +67,14 @@ mod tests;
     Debug,
     TypeInfo,
 )]
-pub struct FreeKittyConstraintChecker;
+pub enum FreeKittyConstraintChecker {
+    /// A transaction that creates kitty without parents.
+    Create,
+    /// A Transaction that updates kitty Name.
+    UpdateKittyName,
+    /// A transaction where kitties are consumed and new family(Parents(mom,dad) and child) is created.
+    Breed,
+}
 
 #[derive(
     Serialize,
@@ -165,6 +189,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 +212,7 @@ impl KittyData {
                 v,
             )
                 .into()],
-            checker: FreeKittyConstraintChecker.into(),
+            checker: FreeKittyConstraintChecker::Create.into(),
         }
     }
 }
@@ -199,6 +224,7 @@ impl Default for KittyData {
             free_breedings: 2,
             dna: KittyDNA(H256::from_slice(b"mom_kitty_1asdfasdfasdfasdfasdfa")),
             num_breedings: 3,
+            name: *b"kity",
         }
     }
 }
@@ -261,9 +287,25 @@ 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,
+    /// Updating nothing
+    OutputUtxoMissingError,
+    /// 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 +542,115 @@ 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)?;
+        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)
+            }
+        }
+    }
+}
 
-        // Output must be Mom, Dad, Child
-        ensure!(output_data.len() == 3, Self::Error::NotEnoughFamilyMembers);
+/// Checks:
+///     - Input and output is of kittyType
+///     - Only name is updated and ther basicproperties are not updated.
+///
+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 map: BTreeMap<KittyDNA, KittyData> = BTreeMap::new();
+
+    for utxo in input_data {
+        let utxo_kitty = utxo
+            .extract::<KittyData>()
+            .map_err(|_| ConstraintCheckerError::BadlyTyped)?;
+        map.insert(utxo_kitty.clone().dna, utxo_kitty);
+    }
 
-        KittyHelpers::check_new_family(&mom, &dad, output_data)?;
+    for utxo in output_data {
+        let utxo_output_kitty = utxo
+            .extract::<KittyData>()
+            .map_err(|_| ConstraintCheckerError::BadlyTyped)?;
 
-        Ok(0)
+        if let Some(input_kitty) = map.remove(&utxo_output_kitty.dna) {
+            // Element found, access the value
+            check_kitty_name_update(&input_kitty, &utxo_output_kitty)?;
+        } else {
+            return Err(ConstraintCheckerError::OutputUtxoMissingError);
+        }
     }
+    return Ok(0);
+}
+
+/// Checks:
+///     - Private function used by can_kitty_name_be_updated.
+///     - Only name is updated and ther basicproperties 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);
 }