Iris Milestone 2 (#5)

* add new contract

* update deps, update readme

* WIP call transfer from contract

* pass args to transfer func

* add test contract, readme

* add payable

* update readme

* remove test, transfer assets works, add registry, add mint func

* add purchase func

* update readme

* update email

* purchase tokens with latest chain ext funcs

* update ext

* update chain ext, add new errors, add event struct, lock and transfer works

* cleanup, add docs

* update readmes, add composable access rules

* limited use token

* remove cars

* happy path tests work

* update get version func

* update storage maps

* rename func

* add getters for registries

* fix typos, handle option

* update structure, CARs WIP

* compilation works

* register func works

* update gitignore

* add limit to constructor

* register works, tests work, execute works

* limited use token works with burn

* rule executor works

* modify storage with new struct, update tests, remove chain ext

* move data retrieval to compoasable rules dir, create trait for rule executor

* cross contract calls works!

* :(

* rule executor works

* rename data_retrieval to rule executor, update docs

* update docs, cleanup

* update readme and .gitignore

* add license

* add copyright headers

* update to pass pk as arg from caller

* add trivial executor

* remove target

Author: driemworks

composable_access_rules/limited_use/lib.rs

@@ -72,9 +72,6 @@ mod limited_use_rule {
     impl LimitedUseRule {
         #[ink(constructor)]
         pub fn new(limit: u32) -> Self {
-            if limit <= 0 {
-                panic!("limit must be positive");
-            }
             ink_lang::utils::initialize_contract(|contract: &mut Self| {
                 contract.limit = limit;
             })
@@ -84,6 +81,24 @@ mod limited_use_rule {
         pub fn get_limit(&self) -> u32 {
             self.limit
         }
+
+        #[ink(message)]
+        pub fn get_attempts_count(&self, asset_id: u32) -> u32 {
+            let caller = self.env().caller();
+            let mut usage_attempts = 0;
+            match self.usage_counter.get(caller) {
+                Some(usages) => {
+                    let filtered_usages = usages.iter().filter(|u| u.asset_id == asset_id).collect::<Vec<_>>();
+                    for usage in filtered_usages.iter() {
+                        usage_attempts = usage.access_attempts;
+                    }
+                },
+                None => {
+                    // do nothing
+                }
+            }
+            usage_attempts
+        }
     }
 
     impl ComposableAccessRule for LimitedUseRule {
@@ -137,20 +152,6 @@ mod limited_use_rule {
             assert_eq!(limit, limited_use_contract.get_limit());
         }
 
-        #[ink::test]
-        #[should_panic]
-        fn panic_when_new_contract_with_zero_limit() {
-            let limit = 0;
-            let limited_use_contract = LimitedUseRule::new(limit);
-        }
-
-        #[ink::test]
-        #[should_panic]
-        fn panic_when_new_contract_with_negative_limit() {
-            let limit = -10;
-            let limited_use_contract = LimitedUseRule::new(limit);
-        }
-
         /**
          * Tests for the `execute` function
          */