Automatic accessors macro

contracts/src/traits/psp22/psp22.rs

@@ -32,7 +32,7 @@ use openbrush::traits::{
 #[openbrush::wrapper]
 pub type PSP22Ref = dyn PSP22;
 
-/// Trait implemented by all PSP-20 respecting smart traits.
+/// Trait implemented by all PSP-22 respecting smart traits.
 #[openbrush::trait_definition]
 pub trait PSP22 {
     /// Returns the total token supply.

examples/accessors_attr/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "accessors_attr"
+version = "3.1.1"
+authors = ["Brushfam <green@727.ventures>"]
+edition = "2021"
+
+[dependencies]
+ink = { version = "4.2.0", default-features = false}
+
+scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }
+scale-info = { version = "2.3", default-features = false, features = ["derive"], optional = true }
+
+openbrush = { path = "../..", default-features = false }
+
+[dev-dependencies]
+ink_e2e = "4.2"
+test_helpers = { path = "../test_helpers", default-features = false }
+
+[lib]
+name = "accessors_attr"
+path = "lib.rs"
+crate-type = [
+    # Used for normal contract Wasm blobs.
+    "cdylib",
+]
+
+[features]
+default = ["std"]
+std = [
+    "ink/std",
+    "scale/std",
+    "scale-info/std",
+    "openbrush/std",
+]
+ink-as-dependency = []
+e2e-tests = []
+
+[profile.dev]
+codegen-units = 16

examples/accessors_attr/lib.rs

@@ -0,0 +1,207 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+#![feature(min_specialization)]
+
+pub use accessors_attr::*;
+
+#[openbrush::contract]
+pub mod accessors_attr {
+    use openbrush::{
+        traits::{
+            Storage,
+        },
+    };
+
+    #[ink(storage)]
+    #[derive(Storage)]
+    pub struct Contract {
+        // fields for hater logic
+        #[storage_field]
+        hated_logic: DumbData,
+    }
+
+    #[openbrush::upgradeable_storage(STORAGE_KEY)]
+    #[openbrush::accessors(DumbDataAccessors)]
+    #[derive(Storage)]
+    #[derive(Debug)]
+    pub struct DumbData {
+        #[get]
+        #[set]
+        dumb_g_s: u32,
+        #[get]
+        dumb_g_only: u32,
+        #[set]
+        dumb_s_only: u32,
+    }
+
+    pub const STORAGE_KEY: u32 = openbrush::storage_unique_key!(DumbData);
+
+    impl DumbDataAccessors for Contract {}
+
+    impl Contract {
+        #[ink(constructor)]
+        pub fn new() -> Self {
+            let instance = Self {
+                hated_logic: DumbData {
+                    dumb_g_s: 0,
+                    dumb_g_only: 0,
+                    dumb_s_only: 0
+                },
+            };
+            instance
+        }
+        #[ink(message)]
+        pub fn update_dumb_g(&mut self, value: u32) {
+            self.hated_logic.dumb_g_only = value
+        }
+        #[ink(message)]
+        pub fn return_dumb_s(&self) -> u32 {
+            self.hated_logic.dumb_s_only
+        }
+    }
+
+    #[cfg(all(test, feature = "e2e-tests"))]
+    pub mod tests {
+        use crate::accessors_attr::dumbdataaccessors_external::DumbDataAccessors;
+        #[rustfmt::skip]
+        use super::*;
+        #[rustfmt::skip]
+        use ink_e2e::{build_message};
+
+        type E2EResult<T> = Result<T, Box<dyn std::error::Error>>;
+
+        #[ink_e2e::test]
+        async fn  get_and_set() -> E2EResult<()> {
+            let constructor = ContractRef::new();
+            let address = client
+                .instantiate("accessors_attr", &ink_e2e::alice(), constructor, 0, None)
+                .await
+                .expect("instantiate failed")
+                .account_id;
+
+            let result = {
+                let _msg = build_message::<ContractRef>(address.clone())
+                    .call(|contract| contract.get_dumb_g_s());
+                client
+                    .call(&ink_e2e::alice(), _msg, 0, None)
+                    .await
+                    .expect("get_dumb_g_s failed")
+            };
+
+            assert!(matches!(result.return_value(), 0));
+
+            let result = {
+                let _msg = build_message::<ContractRef>(address.clone())
+                    .call(|contract| contract.set_dumb_g_s(10));
+                client
+                    .call(&ink_e2e::alice(), _msg, 0, None)
+                    .await
+                    .expect("update_dumb_g_only failed")
+            };
+
+            assert!(matches!(result.return_value(), ()));
+
+            let result = {
+                let _msg = build_message::<ContractRef>(address.clone())
+                    .call(|contract| contract.get_dumb_g_s());
+                client
+                    .call(&ink_e2e::alice(), _msg, 0, None)
+                    .await
+                    .expect("get_dumb_g_only failed")
+            };
+
+            assert!(matches!(result.return_value(), 10));
+
+            Ok(())
+        }
+
+        #[ink_e2e::test]
+        async fn  only_set() -> E2EResult<()> {
+            let constructor = ContractRef::new();
+            let address = client
+                .instantiate("accessors_attr", &ink_e2e::alice(), constructor, 0, None)
+                .await
+                .expect("instantiate failed")
+                .account_id;
+
+            let result = {
+                let _msg = build_message::<ContractRef>(address.clone())
+                    .call(|contract| contract.return_dumb_s());
+                client
+                    .call(&ink_e2e::alice(), _msg, 0, None)
+                    .await
+                    .expect("return_dumb_s failed")
+            };
+
+            assert!(matches!(result.return_value(), 0));
+
+            let result = {
+                let _msg = build_message::<ContractRef>(address.clone())
+                    .call(|contract| contract.set_dumb_s_only(10));
+                client
+                    .call(&ink_e2e::alice(), _msg, 0, None)
+                    .await
+                    .expect("set_dumb_s_only failed")
+            };
+
+            assert!(matches!(result.return_value(), ()));
+
+            let result = {
+                let _msg = build_message::<ContractRef>(address.clone())
+                    .call(|contract| contract.return_dumb_s());
+                client
+                    .call(&ink_e2e::alice(), _msg, 0, None)
+                    .await
+                    .expect("return_dumb_s failed")
+            };
+
+            assert!(matches!(result.return_value(), 10));
+
+            Ok(())
+        }
+
+        #[ink_e2e::test]
+        async fn  only_get() -> E2EResult<()> {
+            let constructor = ContractRef::new();
+            let address = client
+                .instantiate("accessors_attr", &ink_e2e::alice(), constructor, 0, None)
+                .await
+                .expect("instantiate failed")
+                .account_id;
+
+            let result = {
+                let _msg = build_message::<ContractRef>(address.clone())
+                    .call(|contract| contract.get_dumb_g_only());
+                client
+                    .call(&ink_e2e::alice(), _msg, 0, None)
+                    .await
+                    .expect("get_dumb_g_only failed")
+            };
+
+            assert!(matches!(result.return_value(), 0));
+
+            let result = {
+                let _msg = build_message::<ContractRef>(address.clone())
+                    .call(|contract| contract.update_dumb_g(10));
+                client
+                    .call(&ink_e2e::alice(), _msg, 0, None)
+                    .await
+                    .expect("update_dumb_g_only failed")
+            };
+
+            assert!(matches!(result.return_value(), ()));
+
+            let result = {
+                let _msg = build_message::<ContractRef>(address.clone())
+                    .call(|contract| contract.get_dumb_g_only());
+                client
+                    .call(&ink_e2e::alice(), _msg, 0, None)
+                    .await
+                    .expect("get_dumb_g_only failed")
+            };
+
+            assert!(matches!(result.return_value(), 10));
+
+            Ok(())
+        }
+    }
+}