first initial impl of manifests for updating securified entities

crates/profile/models/supporting-types/src/abstract_securified_entity.rs

@@ -62,8 +62,11 @@
         Into::<AddressOfAccountOrPersona>::into(self.entity.address())
     }
 
-    pub fn current_authentication_signing_factor_instance(&self) -> HierarchicalDeterministicFactorInstance {
-self.securified_entity_control().authentication_signing_factor_instance()
+    pub fn current_authentication_signing_factor_instance(
+        &self,
+    ) -> HierarchicalDeterministicFactorInstance {
+        self.securified_entity_control()
+            .authentication_signing_factor_instance()
     }
 
     pub fn veci(&self) -> Option<VirtualEntityCreatingInstance> {

crates/transaction/manifests/src/manifests_security_shield/access_controller_factors_and_time_input.rs

@@ -0,0 +1,100 @@
+use crate::prelude::*;
+use radix_engine_interface::blueprints::access_controller::{
+    AccessControllerInitiateRecoveryAsPrimaryInput as ScryptoAccessControllerInitiateRecoveryAsPrimaryInput,
+    AccessControllerInitiateRecoveryAsRecoveryInput as ScryptoAccessControllerInitiateRecoveryAsRecoveryInput,
+    AccessControllerQuickConfirmPrimaryRoleRecoveryProposalInput as ScryptoAccessControllerQuickConfirmPrimaryRoleRecoveryProposalInput,
+    AccessControllerQuickConfirmRecoveryRoleRecoveryProposalInput as ScryptoAccessControllerQuickConfirmRecoveryRoleRecoveryProposalInput,
+    AccessControllerTimedConfirmRecoveryInput as ScryptoAccessControllerTimedConfirmRecoveryInput,
+};
+
+#[derive(Debug, Clone)]
+pub struct AccessControllerFactorsAndTimeInput {
+    rule_set: ScryptoRuleSet,
+    timed_recovery_delay_in_minutes: u32,
+}
+
+impl AccessControllerFactorsAndTimeInput {
+    pub fn new(
+        security_structure_of_factor_instances: &SecurityStructureOfFactorInstances,
+    ) -> Self {
+        let rule_set = ScryptoRuleSet::from(
+            security_structure_of_factor_instances
+                .matrix_of_factors
+                .clone(),
+        );
+
+        let timed_recovery_delay_in_minutes =
+            security_structure_of_factor_instances
+                .timed_recovery_delay_in_minutes();
+
+        Self {
+            rule_set,
+            timed_recovery_delay_in_minutes,
+        }
+    }
+}
+
+impl From<&AccessControllerFactorsAndTimeInput>
+    for ScryptoAccessControllerInitiateRecoveryAsRecoveryInput
+{
+    fn from(value: &AccessControllerFactorsAndTimeInput) -> Self {
+        Self {
+            rule_set: value.rule_set.clone(),
+            timed_recovery_delay_in_minutes: Some(
+                value.timed_recovery_delay_in_minutes,
+            ),
+        }
+    }
+}
+
+impl From<&AccessControllerFactorsAndTimeInput>
+    for ScryptoAccessControllerInitiateRecoveryAsPrimaryInput
+{
+    fn from(value: &AccessControllerFactorsAndTimeInput) -> Self {
+        Self {
+            rule_set: value.rule_set.clone(),
+            timed_recovery_delay_in_minutes: Some(
+                value.timed_recovery_delay_in_minutes,
+            ),
+        }
+    }
+}
+
+impl From<&AccessControllerFactorsAndTimeInput>
+    for ScryptoAccessControllerQuickConfirmRecoveryRoleRecoveryProposalInput
+{
+    fn from(value: &AccessControllerFactorsAndTimeInput) -> Self {
+        Self {
+            rule_set: value.rule_set.clone(),
+            timed_recovery_delay_in_minutes: Some(
+                value.timed_recovery_delay_in_minutes,
+            ),
+        }
+    }
+}
+
+impl From<&AccessControllerFactorsAndTimeInput>
+    for ScryptoAccessControllerQuickConfirmPrimaryRoleRecoveryProposalInput
+{
+    fn from(value: &AccessControllerFactorsAndTimeInput) -> Self {
+        Self {
+            rule_set: value.rule_set.clone(),
+            timed_recovery_delay_in_minutes: Some(
+                value.timed_recovery_delay_in_minutes,
+            ),
+        }
+    }
+}
+
+impl From<&AccessControllerFactorsAndTimeInput>
+    for ScryptoAccessControllerTimedConfirmRecoveryInput
+{
+    fn from(value: &AccessControllerFactorsAndTimeInput) -> Self {
+        Self {
+            rule_set: value.rule_set.clone(),
+            timed_recovery_delay_in_minutes: Some(
+                value.timed_recovery_delay_in_minutes,
+            ),
+        }
+    }
+}

crates/transaction/manifests/src/manifests_security_shield/manifests_securify_shield_securified_entity.rs

@@ -1,7 +1,8 @@
 #![allow(dead_code)]
-use profile_supporting_types::AnySecurifiedEntity;
-
 use crate::prelude::*;
+use std::ops::Deref;
+
+use profile_supporting_types::AnySecurifiedEntity;
 
 pub trait TransactionManifestSecurifySecurifiedEntity:
     TransactionManifestSetRolaKey
@@ -10,61 +11,76 @@
         securified_entity: AnySecurifiedEntity,
         input: TransactionManifestApplySecurityShieldSecurifiedInput,
     ) -> Result<TransactionManifest>;
-
-    fn _update_shield_exercising_recovery_and_explicit_confirmation(
-        builder: ScryptoTransactionManifestBuilder,
-        securified_entity: &AnySecurifiedEntity,
-        input: &TransactionManifestApplySecurityShieldSecurifiedInput,
-    ) -> Result<ScryptoTransactionManifestBuilder> {
-        todo!()
-    }
 }
 
 impl TransactionManifestSecurifySecurifiedEntity for TransactionManifest {
     fn apply_security_shield_for_securified_entity(
         securified_entity: AnySecurifiedEntity,
         input: TransactionManifestApplySecurityShieldSecurifiedInput,
     ) -> Result<Self> {
         let TransactionManifestApplySecurityShieldSecurifiedInput {
             security_structure_of_factor_instances,
             apply_shield_manifest_kind: kind,
         } = input.clone();
 
         let entity_address = securified_entity.entity.address();
 
-        let mut builder = ScryptoTransactionManifestBuilder::new();
+        // ACCESS_CONTROLLER_CREATE_PROOF_IDENT
+        let mut builder = TransactionManifest::produce_owner_badge(
+            ScryptoTransactionManifestBuilder::new(),
+            &securified_entity.entity,
+        );
+
+        let access_controller_address = securified_entity
+            .securified_entity_control
+            .access_controller_address;
+
+        let factors_and_time_input = &AccessControllerFactorsAndTimeInput::new(
+            &security_structure_of_factor_instances,
+        );
 
-        use TransactionManifestApplySecurityShieldKindSelector::*;
-        builder = match kind {
-            PrimaryAndRecoveryWithExplicitConfirmation => Self::_update_shield_exercising_recovery_and_explicit_confirmation(builder, &securified_entity, &input)?,
-            PrimaryAndRecoveryWithTimedAutoConfirm => todo!(),
-            PrimaryAndExplicitConfirmation => todo!(),
-            PrimaryWithTimedAutoConfirm => todo!(),
-            RecoveryAndExplicitConfirmation => todo!(),
-            RecoveryWithTimedAutoConfirm => todo!(),
-        };
+        // INITIATE RECOVERY
+        let (init_method, init_input) =
+            kind.input_for_initialization(factors_and_time_input);
+        builder = builder.call_method(
+            access_controller_address.scrypto(),
+            init_method,
+            (init_input.deref(),),
+        );
+
+        // CONFIRM RECOVERY
+        // TODO: for timed, should we really call it here, now? Should
+        // we not call it AFTER the time has elapsed???
+        let (confirm_method, confirm_input) =
+            kind.input_for_confirm(factors_and_time_input);
+        builder = builder.call_method(
+            access_controller_address.scrypto(),
+            confirm_method,
+            (confirm_input.deref(),),
+        );
 
         // Set Rola Key
         let should_set_rola_key = security_structure_of_factor_instances
             .authentication_signing_factor_instance
             != securified_entity
                 .current_authentication_signing_factor_instance();
+
         if should_set_rola_key {
             if kind.can_set_rola_key() {
                 builder = TransactionManifest::set_rola_key(
                     builder,
                     &security_structure_of_factor_instances
                         .authentication_signing_factor_instance,
                     &entity_address,
                 );
             } else {
                 return Err(CommonError::Unknown); // TODO: new error variant
             }
         }
 
         let manifest = TransactionManifest::sargon_built(
             builder,
             securified_entity.network_id(),
         );
 
         // N.B.
@@ -74,154 +90,6 @@
         // after user has selected account to pay in wallet GUI.
         // (and as usual also call `modify_manifest_lock_fee`)
 
         Ok(manifest)
     }
 }
-
-impl TransactionManifestApplySecurityShieldKindSelector {
-    fn can_exercise_primary_role(&self) -> bool {
-        match self {
-            Self::PrimaryAndRecoveryWithExplicitConfirmation => true,
-            Self::PrimaryAndRecoveryWithTimedAutoConfirm => true,
-            Self::PrimaryAndExplicitConfirmation => true,
-            Self::PrimaryWithTimedAutoConfirm => true,
-            Self::RecoveryAndExplicitConfirmation => false,
-            Self::RecoveryWithTimedAutoConfirm => false,
-        }
-    }
-
-    fn can_set_rola_key(&self) -> bool {
-        self.can_exercise_primary_role()
-    }
-
-    fn should_confirm_recovery_with_explicit(&self) -> bool {
-        match self {
-            Self::PrimaryAndRecoveryWithExplicitConfirmation => true,
-            Self::PrimaryAndRecoveryWithTimedAutoConfirm => false,
-            Self::PrimaryAndExplicitConfirmation => true,
-            Self::PrimaryWithTimedAutoConfirm => false,
-            Self::RecoveryAndExplicitConfirmation => true,
-            Self::RecoveryWithTimedAutoConfirm => false,
-        }
-    }
-
-    fn should_confirm_recovery_with_time(&self) -> bool {
-        match self {
-            Self::PrimaryAndRecoveryWithExplicitConfirmation => false,
-            Self::PrimaryAndRecoveryWithTimedAutoConfirm => true,
-            Self::PrimaryAndExplicitConfirmation => false,
-            Self::PrimaryWithTimedAutoConfirm => true,
-            Self::RecoveryAndExplicitConfirmation => false,
-            Self::RecoveryWithTimedAutoConfirm => true,
-        }
-    }
-
-    fn should_confirm_recovery(&self) -> bool {
-        self.should_confirm_recovery_with_explicit()
-            || self.should_confirm_recovery_with_time()
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum TransactionManifestApplySecurityShieldKindSelector {
-    /// (Primary Recovery Confirmation)
-    PrimaryAndRecoveryWithExplicitConfirmation,
-
-    /// (Primary Recovery Time)
-    PrimaryAndRecoveryWithTimedAutoConfirm,
-
-    /// (Primary Confirmation)
-    PrimaryAndExplicitConfirmation,
-
-    /// (Primary Time) ‼️ REQUIRES "Dugong" ‼️
-    PrimaryWithTimedAutoConfirm,
-
-    /// (Recovery Confirmation)
-    RecoveryAndExplicitConfirmation,
-
-    /// (Recovery Time)
-    RecoveryWithTimedAutoConfirm,
-}
-
-#[derive(Debug, Clone)]
-pub struct TransactionManifestApplySecurityShieldAnyInput {
-    pub security_structure_of_factor_instances:
-        SecurityStructureOfFactorInstances,
-    pub apply_shield_manifest_kind:
-        Option<TransactionManifestApplySecurityShieldKindSelector>,
-}
-impl TransactionManifestApplySecurityShieldAnyInput {
-    fn new(
-        security_structure_of_factor_instances:
-        SecurityStructureOfFactorInstances,
-        apply_shield_manifest_kind: impl Into<
-            Option<TransactionManifestApplySecurityShieldKindSelector>,
-        >,
-    ) -> Self {
-        Self {
-            security_structure_of_factor_instances,
-            apply_shield_manifest_kind: apply_shield_manifest_kind.into(),
-        }
-    }
-    pub fn for_securified(
-        security_structure_of_factor_instances:
-        SecurityStructureOfFactorInstances,
-        apply_shield_manifest_kind: TransactionManifestApplySecurityShieldKindSelector,
-    ) -> Self {
-        Self::new(
-            security_structure_of_factor_instances,
-            apply_shield_manifest_kind,
-        )
-    }
-    pub fn as_securified(
-        &self,
-    ) -> Result<TransactionManifestApplySecurityShieldSecurifiedInput> {
-        let apply_shield_manifest_kind = self
-            .apply_shield_manifest_kind
-            .clone()
-            .ok_or(CommonError::Unknown)?; // TODO: replace with proper error
-        Ok(TransactionManifestApplySecurityShieldSecurifiedInput {
-            security_structure_of_factor_instances: self
-                .security_structure_of_factor_instances
-                .clone(),
-            apply_shield_manifest_kind,
-        })
-    }
-    pub fn for_unsecurified(
-        security_structure_of_factor_instances:
-        SecurityStructureOfFactorInstances,
-    ) -> Self {
-        Self::new(security_structure_of_factor_instances, None)
-    }
-
-    pub fn as_unsecurified(
-        &self,
-    ) -> Result<TransactionManifestApplySecurityShieldUnsecurifiedInput> {
-        Ok(TransactionManifestApplySecurityShieldUnsecurifiedInput {
-            security_structure_of_factor_instances: self
-                .security_structure_of_factor_instances
-                .clone(),
-        })
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct TransactionManifestApplySecurityShieldSecurifiedInput {
-    pub security_structure_of_factor_instances:
-        SecurityStructureOfFactorInstances,
-    pub apply_shield_manifest_kind:
-        TransactionManifestApplySecurityShieldKindSelector,
-}
-
-impl TransactionManifestApplySecurityShieldSecurifiedInput {
-    pub fn new(
-        security_structure_of_factor_instances:
-        SecurityStructureOfFactorInstances,
-        apply_shield_manifest_kind: TransactionManifestApplySecurityShieldKindSelector,
-    ) -> Self {
-        Self {
-            security_structure_of_factor_instances,
-            apply_shield_manifest_kind,
-        }
-    }
-}