contracts: update && add tests

contracts/src/blobert.cairo

@@ -1,6 +1,6 @@
 use blob::types::erc721::MintStartTime;
 use blob::types::erc721::Supply;
-use blob::types::erc721::TokenIdentifier;
+use blob::types::erc721::TokenTrait;
 use blob::types::erc721::WhitelistTier;
 use blob::types::seeder::Seed;
 use starknet::ContractAddress;
@@ -25,7 +25,7 @@ trait IBlobert<TContractState> {
     // contract state read
     fn supply(self: @TContractState) -> Supply;
     fn max_supply(self: @TContractState) -> u16;
-    fn token_identifier(self: @TContractState, token_id: u256) -> TokenIdentifier;
+    fn traits(self: @TContractState, token_id: u256) -> TokenTrait;
     fn svg_image(self: @TContractState, token_id: u256) -> ByteArray;
 
     fn seeder(self: @TContractState) -> ContractAddress;
@@ -61,7 +61,7 @@ mod Blobert {
     use blob::seeder::{Seed, ISeederDispatcher, ISeederDispatcherTrait};
     use blob::types::erc721::MintStartTime;
     use blob::types::erc721::Supply;
-    use blob::types::erc721::TokenIdentifier;
+    use blob::types::erc721::TokenTrait;
     use blob::types::erc721::WhitelistTier;
     use blob::utils::randomness as rand;
 
@@ -243,18 +243,16 @@ mod Blobert {
         }
 
         fn token_uri(self: @ContractState, token_id: u256) -> ByteArray {
-            assert(self.erc721._exists(token_id), ERC721Component::Errors::INVALID_TOKEN_ID);
-
-            let custom_token_number = self
-                .custom_image_counts
-                .read(token_id.try_into().unwrap());
-            if custom_token_number != 0 {
-                let descriptor = self.descriptor_custom.read();
-                return descriptor.token_uri(token_id, custom_token_number - 1);
-            } else {
-                let seed = self.regular_nft_seeds.read(token_id);
-                let descriptor = self.descriptor_regular.read();
-                return descriptor.token_uri(token_id, seed);
+            let traits = self.traits(token_id);
+            match traits {
+                TokenTrait::Regular(seed) => {
+                    self.descriptor_regular.read()
+                        .token_uri(token_id, seed)
+                }, 
+                TokenTrait::Custom(index) => {
+                    self.descriptor_custom.read()
+                        .token_uri(token_id, index)
+                }
             }
         }
     }
@@ -282,36 +280,32 @@ mod Blobert {
             MAX_SUPPLY
         }
 
-        fn token_identifier(self: @ContractState, token_id: u256) -> TokenIdentifier {
+        fn traits(self: @ContractState, token_id: u256) -> TokenTrait {
             assert(self.erc721._exists(token_id), ERC721Component::Errors::INVALID_TOKEN_ID);
 
             let custom_token_number = self
                 .custom_image_counts
                 .read(token_id.try_into().unwrap());
             if custom_token_number != 0 {
                 let image_index = custom_token_number - 1;
-                return TokenIdentifier::CustomTokenIndex(image_index);
+                return TokenTrait::Custom(image_index);
             } else {
                 let seed = self.regular_nft_seeds.read(token_id);
-                return TokenIdentifier::RegularTokenSeed(seed);
+                return TokenTrait::Regular(seed);
             }
         }
 
         fn svg_image(self: @ContractState, token_id: u256) -> ByteArray{
-            assert(self.erc721._exists(token_id), ERC721Component::Errors::INVALID_TOKEN_ID);
-
-            //todo ensure it only works for minted tokens
-            let custom_token_number = self
-                .custom_image_counts
-                .read(token_id.try_into().unwrap());
-            if custom_token_number != 0 {
-                let image_index = custom_token_number - 1;
-                let descriptor = self.descriptor_custom.read();
-                return descriptor.svg_image(image_index);
-            } else {
-                let seed = self.regular_nft_seeds.read(token_id);
-                let descriptor = self.descriptor_regular.read();
-                return descriptor.svg_image(seed);
+            let traits = self.traits(token_id);
+            match traits {
+                TokenTrait::Regular(seed) => {
+                    self.descriptor_regular.read()
+                        .svg_image(seed)
+                }, 
+                TokenTrait::Custom(index) => {
+                    self.descriptor_custom.read()
+                        .svg_image(index)
+                }
             }
         }
 
@@ -674,7 +668,6 @@ mod Blobert {
             let now = starknet::get_block_timestamp();
             let mint_start_time = self.mint_start_time.read();
             assert(now >= mint_start_time.regular, Errors::BEFORE_REGULAR_MINT);
-        // @note confirm no mint end period
         }
 
 

contracts/src/generation/traits/jewelry.cairo

@@ -0,0 +1,20 @@
+use blob::generation::traits::data::jewelry;
+
+const jewelry_COUNT: u8 = 9;
+fn jewellries(index: u8) -> (ByteArray, ByteArray) {
+    assert(index < jewelry_COUNT, 'wrong jewelry index');
+    let index: felt252 = index.into();
+
+    match index {
+        0 => (jewelry::amulet(), "Amulet"),
+        1 => (jewelry::bronzering(), "Bronze Ring"),
+        2 => (jewelry::goldring(), "Gold Ring"),
+        3 => (jewelry::necklace(), "Necklace"),
+        4 => (jewelry::nounsglasses(), "Nouns Glasses"),
+        5 => (jewelry::pendant(), "Pendant"),
+        6 => (jewelry::platinumring(), "Platinum Ring"),
+        7 => (jewelry::silverring(), "Silver Ring"),
+        8 => (jewelry::titaniumring(), "Titanium Ring"),
+        _ => panic!("wrong jewelry index")
+    }
+}

contracts/src/lib.cairo

@@ -19,13 +19,13 @@ mod generation {
     mod traits {
         mod armour;
         mod background;
-        mod jewellry;
+        mod jewelry;
         mod mask;
         mod weapon;
         mod data {
             mod armour;
             mod background;
-            mod jewellry;
+            mod jewelry;
             mod mask;
             mod weapon;
         }
@@ -37,6 +37,10 @@ mod tests {
     }
     mod unit_tests {
         mod test_blobert;
+        mod test_descriptor_regular;
+        mod test_descriptor_custom;
+        mod test_seeder;
+        mod test_types;
         mod utils;
     }
 }

contracts/src/seeder.cairo

@@ -40,21 +40,24 @@ mod Seeder {
 
             let block_timestamp = starknet::get_block_timestamp();
             let randomness: u256 = poseidon_hash_span(
-                array![block_timestamp.into(), token_id.low.into(), token_id.high.into(), salt]
-                    .span()
-            )
-                .into();
+                array![
+                    block_timestamp.into(), 
+                    token_id.low.into(), 
+                    token_id.high.into(), 
+                    salt
+                ].span()
+            ).into();
 
             let background_count: u256 = descriptor.background_count().into();
             let armour_count: u256 = descriptor.armour_count().into();
-            let jewellry_count: u256 = descriptor.jewellry_count().into();
+            let jewelry_count: u256 = descriptor.jewelry_count().into();
             let mask_count: u256 = descriptor.mask_count().into();
             let weapon_count: u256 = descriptor.weapon_count().into();
 
             return Seed {
                 background: (randomness % background_count).try_into().unwrap(),
                 armour: (BitShift::shr(randomness, 48) % armour_count).try_into().unwrap(),
-                jewellry: (BitShift::shr(randomness, 96) % jewellry_count).try_into().unwrap(),
+                jewelry: (BitShift::shr(randomness, 96) % jewelry_count).try_into().unwrap(),
                 mask: (BitShift::shr(randomness, 144) % mask_count).try_into().unwrap(),
                 weapon: (BitShift::shr(randomness, 192) % weapon_count).try_into().unwrap(),
             };

contracts/src/tests/unit_tests/test_blobert.cairo

@@ -775,13 +775,13 @@ mod blobert_internal_tests {
         assert!(seed.armour != 0, "armour not set");
         assert!(seed.weapon != 0, "weapon not set");
         assert!(seed.mask != 0, "mask not set");
-        assert!(seed.jewellry != 0, "jewellry not set");
+        assert!(seed.jewelry != 0, "jewelry not set");
 
         let seed_hash = poseidon::poseidon_hash_span(
             array![
                 seed.background.into(),
                 seed.armour.into(),
-                seed.jewellry.into(),
+                seed.jewelry.into(),
                 seed.mask.into(),
                 seed.weapon.into()
             ]
@@ -1265,7 +1265,7 @@ mod blobert_write_endpoint_tests {
         let seed = contract_state.regular_nft_seeds.read(token_id);
         if seed.background == 0 {
             if seed.armour == 0 {
-                if seed.jewellry == 0 {
+                if seed.jewelry == 0 {
                     assert(false, 'seed not set');
                 }
             }
@@ -1552,7 +1552,7 @@ mod blobert_write_endpoint_tests {
             let seed = contract_state.regular_nft_seeds.read(token_id);
             if seed.background == 0 {
                 if seed.armour == 0 {
-                    if seed.jewellry == 0 {
+                    if seed.jewelry == 0 {
                         assert(false, 'seed not set');
                     }
                 }
@@ -1766,7 +1766,7 @@ use blob::blobert::Blobert::__member_module_custom_image_counts::InternalContrac
         deploy_descriptor_regular, deploy_descriptor_custom, create_merkle_tree
     };
     use blob::types::erc721::Supply;
-    use blob::types::erc721::TokenIdentifier;
+    use blob::types::erc721::TokenTrait;
     use blob::types::seeder::Seed;
 
 
@@ -1870,20 +1870,20 @@ use blob::blobert::Blobert::__member_module_custom_image_counts::InternalContrac
     }
 
     #[test]
-    fn test_token_identifier() {
+    fn test_traits() {
         let mut contract_state = call_constructor();
         contract_state.erc721._mint(contract_address_const::<'someone'>(), 1337);
         contract_state.custom_image_counts.write(1337, 44);
         assert(
-            contract_state.token_identifier(1337) == TokenIdentifier::CustomTokenIndex(44 - 1),
+            contract_state.traits(1337) == TokenTrait::Custom(44 - 1),
             'wrong first identifier'
         );
 
-        let seed = Seed { background: 1, armour: 1, jewellry: 1, mask: 1, weapon: 1 };
+        let seed = Seed { background: 1, armour: 1, jewelry: 1, mask: 1, weapon: 1 };
         contract_state.erc721._mint(contract_address_const::<'someone_else'>(), 1338);
         contract_state.regular_nft_seeds.write(1338, seed);
         assert(
-            contract_state.token_identifier(1338) == TokenIdentifier::RegularTokenSeed(seed),
+            contract_state.traits(1338) == TokenTrait::Regular(seed),
             'wrong second identifier'
         );
     }