Iris Milestone 1 (#4)

* 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

Author: driemworks

iris_asset_exchange/.gitignore renamed to .gitignore

@@ -1,5 +1,5 @@
 # Ignore build artifacts from the local tests sub-crate.
-/target/
+**/target/
 
 # Ignore backup files creates by cargo fmt.
 **/*.rs.bk

HEADER

@@ -0,0 +1,16 @@
+// This file is part of Iris.
+//
+// Copyright (C) 2022 Ideal Labs.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.

LICENSE-GPL3

@@ -1,17 +1,15 @@
-# Contracts
+# Iris Contracts
 
-A collection of smart contracts used on the [iris blockchain](https://github.com/iridium-labs/substrate/tree/iris).
+[![Built with ink!](https://raw.githubusercontent.com/paritytech/ink/master/.images/badge.svg)](https://github.com/paritytech/ink)
+
+A collection of smart contracts used on the [iris blockchain](https://github.com/ideal-lab5/iris).
 
 ## Setup
 
 Follow the [ink! documentation](https://paritytech.github.io/ink-docs/getting-started/setup) for a complete guide on getting started.
 
 To compile a wasm blob and metadata for a contract, navigate to the contract's root directory and run:
 
-``` bash
-cargo +nightly contract build
-```
-
 ### Note on Binaryen/wasm-opt
 
 If your package manager doesn't have binaryen versions >= 99, then:

README.md

@@ -0,0 +1,18 @@
+# Composable Access Rules
+
+Composable Access Rules allows data owners to implement custom logic that data consumers are beholden to when fetching their data.
+
+## Usage
+
+Each composable access rule must implement the [ComposableAccessRule trait](./composable_access_rule.rs).
+To build a composable access rule, each contract must implement the execute function:
+
+`fn execute(&mut self, asset_id: u32, consumer: ink_env::AccountId) -> bool`
+
+## Building
+
+`cargo +nightly contract build`
+
+## Testing
+
+`cargo +nightly test`

composable_access_rules/README.md

@@ -0,0 +1,3 @@
+# Limited Use Contract
+
+Specify a number of times that a consumer can use a token to access data associated with it.

composable_access_rules/limited_use/README.md

@@ -0,0 +1,45 @@
+[package]
+name = "limited_use_rule"
+version = "1.0.0"
+edition = "2021"
+rust-version = "1.56.1"
+authors = ["Ideal Labs Developers <https://github.com/ideal-lab5>"]
+homepage = "https://idealabs.networks/"
+license = "GPL-3.0-or-later"
+publish = false
+repository = "https://github.com/ideal-lab5/iris"
+
+[dependencies]
+ink_primitives = { version = "3.0.0-rc8", default-features = false }
+ink_metadata = { version = "3.0.0-rc8", default-features = false, features = ["derive"], optional = true }
+ink_env = { version = "3.0.0-rc8", default-features = false }
+ink_storage = { version = "3.0.0-rc8", default-features = false }
+ink_lang = { version = "3.0.0-rc8", default-features = false }
+ink_prelude = { version = "3.0.0-rc8", default-features = false }
+
+scale = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] }
+scale-info = { version = "2.1.1", default-features = false, features = ["derive"], optional = true }
+traits = { path = "../traits", default-features = false }
+
+[lib]
+name = "limited_use_rule"
+path = "lib.rs"
+crate-type = [
+    # used for normal contract wasm blobs
+    "cdylib", 
+    # used for ABI generation
+    "rlib"
+]
+
+[features]
+default = ["std"]
+std = [
+    "ink_primitives/std",
+    "ink_metadata/std",
+    "ink_env/std",
+    "ink_storage/std",
+    "ink_lang/std",
+    "scale/std",
+    "scale-info/std",
+]
+ink-as-dependency = []

composable_access_rules/limited_use/cargo.toml

@@ -0,0 +1,220 @@
+// This file is part of Iris.
+//
+// Copyright (C) 2022 Ideal Labs.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![feature(trivial_bounds)]
+//!
+//! Limited Use Rule
+//! 
+//! # Goal
+//! This contract allows data owners to impose limitations on the number
+//! of times an address may use a token to access data associated with the 
+//! asset class
+//! 
+use ink_lang as ink;
+use ink_storage::traits::{
+    SpreadLayout, 
+    PackedLayout, 
+    SpreadAllocate
+};
+
+pub use self::limited_use_rule::{
+    LimitedUseRule,
+    LimitedUseRuleRef,
+};
+
+#[derive(
+    scale::Encode, scale::Decode, PartialEq, Debug, Clone, Copy, SpreadLayout, PackedLayout, SpreadAllocate,
+)]
+#[cfg_attr(
+    feature = "std",
+    derive(scale_info::TypeInfo, ink_storage::traits::StorageLayout)
+)]
+struct Usage {
+    asset_id: u32,
+    access_attempts: u32,
+}
+
+#[ink::contract]
+mod limited_use_rule {
+    use ink_storage::traits::SpreadAllocate;
+    use traits::ComposableAccessRule;
+    use crate::Usage;
+    use ink_prelude::vec::Vec;
+
+    #[ink(event)]
+    pub struct LimitExceeded{}
+
+    #[ink(event)]
+    pub struct AccessAllowed{}
+
+    #[ink(storage)]
+    #[derive(SpreadAllocate)]
+    pub struct LimitedUseRule {
+        limit: u32,
+        usage_counter: ink_storage::Mapping<AccountId, Vec<Usage>>,
+    }
+
+    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;
+            })
+        }
+
+        #[ink(message)]
+        pub fn get_limit(&self) -> u32 {
+            self.limit
+        }
+    }
+
+    impl ComposableAccessRule for LimitedUseRule {
+        /// check if the number of times a caller has attempted access to the asset 
+        /// exceeds the pre-defined limit amount
+        /// 
+        /// * `asset_id`: The asset to which access is attempted
+        /// 
+        #[ink(message)]
+        fn execute(&mut self, asset_id: u32, consumer: ink_env::AccountId) -> bool {
+            if let Some(mut usage_attempts) = self.usage_counter.get(&consumer) {
+                let index = usage_attempts.iter().position(|x| x.asset_id == asset_id).unwrap();
+                let u = usage_attempts[index];
+                if u.access_attempts < self.limit {
+                    usage_attempts.remove(index);
+                    let new_usage = Usage{
+                        asset_id: asset_id,
+                        access_attempts: u.access_attempts + 1,
+                    };
+                    let mut usage_vec = usage_attempts;
+                    usage_vec.push(new_usage);
+                    self.usage_counter.insert(&consumer, &usage_vec);
+                    self.env().emit_event(AccessAllowed{});
+                    return true;
+                } else {
+                    self.env().emit_event(LimitExceeded{});
+                    return false;
+                }
+            } else {
+                let mut new_usage_vec = Vec::new();
+                new_usage_vec.push(Usage{
+                    asset_id: asset_id,
+                    access_attempts: 1,
+                });
+                self.usage_counter.insert(&consumer, &new_usage_vec);
+                self.env().emit_event(AccessAllowed{});
+                return true;
+            }
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+        use ink_lang as ink;
+
+        #[ink::test]
+        fn can_create_new_contract_with_positive_limit() {
+            let limit = 10;
+            let limited_use_contract = LimitedUseRule::new(limit);
+            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
+         */
+
+        fn setup_test(limit: u32, default_account: ink_env::AccountId) -> LimitedUseRule {
+            let limited_use_contract = LimitedUseRule::new(limit);
+            ink_env::test::set_caller::<ink_env::DefaultEnvironment>(default_account);
+            limited_use_contract
+        }
+        
+        #[ink::test]
+        fn can_execute_and_increment_on_first_access() {
+            let accounts = ink_env::test::default_accounts::<ink_env::DefaultEnvironment>();
+            let mut limited_use_contract = setup_test(2, accounts.alice);
+
+            // WHEN: I attempt to invoke the execute function
+            limited_use_contract.execute(1, accounts.alice);
+            // THEN: there is a usage attempt added 
+            let usage_tracker = limited_use_contract.usage_counter.get(accounts.alice).unwrap();
+            let usage_len = usage_tracker.len();
+            assert_eq!(1, usage_len);
+            // AND: The only entry contains my asset id as accessed a single time
+            assert_eq!(1, usage_tracker[0].asset_id);
+            assert_eq!(1, usage_tracker[0].access_attempts);
+        }
+
+        #[ink::test]
+        fn can_execute_and_increment_on_second_access() {
+            let accounts = ink_env::test::default_accounts::<ink_env::DefaultEnvironment>();
+            let mut limited_use_contract = setup_test(2, accounts.alice);
+
+            // WHEN: I attempt to invoke the execute function
+            limited_use_contract.execute(1, accounts.alice);
+            // THEN: The access attempt value is incremented by one
+            let usage_tracker_1 = limited_use_contract.usage_counter.get(accounts.alice).unwrap();
+            assert_eq!(1, usage_tracker_1[0].access_attempts);
+
+            // WHEN: I attempt to invoke the execute function AGAIN
+            limited_use_contract.execute(1, accounts.alice);
+            // THEN: The access attempt value is incremented by one
+            let usage_tracker_2 = limited_use_contract.usage_counter.get(accounts.alice).unwrap();
+            assert_eq!(2, usage_tracker_2[0].access_attempts);
+        }
+
+        #[ink::test]
+        fn can_execute_and_not_increment_when_limit_exceeded() {
+            let accounts = ink_env::test::default_accounts::<ink_env::DefaultEnvironment>();
+            let mut limited_use_contract = setup_test(2, accounts.alice);
+
+            // WHEN: I attempt to invoke the execute function
+            limited_use_contract.execute(1, accounts.alice);
+            // THEN: The access attempt value is incremented by one
+            let usage_tracker_1 = limited_use_contract.usage_counter.get(accounts.alice).unwrap();
+            assert_eq!(1, usage_tracker_1[0].access_attempts);
+            // WHEN: I attempt to invoke the execute function AGAIN
+            limited_use_contract.execute(1, accounts.alice);
+            // THEN: The access attempt value is incremented by one
+            let usage_tracker_2 = limited_use_contract.usage_counter.get(accounts.alice).unwrap();
+            assert_eq!(2, usage_tracker_2[0].access_attempts);
+            // WHEN: I attempt to invoke the execute function AGAIN
+            limited_use_contract.execute(1, accounts.alice);
+            // THEN: The access attempt value is incremented by one
+            let usage_tracker_3 = limited_use_contract.usage_counter.get(accounts.alice).unwrap();
+            assert_eq!(2, usage_tracker_3[0].access_attempts);
+        }
+    }
+}

composable_access_rules/limited_use/lib.rs

@@ -0,0 +1 @@
+{"rustc_fingerprint":11766580262192304820,"outputs":{"15697416045686424142":{"success":false,"status":"exit status: 1","code":1,"stdout":"","stderr":"error: `-Csplit-debuginfo` is unstable on this platform\n\n"},"10376369925670944939":{"success":true,"status":"","code":0,"stdout":"___\nlib___.rlib\nlib___.so\nlib___.so\nlib___.a\nlib___.so\n/home/driemworks/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu\ndebug_assertions\npanic=\"unwind\"\nproc_macro\ntarget_abi=\"\"\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"gnu\"\ntarget_family=\"unix\"\ntarget_feature=\"fxsr\"\ntarget_feature=\"llvm14-builtins-abi\"\ntarget_feature=\"sse\"\ntarget_feature=\"sse2\"\ntarget_has_atomic=\"16\"\ntarget_has_atomic=\"32\"\ntarget_has_atomic=\"64\"\ntarget_has_atomic=\"8\"\ntarget_has_atomic=\"ptr\"\ntarget_has_atomic_equal_alignment=\"16\"\ntarget_has_atomic_equal_alignment=\"32\"\ntarget_has_atomic_equal_alignment=\"64\"\ntarget_has_atomic_equal_alignment=\"8\"\ntarget_has_atomic_equal_alignment=\"ptr\"\ntarget_has_atomic_load_store=\"16\"\ntarget_has_atomic_load_store=\"32\"\ntarget_has_atomic_load_store=\"64\"\ntarget_has_atomic_load_store=\"8\"\ntarget_has_atomic_load_store=\"ptr\"\ntarget_os=\"linux\"\ntarget_pointer_width=\"64\"\ntarget_thread_local\ntarget_vendor=\"unknown\"\nunix\n","stderr":""},"4614504638168534921":{"success":true,"status":"","code":0,"stdout":"rustc 1.63.0-nightly (4cbaac699 2022-05-25)\nbinary: rustc\ncommit-hash: 4cbaac699c14b7ac7cc80e54823b2ef6afeb64af\ncommit-date: 2022-05-25\nhost: x86_64-unknown-linux-gnu\nrelease: 1.63.0-nightly\nLLVM version: 14.0.4\n","stderr":""}},"successes":{}}

composable_access_rules/limited_use/target/.rustc_info.json

@@ -0,0 +1 @@
+{"rustc_fingerprint":11766580262192304820,"outputs":{"960003148300528316":{"success":true,"status":"","code":0,"stdout":"___.wasm\nlib___.rlib\n___.wasm\nlib___.a\n/home/driemworks/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu\ndebug_assertions\npanic=\"abort\"\nproc_macro\ntarget_abi=\"\"\ntarget_arch=\"wasm32\"\ntarget_endian=\"little\"\ntarget_env=\"\"\ntarget_family=\"wasm\"\ntarget_feature=\"llvm14-builtins-abi\"\ntarget_has_atomic=\"16\"\ntarget_has_atomic=\"32\"\ntarget_has_atomic=\"64\"\ntarget_has_atomic=\"8\"\ntarget_has_atomic=\"ptr\"\ntarget_has_atomic_equal_alignment=\"16\"\ntarget_has_atomic_equal_alignment=\"32\"\ntarget_has_atomic_equal_alignment=\"64\"\ntarget_has_atomic_equal_alignment=\"8\"\ntarget_has_atomic_equal_alignment=\"ptr\"\ntarget_has_atomic_load_store=\"16\"\ntarget_has_atomic_load_store=\"32\"\ntarget_has_atomic_load_store=\"64\"\ntarget_has_atomic_load_store=\"8\"\ntarget_has_atomic_load_store=\"ptr\"\ntarget_os=\"unknown\"\ntarget_pointer_width=\"32\"\ntarget_thread_local\ntarget_vendor=\"unknown\"\n","stderr":"warning: dropping unsupported crate type `dylib` for target `wasm32-unknown-unknown`\n\nwarning: dropping unsupported crate type `proc-macro` for target `wasm32-unknown-unknown`\n\nwarning: 2 warnings emitted\n\n"},"6696513553006607334":{"success":false,"status":"exit status: 1","code":1,"stdout":"","stderr":"error: `-Csplit-debuginfo` is unstable on this platform\n\n"},"4614504638168534921":{"success":true,"status":"","code":0,"stdout":"rustc 1.63.0-nightly (4cbaac699 2022-05-25)\nbinary: rustc\ncommit-hash: 4cbaac699c14b7ac7cc80e54823b2ef6afeb64af\ncommit-date: 2022-05-25\nhost: x86_64-unknown-linux-gnu\nrelease: 1.63.0-nightly\nLLVM version: 14.0.4\n","stderr":""},"15697416045686424142":{"success":false,"status":"exit status: 1","code":1,"stdout":"","stderr":"error: `-Csplit-debuginfo` is unstable on this platform\n\n"},"10376369925670944939":{"success":true,"status":"","code":0,"stdout":"___\nlib___.rlib\nlib___.so\nlib___.so\nlib___.a\nlib___.so\n/home/driemworks/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu\ndebug_assertions\npanic=\"unwind\"\nproc_macro\ntarget_abi=\"\"\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"gnu\"\ntarget_family=\"unix\"\ntarget_feature=\"fxsr\"\ntarget_feature=\"llvm14-builtins-abi\"\ntarget_feature=\"sse\"\ntarget_feature=\"sse2\"\ntarget_has_atomic=\"16\"\ntarget_has_atomic=\"32\"\ntarget_has_atomic=\"64\"\ntarget_has_atomic=\"8\"\ntarget_has_atomic=\"ptr\"\ntarget_has_atomic_equal_alignment=\"16\"\ntarget_has_atomic_equal_alignment=\"32\"\ntarget_has_atomic_equal_alignment=\"64\"\ntarget_has_atomic_equal_alignment=\"8\"\ntarget_has_atomic_equal_alignment=\"ptr\"\ntarget_has_atomic_load_store=\"16\"\ntarget_has_atomic_load_store=\"32\"\ntarget_has_atomic_load_store=\"64\"\ntarget_has_atomic_load_store=\"8\"\ntarget_has_atomic_load_store=\"ptr\"\ntarget_os=\"linux\"\ntarget_pointer_width=\"64\"\ntarget_thread_local\ntarget_vendor=\"unknown\"\nunix\n","stderr":""}},"successes":{}}