[WIP] Apply Shield Wallet Interaction Part 2

crates/common/numeric/src/decimal/decimal192.rs

@@ -59,7 +59,7 @@ impl Decimal {
         self.0
     }
 
-    fn from_native(decimal: ScryptoDecimal192) -> Self {
+    pub const fn from_native(decimal: ScryptoDecimal192) -> Self {
         Self(decimal)
     }
 

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

@@ -62,6 +62,13 @@
         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 veci(&self) -> Option<VirtualEntityCreatingInstance> {
         self.securified_entity_control()
             .veci()

crates/system/os/factors/src/apply_security_shield/sargon_os_apply_security_shield_interaction.rs

@@ -30,10 +30,9 @@
             .map(|e| {
                 let provisional = e.entity.get_provisional().expect("Entity should have a provisional config set since we applied shield above");
                 let derived = provisional.as_factor_instances_derived().expect("Should have derived factors");
-                let input = TransactionManifestApplySecurityShieldUnsecurifiedInput::new(derived.clone());
                 TransactionManifest::apply_security_shield_for_unsecurified_entity(
                     e,
-                    input,
+                    derived.clone()
                 )
         }).collect::<Result<Vec<TransactionManifest>>>()?;
 
@@ -42,8 +41,12 @@
              .iter()
              .map(|e| {
                 let provisional = e.entity.get_provisional().expect("Entity should have a provisional config set since we applied shield above");
-                let _derived = provisional.as_factor_instances_derived().expect("Should have derived factors");
-                todo!("Implement TransactionManifest::apply_security_shield_for_securified_entity")
+                let derived = provisional.as_factor_instances_derived().expect("Should have derived factors");
+                TransactionManifest::apply_security_shield_for_securified_entity(
+                    e,
+                    derived.clone(),
+                    TransactionManifestApplySecurityShieldKind::PrimaryAndRecoveryWithExplicitConfirmation
+                )
          }).collect::<Result<Vec<TransactionManifest>>>()?;
 
         Ok(DappToWalletInteractionBatchOfTransactions::new(

crates/transaction/manifests/Cargo.toml

@@ -33,6 +33,7 @@ sbor = { workspace = true }
 # === EXTERNAL DEPENDENCIES ===
 derive_more = { workspace = true }
 enum-as-inner = { workspace = true }
+enum-iterator = { workspace = true }
 itertools = { workspace = true }
 paste = { workspace = true }
 pretty_assertions = { workspace = true }

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

@@ -0,0 +1,106 @@
+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,
+};
+
+/// An ephemeral DTO that is used to create the input for the access controller
+/// methods that require factors and time - which we create from a
+/// `SecurityStructureOfFactorInstances`
+#[derive(Debug, Clone)]
+pub struct AccessControllerFactorsAndTimeInput {
+    /// RuleSet is Scrypto representation of the security structure's
+    /// MatrixOfFactors
+    rule_set: ScryptoRuleSet,
+    /// The timed recovery delay in minutes we get from `SecurityStructureOfFactorInstances`.
+    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/confirm_timed_recovery.rs

@@ -0,0 +1,27 @@
+use crate::prelude::*;
+
+// use radix_engine_interface::blueprints::access_controller::{
+//     AccessControllerTimedConfirmRecoveryInput as ScryptoAccessControllerTimedConfirmRecoveryInput,
+//     ACCESS_CONTROLLER_TIMED_CONFIRM_RECOVERY_IDENT as SCRYPTO_ACCESS_CONTROLLER_TIMED_CONFIRM_RECOVERY_IDENT,
+// };
+
+pub trait TransactionManifestConfirmTimedRecovery {
+    /// TBD
+    /// TODO: Figure out how to do this...
+    /// since `AccessControllerTimedConfirmRecoveryInput` need the input of
+    /// the factors and time which was used to start recovery - which could not
+    /// be quick confirmed. We need to figure out how we best represent this
+    /// in Profile. Perhaps a new variant on ProvisionalSecurityConfig? Something
+    /// like:
+    /// `WaitingForTimedRecovery(SecurityStructureOfFactorInstances)`
+    fn confirm_timed_recovery() -> Result<TransactionManifest>;
+    // {
+    //     builder.call_method(
+    //          access_controller,
+    //          SCRYPTO_ACCESS_CONTROLLER_TIMED_CONFIRM_RECOVERY_IDENT,
+    //         ScryptoAccessControllerTimedConfirmRecoveryInput::from(
+    //             factors_and_time,
+    //         ),
+    //     );
+    // }
+}

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

@@ -0,0 +1,51 @@
+use profile_supporting_types::AnySecurifiedEntity;
+use radix_engine_interface::blueprints::access_controller::{
+    AccessControllerLockRecoveryFeeInput as ScryptoAccessControllerLockRecoveryFeeInput,
+    ACCESS_CONTROLLER_LOCK_RECOVERY_FEE_IDENT as SCRYPTO_ACCESS_CONTROLLER_LOCK_RECOVERY_FEE_IDENT,
+};
+use radix_transactions::prelude::ManifestBuilder;
+
+use crate::prelude::*;
+
+pub trait TransactionManifestLockFeeAgainstXrdVaultOfAccessController {
+    /// Locks transaction fee against the XRD vault of the access controller of
+    /// `entity_applying_shield` - either AC of an Account or of a Persona.
+    ///
+    /// We need to call this later when we have made a preview/dry-run of the
+    /// `manifest` to get the actual fee to lock.
+    ///
+    /// `manifest` was produced by `apply_security_shield_for_securified_entity`.
+    ///
+    /// In fact we will be locking fee for 6 flavours of transaction manifest
+    /// which updates the security shield of an entity, as returned by
+    /// `TransactionManifestApplySecurityShieldKind::all()`, and we could try to
+    /// be smart and run preview of each six to get a minimial fee per manifest,
+    /// but we will avoid that complexity.
+    ///
+    /// Only relevant for securified entities - since it is only securified entities
+    /// which have an access controller to lock against.
+    fn modify_manifest_add_lock_fee_against_xrd_vault_of_access_controller(
+        manifest: TransactionManifest,
+        fee: Decimal192,
+        // TODO: remove `entity_applying_shield`, this should be read out from the manifest in a throwing function, `manifest.get_address_of_entity_applying_shield()` or similar which Omar need to provide us with, oh well we need the account here, so elsewhere, in SargonOS where we have access to Profile we would call `manifest.get_address_of_entity_applying_shield` and then lookup the entity.
+        entity_applying_shield: AnySecurifiedEntity,
+    ) -> TransactionManifest {
+        let mut builder = ManifestBuilder::with_manifest(manifest);
+        let access_controller_address = entity_applying_shield
+            .securified_entity_control
+            .access_controller_address;
+        // Lock fee against XRD vault of the access controller
+        builder = builder.call_method(
+            access_controller_address.scrypto(),
+            SCRYPTO_ACCESS_CONTROLLER_LOCK_RECOVERY_FEE_IDENT,
+            ScryptoAccessControllerLockRecoveryFeeInput {
+                amount: ScryptoDecimal192::from(fee),
+            },
+        );
+
+        TransactionManifest::sargon_built(
+            builder,
+            entity_applying_shield.entity.network_id(),
+        )
+    }
+}

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

@@ -0,0 +1,113 @@
+#![allow(dead_code)]
+use crate::prelude::*;
+use std::ops::Deref;
+
+use profile_supporting_types::AnySecurifiedEntity;
+
+pub trait TransactionManifestSecurifySecurifiedEntity:
+    TransactionManifestSetRolaKey
+{
+    fn apply_security_shield_for_securified_entity(
+        securified_entity: AnySecurifiedEntity,
+        security_structure_of_factor_instances:
+        SecurityStructureOfFactorInstances,
+        apply_shield_manifest_kind: TransactionManifestApplySecurityShieldKind,
+    ) -> Result<TransactionManifest>;
+}
+
+impl TransactionManifestSecurifySecurifiedEntity for TransactionManifest {
+    /// Updates the security shield of a securified entity to `security_structure_of_factor_instances`.
+    ///
+    /// Also conditionally updates the Rola key of the entity - if it is new.
+    ///
+    /// Later once we have got a preview from Gateway - we will need to call:
+    /// * `modify_manifest_add_lock_fee_against_xrd_vault_of_access_controller`
+    ///
+    /// And when we know the fee we can calculate how much to top up the XRD vault of the AccessController
+    /// and call
+    /// * `modify_manifest_add_withdraw_of_xrd_for_access_controller_xrd_vault_top_up_paid_by_account`
+    ///
+    /// For timed confirmation - much later (`timed_recovery_delay_in_minutes` later ) the
+    /// host app will need to call `confirm_timed_recovery`
+    fn apply_security_shield_for_securified_entity(
+        securified_entity: AnySecurifiedEntity,
+        security_structure_of_factor_instances:
+        SecurityStructureOfFactorInstances,
+        apply_shield_manifest_kind: TransactionManifestApplySecurityShieldKind,
+    ) -> Result<Self> {
+        let kind = apply_shield_manifest_kind;
+        let entity_address = securified_entity.entity.address();
+
+        // 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,
+        );
+
+        // 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(),),
+        );
+
+        // QUICK CONFIRM RECOVERY - Only if we can exercise the confirmation role explicitly.
+        if let Some((confirm_method, confirm_input)) =
+            kind.input_for_quick_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.
+        // We will not lock fee against the XRD vault yet - we will do that
+        // later when we have made a preview/dry-run of the `manifest` to get
+        // the estimated fee to lock, by calling `modify_manifest_add_lock_fee_against_xrd_vault_of_access_controller`
+        //
+        // Furthermore:
+        // We do NOT top of XRD vault of AccessController - yet!
+        // Host will need to call the function:
+        // `modify_manifest_add_withdraw_of_xrd_for_access_controller_xrd_vault_top_up_paid_by_account`
+        // after user has selected account to pay in wallet GUI.
+        // (and as usual also call `modify_manifest_lock_fee`)
+
+        Ok(manifest)
+    }
+}