feat(access-manager): e2e test for scheduling

wip

wip

wip

wip

Author: benluelo

Cargo.lock

@@ -290,6 +290,8 @@ members = [
   "lib/ucs03-zkgmable",
   "lib/ucs03-solvable",
   "lib/access-manager-types",
+  "e2e/access-manager-tests",
+  "e2e/access-managed-example",
 ]
 
 [workspace.package]
@@ -392,15 +394,16 @@ ibc-union              = { path = "cosmwasm/ibc-union/core", default-features =
 ibc-union-light-client = { path = "cosmwasm/ibc-union/core/light-client-interface", default-features = false }
 ibc-union-msg          = { path = "cosmwasm/ibc-union/core/msg", default-features = false }
 
+access-managed         = { path = "cosmwasm/access-managed", default-features = false }
+access-managed-example = { path = "e2e/access-managed-example", default-features = false }
+access-manager-types   = { path = "lib/access-manager-types", default-features = false }
+
 frissitheto = { path = "lib/frissitheto", default-features = false }
 
 lst = { path = "cosmwasm/lst", default-features = false }
 
-access-manager-types = { path = "lib/access-manager-types", default-features = false }
-access-manager = { path = "cosmwasm/access-manager", default-features = false }
-
-cw-account           = { path = "cosmwasm/cw-account", default-features = false }
-cw-escrow-vault      = { path = "cosmwasm/cw-escrow-vault", default-features = false }
+cw-account      = { path = "cosmwasm/cw-account", default-features = false }
+cw-escrow-vault = { path = "cosmwasm/cw-escrow-vault", default-features = false }
 
 cw20-base                         = { path = "cosmwasm/cw20-base", default-features = false }
 cw20-ctx                          = { path = "lib/cw20-ctx", default-features = false }

Cargo.toml

@@ -40,7 +40,6 @@ use crate::{
 
 pub mod contract;
 pub mod error;
-pub mod managed;
 mod restricted;
 pub mod state;
 
@@ -51,8 +50,6 @@ pub use restricted::{
 // #[cfg(test)]
 // mod tests;
 
-pub const EXECUTE_REPLY_ID: u64 = 1;
-
 /// Initializes the contract connected to an initial authority.
 ///
 /// ```solidity
@@ -61,7 +58,7 @@ pub const EXECUTE_REPLY_ID: u64 = 1;
 ///
 /// <https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.4.0/contracts/access/manager/AccessManaged.sol#L27>
 #[expect(clippy::needless_pass_by_value, reason = "required for entry_point")]
-pub fn init(deps: DepsMut, _: &Env, msg: InitMsg) -> Result<Response, ContractError> {
+pub fn init(deps: DepsMut, msg: InitMsg) -> Result<Response, ContractError> {
     let InitMsg { initial_authority } = msg;
 
     deps.storage.write_item::<Authority>(&initial_authority);
@@ -98,8 +95,22 @@ pub fn query(deps: Deps, _: Env, msg: QueryMsg) -> Result<Binary, ContractError>
 }
 
 #[cfg_attr(not(feature = "library"), cosmwasm_std::entry_point)]
-#[expect(clippy::needless_pass_by_value, reason = "required for entry_point")]
 pub fn reply(deps: DepsMut, _: Env, reply: Reply) -> Result<Response, ContractError> {
+    if let Some(reply) = handle_consume_scheduled_op_reply(deps, reply)? {
+        Err(StdError::generic_err(format!("unknown reply: {reply:?}")).into())
+    } else {
+        Ok(Response::new())
+    }
+}
+
+#[expect(
+    clippy::needless_pass_by_value,
+    reason = "DepsMut should be passed by value"
+)]
+pub fn handle_consume_scheduled_op_reply(
+    deps: DepsMut<'_>,
+    reply: Reply,
+) -> Result<Option<Reply>, ContractError> {
     match reply {
         Reply {
             id: ACCESS_MANAGED_CONSUME_SCHEDULED_OP_REPLY_ID,
@@ -110,23 +121,22 @@ pub fn reply(deps: DepsMut, _: Env, reply: Reply) -> Result<Response, ContractEr
 
             deps.storage.write_item::<ConsumingSchedule>(&false);
 
-            Ok(Response::new())
+            Ok(None)
         }
-        _ => Err(StdError::generic_err("unknown reply: {reply:?}").into()),
+        _ => Ok(Some(reply)),
     }
 }
 
 #[cfg_attr(not(feature = "library"), cosmwasm_std::entry_point)]
-#[expect(clippy::needless_pass_by_value, reason = "required for entry_point")]
 pub fn migrate(
     deps: DepsMut,
-    env: Env,
+    _: Env,
     msg: UpgradeMsg<InitMsg, MigrateMsg>,
 ) -> Result<Response, ContractError> {
     msg.run(
         deps,
         |deps, msg| {
-            let res = init(deps, &env, msg)?;
+            let res = init(deps, msg)?;
             Ok((res, None))
         },
         |_, _, _| Ok((Response::default(), None)),

cosmwasm/access-managed/src/lib.rs

@@ -1,29 +1,20 @@
-use std::marker::PhantomData;
-
 use access_manager_types::{managed::error::AccessManagedError, CanCall, Selector};
-use cosmwasm_std::{
-    from_json, to_json_binary, Addr, DepsMut, Env, MessageInfo, StdError, SubMsg, WasmMsg,
-};
+use cosmwasm_std::{to_json_binary, Addr, DepsMut, Env, MessageInfo, SubMsg, WasmMsg};
 use depolama::{StorageExt, Store};
-use serde::{
-    de::{self, DeserializeOwned},
-    Deserialize, Deserializer,
-};
-use serde_json::value::RawValue;
+use serde::{de::DeserializeOwned, Deserialize, Deserializer, Serialize};
 
 use crate::{error::ContractError, state::ConsumingSchedule};
 
 pub const ACCESS_MANAGED_CONSUME_SCHEDULED_OP_REPLY_ID: u64 = u64::MAX;
 
 #[derive(Debug)]
-pub struct Restricted<'a, T: DeserializeOwned> {
-    selector: &'a Selector,
-    raw: &'a RawValue,
-    __marker: PhantomData<fn() -> T>,
+pub struct Restricted<T: DeserializeOwned + Serialize> {
+    selector: &'static Selector,
+    value: T,
 }
 
-impl<T: DeserializeOwned> Restricted<'_, T> {
-    #[allow(clippy::needless_pass_by_value)]
+impl<T: DeserializeOwned + Serialize> Restricted<T> {
+    #[allow(clippy::needless_pass_by_value, clippy::missing_panics_doc)]
     pub fn ensure_can_call<S: Store<Key = (), Value = Addr>>(
         self,
         deps: DepsMut,
@@ -45,7 +36,7 @@ impl<T: DeserializeOwned> Restricted<'_, T> {
         )?;
 
         if immediate {
-            Ok(EnsureCanCallResult::Msg(self.deserialize_inner()?))
+            Ok(EnsureCanCallResult::Msg(self.value))
         } else if delay > 0 {
             deps.storage.write_item::<ConsumingSchedule>(&true);
 
@@ -56,15 +47,15 @@ impl<T: DeserializeOwned> Restricted<'_, T> {
                         msg: to_json_binary(
                             &access_manager_types::manager::msg::ExecuteMsg::ConsumeScheduledOp {
                                 caller: info.sender.clone(),
-                                data: self.raw.get().to_owned(),
+                                data: serde_json_wasm::to_string(&self.value).expect("infallible"),
                             },
                         )?,
                         funds: vec![],
                     }),
-                    SubMsg::reply_always(
+                    SubMsg::reply_on_success(
                         WasmMsg::Execute {
                             contract_addr: env.contract.address.to_string(),
-                            msg: self.raw.get().as_bytes().into(),
+                            msg: to_json_binary(&self.value).expect("infallible"),
                             funds: vec![],
                         },
                         ACCESS_MANAGED_CONSUME_SCHEDULED_OP_REPLY_ID,
@@ -79,31 +70,23 @@ impl<T: DeserializeOwned> Restricted<'_, T> {
             .into())
         }
     }
-
-    fn deserialize_inner(self) -> Result<T, StdError> {
-        from_json(self.raw.get())
-    }
 }
 
 pub enum EnsureCanCallResult<T> {
     Msg(T),
     Scheduled(Vec<SubMsg>),
 }
 
-impl<'de, T: DeserializeOwned> Deserialize<'de> for Restricted<'de, T> {
+impl<'de, T: DeserializeOwned + Serialize> Deserialize<'de> for Restricted<T> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
-        let raw = <&RawValue as Deserialize>::deserialize(deserializer)?;
+        let value = T::deserialize(deserializer)?;
 
-        let selector = Selector::extract(raw.get()).map_err(de::Error::custom)?;
+        let selector = Selector::extract_from_serialize(&value);
 
-        Ok(Self {
-            selector,
-            raw,
-            __marker: PhantomData,
-        })
+        Ok(Self { selector, value })
     }
 }
 
@@ -123,7 +106,7 @@ mod tests {
     #[track_caller]
     fn deser_expect_error(json: &[u8], expect: &str) {
         assert_eq!(
-            serde_json::from_slice::<Restricted<ExecuteMsg>>(json)
+            serde_json_wasm::from_slice::<Restricted<ExecuteMsg>>(json)
                 .unwrap_err()
                 .to_string(),
             expect
@@ -133,59 +116,55 @@ mod tests {
     #[test]
     fn restricted_deser_ok() {
         let obj = br#"{"key":{}}"#;
-        let restricted = serde_json::from_slice::<Restricted<ExecuteMsg>>(obj).unwrap();
+        let restricted = serde_json_wasm::from_slice::<Restricted<ExecuteMsg>>(obj).unwrap();
 
         assert_eq!(restricted.selector, Selector::new("key"));
-        assert_eq!(restricted.raw.get().as_bytes(), obj);
-
-        assert_eq!(restricted.deserialize_inner().unwrap(), ExecuteMsg::Key {});
+        assert_eq!(restricted.value, ExecuteMsg::Key {});
     }
 
     #[test]
     fn restricted_deser_value_not_object_ok() {
         let obj = br#"{"key2":1}"#;
-        let restricted = serde_json::from_slice::<Restricted<ExecuteMsg>>(obj).unwrap();
+        let restricted = serde_json_wasm::from_slice::<Restricted<ExecuteMsg>>(obj).unwrap();
 
         assert_eq!(restricted.selector, Selector::new("key2"));
-        assert_eq!(restricted.raw.get().as_bytes(), obj);
-
-        assert_eq!(restricted.deserialize_inner().unwrap(), ExecuteMsg::Key2(1));
+        assert_eq!(restricted.value, ExecuteMsg::Key2(1));
     }
 
     #[test]
-    fn restricted_deser_escaped_fails() {
+    fn restricted_deser_unknown_variant_fails() {
         deser_expect_error(
             br#"{"key\n":{}}"#,
-            r#"invalid type: string "key\n", expected a borrowed string at line 1 column 8"#,
+            "unknown variant `key\n`, expected `key` or `key2`",
         );
     }
 
     #[test]
     fn restricted_deser_multiple_keys_different_key_name_fails() {
         deser_expect_error(
             br#"{"key":{},"key2":{}}"#,
-            "multiple keys found at line 1 column 16",
+            "Expected this character to start a JSON value.",
         );
     }
 
     #[test]
     fn restricted_deser_multiple_keys_same_key_name_fails() {
         deser_expect_error(
             br#"{"key":{},"key":{}}"#,
-            "multiple keys found at line 1 column 15",
+            "Expected this character to start a JSON value.",
         );
     }
 
     #[test]
     fn restricted_deser_no_key() {
-        deser_expect_error(br"{}", "no key found at line 1 column 2");
+        deser_expect_error(br"{}", "Invalid type");
     }
 
     #[test]
     fn restricted_deser_not_object() {
         deser_expect_error(
             b"null",
-            "invalid type: null, expected json object with single top level key at line 1 column 4",
+            "Expected to parse either a `true`, `false`, or a `null`.",
         );
     }
 }