feat: Start Time for Permissions

CHANGELOG.md

@@ -75,6 +75,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - ADODB now supports pre-release tagging [(#560)](https://github.com/andromedaprotocol/andromeda-core/pull/560)
 - Validator Staking: Updated according to audit [(#565)](https://github.com/andromedaprotocol/andromeda-core/pull/565)
 - Conditional Splitter: Change lock_time's type from MillisecondsDuration to Expiry [(#567)](https://github.com/andromedaprotocol/andromeda-core/pull/567)
+- Permissions now have an optional start time [(#668)](https://github.com/andromedaprotocol/andromeda-core/pull/668)
 
 ### Fixed
 

contracts/data-storage/andromeda-boolean/src/contract.rs

@@ -56,7 +56,7 @@ pub fn instantiate(
                 None => info.sender,
                 Some(owner) => Addr::unchecked(owner),
             },
-            Permission::Local(LocalPermission::Whitelisted(None)),
+            Permission::Local(LocalPermission::whitelisted(None, None)),
         )?;
     }
 

contracts/fungible-tokens/andromeda-cw20/src/testing/tests.rs

@@ -112,7 +112,7 @@ fn test_transfer() {
     ]);
 
     // Blacklist the sender who otherwise would have been able to call the function successfully
-    let permission = Permission::Local(LocalPermission::blacklisted(None));
+    let permission = Permission::Local(LocalPermission::blacklisted(None, None));
     let actors = vec![AndrAddr::from_string("sender")];
     let action = "Transfer";
     let ctx = ExecuteContext::new(deps.as_mut(), mock_info("owner", &[]), mock_env());
@@ -125,7 +125,7 @@ fn test_transfer() {
     assert_eq!(err, ContractError::Unauthorized {});
 
     // Now whitelist the sender, that should allow him to call the function successfully
-    let permission = Permission::Local(LocalPermission::whitelisted(None));
+    let permission = Permission::Local(LocalPermission::whitelisted(None, None));
     let actors = vec![AndrAddr::from_string("sender")];
     let action = "Transfer";
     let ctx = ExecuteContext::new(deps.as_mut(), mock_info("owner", &[]), mock_env());

contracts/fungible-tokens/andromeda-merkle-airdrop/src/contract.rs

@@ -69,7 +69,7 @@ pub fn instantiate(
             deps.storage,
             SEND_CW20_ACTION,
             addr,
-            Permission::Local(LocalPermission::whitelisted(None)),
+            Permission::Local(LocalPermission::whitelisted(None, None)),
         )?;
     }
 

contracts/modules/andromeda-address-list/src/testing/tests.rs

@@ -26,7 +26,7 @@ fn init(deps: DepsMut, info: MessageInfo) {
             owner: None,
             actor_permission: Some(ActorPermission {
                 actors: vec![AndrAddr::from_string("actor")],
-                permission: LocalPermission::whitelisted(None),
+                permission: LocalPermission::whitelisted(None, None),
             }),
         },
     )

contracts/non-fungible-tokens/andromeda-auction/src/contract.rs

@@ -313,7 +313,7 @@ fn execute_start_auction(
                 deps.storage,
                 auction_id.to_string(),
                 whitelisted_address,
-                Permission::Local(LocalPermission::Whitelisted(None)),
+                Permission::Local(LocalPermission::whitelisted(None, None)),
             )?;
         }
     };
@@ -427,7 +427,7 @@ fn execute_update_auction(
                 deps.storage,
                 token_auction_state.auction_id.to_string(),
                 whitelisted_address,
-                Permission::Local(LocalPermission::Whitelisted(None)),
+                Permission::Local(LocalPermission::whitelisted(None, None)),
             )?;
         }
     };

contracts/non-fungible-tokens/andromeda-crowdfund/src/contract.rs

@@ -75,7 +75,7 @@ pub fn instantiate(
             deps.storage,
             SEND_CW20_ACTION,
             addr,
-            Permission::Local(LocalPermission::Whitelisted(None)),
+            Permission::Local(LocalPermission::whitelisted(None, None)),
         )?;
     }
 

contracts/non-fungible-tokens/andromeda-marketplace/src/testing/tests.rs

@@ -229,7 +229,7 @@ fn test_instantiate_with_multiple_authorized_cw20_addresses() {
             ADOContract::get_permission(deps.as_ref().storage, SEND_CW20_ACTION, raw_addr).unwrap();
         assert_eq!(
             permission,
-            Some(Permission::Local(LocalPermission::Whitelisted(None)))
+            Some(Permission::Local(LocalPermission::whitelisted(None, None)))
         );
     }
 
@@ -1024,7 +1024,7 @@ fn test_execute_authorize_cw20_contract() {
             .unwrap();
     assert_eq!(
         permission,
-        Some(Permission::Local(LocalPermission::Whitelisted(None)))
+        Some(Permission::Local(LocalPermission::whitelisted(None, None)))
     );
 
     // Test successful authorization with expiration
@@ -1042,7 +1042,7 @@ fn test_execute_authorize_cw20_contract() {
         vec![
             attr("action", "authorize_contract"),
             attr("address", "cw20_contract_with_expiry"),
-            attr("permission", format!("whitelisted:{}", expiration)),
+            attr("permission", format!("whitelisted until:{}", expiration)),
         ]
     );
 
@@ -1055,9 +1055,10 @@ fn test_execute_authorize_cw20_contract() {
     .unwrap();
     assert_eq!(
         permission,
-        Some(Permission::Local(LocalPermission::Whitelisted(Some(
-            expiration
-        ))))
+        Some(Permission::Local(LocalPermission::whitelisted(
+            None,
+            Some(expiration),
+        )))
     );
 }
 
@@ -1081,7 +1082,7 @@ fn test_execute_deauthorize_cw20_contract() {
             .unwrap();
     assert_eq!(
         permission,
-        Some(Permission::Local(LocalPermission::Whitelisted(None)))
+        Some(Permission::Local(LocalPermission::whitelisted(None, None)))
     );
 
     // Now deauthorize the CW20 contract
@@ -1181,7 +1182,7 @@ fn test_authorize_token_contract() {
         vec![
             attr("action", "authorize_contract"),
             attr("address", "nft_contract"),
-            attr("permission", format!("whitelisted:{}", expiration)),
+            attr("permission", format!("whitelisted until:{}", expiration)),
         ]
     );
 

contracts/os/andromeda-ibc-registry/src/contract.rs

@@ -57,7 +57,7 @@ pub fn instantiate(
         deps.storage,
         STORE_DENOM_INFO,
         service_address.clone(),
-        Permission::Local(LocalPermission::Whitelisted(None)),
+        Permission::Local(LocalPermission::whitelisted(None, None)),
     )?;
 
     Ok(resp.add_attribute("service_address", service_address))

packages/std/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "andromeda-std"
-version = "1.3.4"
+version = "1.4.0"
 edition = "2021"
 rust-version = "1.75.0"
 description = "The standard library for creating an Andromeda Digital Object"

packages/std/src/ado_base/permissioning.rs

@@ -49,44 +49,73 @@ pub struct PermissionedActionsResponse {
 /// Expiration defaults to `Never` if not provided
 #[cw_serde]
 pub enum LocalPermission {
-    Blacklisted(Option<Expiry>),
+    Blacklisted {
+        start: Option<Expiry>,
+        expiration: Option<Expiry>,
+    },
     Limited {
+        start: Option<Expiry>,
         expiration: Option<Expiry>,
         uses: u32,
     },
-    Whitelisted(Option<Expiry>),
+    Whitelisted {
+        start: Option<Expiry>,
+        expiration: Option<Expiry>,
+    },
 }
 
 impl std::default::Default for LocalPermission {
     fn default() -> Self {
-        Self::Whitelisted(None)
+        Self::Whitelisted {
+            start: None,
+            expiration: None,
+        }
     }
 }
 
 impl LocalPermission {
-    pub fn blacklisted(expiration: Option<Expiry>) -> Self {
-        Self::Blacklisted(expiration)
+    pub fn blacklisted(start: Option<Expiry>, expiration: Option<Expiry>) -> Self {
+        Self::Blacklisted { start, expiration }
     }
 
-    pub fn whitelisted(expiration: Option<Expiry>) -> Self {
-        Self::Whitelisted(expiration)
+    pub fn whitelisted(start: Option<Expiry>, expiration: Option<Expiry>) -> Self {
+        Self::Whitelisted { start, expiration }
     }
 
-    pub fn limited(expiration: Option<Expiry>, uses: u32) -> Self {
-        Self::Limited { expiration, uses }
+    pub fn limited(start: Option<Expiry>, expiration: Option<Expiry>, uses: u32) -> Self {
+        Self::Limited {
+            start,
+            expiration,
+            uses,
+        }
     }
 
     pub fn is_permissioned(&self, env: &Env, strict: bool) -> bool {
         match self {
-            Self::Blacklisted(expiration) => {
+            Self::Blacklisted { start, expiration } => {
+                // If start time hasn't started yet, then it should return true
+                if let Some(start) = start {
+                    if !start.get_time(&env.block).is_expired(&env.block) {
+                        return true;
+                    }
+                }
                 if let Some(expiration) = expiration {
                     if expiration.get_time(&env.block).is_expired(&env.block) {
                         return !strict;
                     }
                 }
                 false
             }
-            Self::Limited { expiration, uses } => {
+            Self::Limited {
+                start,
+                expiration,
+                uses,
+            } => {
+                if let Some(start) = start {
+                    if !start.get_time(&env.block).is_expired(&env.block) {
+                        return true;
+                    }
+                }
                 if let Some(expiration) = expiration {
                     if expiration.get_time(&env.block).is_expired(&env.block) {
                         return !strict;
@@ -97,7 +126,12 @@ impl LocalPermission {
                 }
                 true
             }
-            Self::Whitelisted(expiration) => {
+            Self::Whitelisted { start, expiration } => {
+                if let Some(start) = start {
+                    if !start.get_time(&env.block).is_expired(&env.block) {
+                        return !strict;
+                    }
+                }
                 if let Some(expiration) = expiration {
                     if expiration.get_time(&env.block).is_expired(&env.block) {
                         return !strict;
@@ -110,18 +144,30 @@ impl LocalPermission {
 
     pub fn get_expiration(&self, env: Env) -> MillisecondsExpiration {
         match self {
-            Self::Blacklisted(expiration) => {
+            Self::Blacklisted { expiration, .. } => {
                 expiration.clone().unwrap_or_default().get_time(&env.block)
             }
             Self::Limited { expiration, .. } => {
                 expiration.clone().unwrap_or_default().get_time(&env.block)
             }
-            Self::Whitelisted(expiration) => {
+            Self::Whitelisted { expiration, .. } => {
                 expiration.clone().unwrap_or_default().get_time(&env.block)
             }
         }
     }
 
+    pub fn get_start_time(&self, env: Env) -> MillisecondsExpiration {
+        match self {
+            Self::Blacklisted { start, .. } => {
+                start.clone().unwrap_or_default().get_time(&env.block)
+            }
+            Self::Limited { start, .. } => start.clone().unwrap_or_default().get_time(&env.block),
+            Self::Whitelisted { start, .. } => {
+                start.clone().unwrap_or_default().get_time(&env.block)
+            }
+        }
+    }
+
     pub fn consume_use(&mut self) -> Result<(), ContractError> {
         if let Self::Limited { uses, .. } = self {
             *uses = uses.saturating_sub(1);
@@ -134,27 +180,28 @@ impl LocalPermission {
 impl fmt::Display for LocalPermission {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let self_as_string = match self {
-            Self::Blacklisted(expiration) => {
-                if let Some(expiration) = expiration {
-                    format!("blacklisted:{expiration}")
-                } else {
-                    "blacklisted".to_string()
-                }
-            }
-            Self::Limited { expiration, uses } => {
-                if let Some(expiration) = expiration {
-                    format!("limited:{expiration}:{uses}")
-                } else {
-                    format!("limited:{uses}")
-                }
-            }
-            Self::Whitelisted(expiration) => {
-                if let Some(expiration) = expiration {
-                    format!("whitelisted:{expiration}")
-                } else {
-                    "whitelisted".to_string()
-                }
-            }
+            Self::Blacklisted { start, expiration } => match (start, expiration) {
+                (Some(s), Some(e)) => format!("blacklisted starting from:{s} until:{e}"),
+                (Some(s), None) => format!("blacklisted starting from:{s}"),
+                (None, Some(e)) => format!("blacklisted until:{e}"),
+                (None, None) => "blacklisted".to_string(),
+            },
+            Self::Limited {
+                start,
+                expiration,
+                uses,
+            } => match (start, expiration) {
+                (Some(s), Some(e)) => format!("limited starting from:{s} until:{e} uses:{uses}"),
+                (Some(s), None) => format!("limited starting from:{s} uses:{uses}"),
+                (None, Some(e)) => format!("limited until:{e} uses:{uses}"),
+                (None, None) => format!("limited uses:{uses}"),
+            },
+            Self::Whitelisted { start, expiration } => match (start, expiration) {
+                (Some(s), Some(e)) => format!("whitelisted starting from:{s} until:{e}"),
+                (Some(s), None) => format!("whitelisted starting from:{s}"),
+                (None, Some(e)) => format!("whitelisted until:{e}"),
+                (None, None) => "whitelisted".to_string(),
+            },
         };
         write!(f, "{self_as_string}")
     }