Unmocking guardian

packages/account_sdk/src/abigen/controller.rs

@@ -2118,6 +2118,20 @@ impl<A: starknet::accounts::ConnectedAccount + Sync> Controller<A> {
     }
     #[allow(clippy::ptr_arg)]
     #[allow(clippy::too_many_arguments)]
+    pub fn get_guardian_guid(
+        &self,
+    ) -> cainome::cairo_serde::call::FCall<A::Provider, Option<Signer>> {
+        use cainome::cairo_serde::CairoSerde;
+        let mut __calldata = vec![];
+        let __call = starknet::core::types::FunctionCall {
+            contract_address: self.address,
+            entry_point_selector: starknet::macros::selector!("get_guardian_guid"),
+            calldata: __calldata,
+        };
+        cainome::cairo_serde::call::FCall::new(__call, self.provider())
+    }
+    #[allow(clippy::ptr_arg)]
+    #[allow(clippy::too_many_arguments)]
     pub fn get_outside_execution_message_hash_rev_0(
         &self,
         outside_execution: &OutsideExecution,
@@ -2188,6 +2202,26 @@ impl<A: starknet::accounts::ConnectedAccount + Sync> Controller<A> {
     }
     #[allow(clippy::ptr_arg)]
     #[allow(clippy::too_many_arguments)]
+    pub fn is_session_registered(
+        &self,
+        session_hash: &starknet::core::types::Felt,
+        guid_or_address: &starknet::core::types::Felt,
+    ) -> cainome::cairo_serde::call::FCall<A::Provider, bool> {
+        use cainome::cairo_serde::CairoSerde;
+        let mut __calldata = vec![];
+        __calldata.extend(starknet::core::types::Felt::cairo_serialize(session_hash));
+        __calldata.extend(starknet::core::types::Felt::cairo_serialize(
+            guid_or_address,
+        ));
+        let __call = starknet::core::types::FunctionCall {
+            contract_address: self.address,
+            entry_point_selector: starknet::macros::selector!("is_session_registered"),
+            calldata: __calldata,
+        };
+        cainome::cairo_serde::call::FCall::new(__call, self.provider())
+    }
+    #[allow(clippy::ptr_arg)]
+    #[allow(clippy::too_many_arguments)]
     pub fn is_session_revoked(
         &self,
         session_hash: &starknet::core::types::Felt,
@@ -2204,6 +2238,22 @@ impl<A: starknet::accounts::ConnectedAccount + Sync> Controller<A> {
     }
     #[allow(clippy::ptr_arg)]
     #[allow(clippy::too_many_arguments)]
+    pub fn is_valid_guardian(
+        &self,
+        guardian_guid: &starknet::core::types::Felt,
+    ) -> cainome::cairo_serde::call::FCall<A::Provider, bool> {
+        use cainome::cairo_serde::CairoSerde;
+        let mut __calldata = vec![];
+        __calldata.extend(starknet::core::types::Felt::cairo_serialize(guardian_guid));
+        let __call = starknet::core::types::FunctionCall {
+            contract_address: self.address,
+            entry_point_selector: starknet::macros::selector!("is_valid_guardian"),
+            calldata: __calldata,
+        };
+        cainome::cairo_serde::call::FCall::new(__call, self.provider())
+    }
+    #[allow(clippy::ptr_arg)]
+    #[allow(clippy::too_many_arguments)]
     pub fn is_valid_outside_execution_nonce(
         &self,
         nonce: &starknet::core::types::Felt,
@@ -2764,6 +2814,18 @@ impl<P: starknet::providers::Provider + Sync> ControllerReader<P> {
     }
     #[allow(clippy::ptr_arg)]
     #[allow(clippy::too_many_arguments)]
+    pub fn get_guardian_guid(&self) -> cainome::cairo_serde::call::FCall<P, Option<Signer>> {
+        use cainome::cairo_serde::CairoSerde;
+        let mut __calldata = vec![];
+        let __call = starknet::core::types::FunctionCall {
+            contract_address: self.address,
+            entry_point_selector: starknet::macros::selector!("get_guardian_guid"),
+            calldata: __calldata,
+        };
+        cainome::cairo_serde::call::FCall::new(__call, self.provider())
+    }
+    #[allow(clippy::ptr_arg)]
+    #[allow(clippy::too_many_arguments)]
     pub fn get_outside_execution_message_hash_rev_0(
         &self,
         outside_execution: &OutsideExecution,
@@ -2834,6 +2896,26 @@ impl<P: starknet::providers::Provider + Sync> ControllerReader<P> {
     }
     #[allow(clippy::ptr_arg)]
     #[allow(clippy::too_many_arguments)]
+    pub fn is_session_registered(
+        &self,
+        session_hash: &starknet::core::types::Felt,
+        guid_or_address: &starknet::core::types::Felt,
+    ) -> cainome::cairo_serde::call::FCall<P, bool> {
+        use cainome::cairo_serde::CairoSerde;
+        let mut __calldata = vec![];
+        __calldata.extend(starknet::core::types::Felt::cairo_serialize(session_hash));
+        __calldata.extend(starknet::core::types::Felt::cairo_serialize(
+            guid_or_address,
+        ));
+        let __call = starknet::core::types::FunctionCall {
+            contract_address: self.address,
+            entry_point_selector: starknet::macros::selector!("is_session_registered"),
+            calldata: __calldata,
+        };
+        cainome::cairo_serde::call::FCall::new(__call, self.provider())
+    }
+    #[allow(clippy::ptr_arg)]
+    #[allow(clippy::too_many_arguments)]
     pub fn is_session_revoked(
         &self,
         session_hash: &starknet::core::types::Felt,
@@ -2850,6 +2932,22 @@ impl<P: starknet::providers::Provider + Sync> ControllerReader<P> {
     }
     #[allow(clippy::ptr_arg)]
     #[allow(clippy::too_many_arguments)]
+    pub fn is_valid_guardian(
+        &self,
+        guardian_guid: &starknet::core::types::Felt,
+    ) -> cainome::cairo_serde::call::FCall<P, bool> {
+        use cainome::cairo_serde::CairoSerde;
+        let mut __calldata = vec![];
+        __calldata.extend(starknet::core::types::Felt::cairo_serialize(guardian_guid));
+        let __call = starknet::core::types::FunctionCall {
+            contract_address: self.address,
+            entry_point_selector: starknet::macros::selector!("is_valid_guardian"),
+            calldata: __calldata,
+        };
+        cainome::cairo_serde::call::FCall::new(__call, self.provider())
+    }
+    #[allow(clippy::ptr_arg)]
+    #[allow(clippy::too_many_arguments)]
     pub fn is_valid_outside_execution_nonce(
         &self,
         nonce: &starknet::core::types::Felt,

packages/account_sdk/src/account/session/hash.rs

@@ -5,15 +5,14 @@ use starknet::core::types::Felt;
 use starknet::core::utils::NonAsciiNameError;
 use starknet::macros::selector;
 use starknet_crypto::poseidon_hash_many;
-use starknet_types_core::hash::Poseidon;
 
 use crate::abigen::controller::Signer as AbigenSigner;
 
-use crate::hash::MessageHashRev1;
 use crate::signers::{SignError, SignerTrait};
 
 use super::merkle::MerkleTree;
 use super::raw_session::RawSession;
+use super::raw_session::SessionHash;
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct ProvedPolicy {
@@ -81,10 +80,7 @@ impl Session {
         chain_id: Felt,
         address: Felt,
     ) -> Result<Felt, NonAsciiNameError> {
-        let token_session_hash = self.raw().get_message_hash_rev_1(chain_id, address);
-        let mut msg_hash = [tx_hash, token_session_hash, Felt::TWO];
-        Poseidon::hades_permutation(&mut msg_hash);
-        Ok(msg_hash[0])
+        self.raw().get_session_hash(chain_id, address, tx_hash)
     }
 
     pub fn single_proof(&self, policy: &Policy) -> Option<Vec<Felt>> {

packages/account_sdk/src/account/session/raw_session.rs

@@ -1,7 +1,9 @@
 use cainome::cairo_serde::CairoSerde;
 use starknet::core::types::Felt;
+use starknet::core::utils::NonAsciiNameError;
 use starknet::macros::{selector, short_string};
 use starknet_crypto::poseidon_hash_many;
+use starknet_types_core::hash::Poseidon;
 
 use crate::{
     abigen::controller::SignerSignature,
@@ -43,6 +45,29 @@ impl MessageHashRev1 for RawSession {
     }
 }
 
+pub trait SessionHash {
+    fn get_session_hash(
+        &self,
+        chain_id: Felt,
+        address: Felt,
+        tx_hash: Felt,
+    ) -> Result<Felt, NonAsciiNameError>;
+}
+
+impl SessionHash for RawSession {
+    fn get_session_hash(
+        &self,
+        chain_id: Felt,
+        address: Felt,
+        tx_hash: Felt,
+    ) -> Result<Felt, NonAsciiNameError> {
+        let token_session_hash = self.get_message_hash_rev_1(chain_id, address);
+        let mut msg_hash = [tx_hash, token_session_hash, Felt::TWO];
+        Poseidon::hades_permutation(&mut msg_hash);
+        Ok(msg_hash[0])
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct RawSessionToken {
     pub(crate) session: RawSession,

packages/account_sdk/src/artifacts.rs

@@ -27,9 +27,9 @@ lazy_static! {
             Version::LATEST,
             ContractClass {
                 content: include_str!("../artifacts/controller.latest.contract_class.json"),
-                hash: felt!("0x32e17891b6cc89e0c3595a3df7cee760b5993744dc8dfef2bd4d443e65c0f40"),
+                hash: felt!("0x48a59af60f682755b11ef727d0f5dcf3947ef4e451099f171d06abb7a7cc710"),
                 casm_hash: felt!(
-                    "0x46b6264bd23cdea881b1b1110d7e1e5408507fa847f053ca9b272f4cbe1d55c"
+                    "0x2a7139059dce9f414a1647ee5200f20029efb327f6a8d6aebe49f8729106a6a"
                 ),
             },
         );

packages/account_sdk/src/provider.rs

@@ -25,7 +25,7 @@ mod provider_test;
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[auto_impl(&, Arc)]
-pub trait CartridgeProvider: Provider {
+pub trait CartridgeProvider: Provider + Clone {
     async fn add_execute_outside_transaction(
         &self,
         outside_execution: OutsideExecution,

packages/account_sdk/src/session_test.rs

@@ -9,12 +9,13 @@ use starknet::{
 use starknet_crypto::Felt;
 
 use crate::{
-    abigen::erc_20::Erc20,
+    abigen::{self, erc_20::Erc20},
     account::session::{
         hash::{Policy, Session},
         SessionAccount,
     },
     artifacts::Version,
+    hash::MessageHashRev1,
     signers::{webauthn::WebauthnSigner, HashSigner, Signer, SignerTrait},
     tests::{
         account::FEE_TOKEN_ADDRESS, ensure_txn, runners::katana::KatanaRunner,
@@ -215,7 +216,7 @@ async fn test_create_and_use_registered_session() {
 
     // Register the session
     let expires_at = u64::MAX;
-    let max_fee = Felt::from(277600000000000_u128);
+    let max_fee = Felt::from(277800000000000_u128);
     let txn = controller
         .register_session(policies.clone(), expires_at, public_key, max_fee)
         .await
@@ -226,16 +227,31 @@ async fn test_create_and_use_registered_session() {
         .await
         .unwrap();
 
+    let session = Session::new(policies, expires_at, &session_signer.signer()).unwrap();
+
     // Create a SessionAccount using new_from_registered
     let session_account = SessionAccount::new_as_registered(
         runner.client().clone(),
         session_signer.clone(),
         controller.address(),
         controller.chain_id(),
         owner_signer.signer().guid(),
-        Session::new(policies, expires_at, &session_signer.signer()).unwrap(),
+        session.clone(),
     );
 
+    let is_registered =
+        abigen::controller::ControllerReader::new(controller.address(), runner.client())
+            .is_session_registered(
+                &session
+                    .raw()
+                    .get_message_hash_rev_1(controller.chain_id, controller.address),
+                &owner_signer.signer().guid(),
+            )
+            .call()
+            .await
+            .unwrap();
+    assert!(is_registered);
+
     // Use the session account to perform a transfer
     let recipient = ContractAddress(felt!("0x18301129"));
     let contract_erc20 = Erc20::new(*FEE_TOKEN_ADDRESS, &session_account);

packages/account_sdk/src/tests/guardian_test.rs

@@ -8,15 +8,15 @@ use crate::{
     abigen::erc_20::Erc20,
     artifacts::Version,
     signers::{webauthn::WebauthnSigner, Signer},
-    tests::{account::FEE_TOKEN_ADDRESS, runners::katana::KatanaRunner},
+    tests::{account::FEE_TOKEN_ADDRESS, runners::katana::KatanaRunner, EnsureTxnError},
 };
 
 use super::ensure_txn;
 
 pub async fn test_verify_execute(signer: Signer) {
     let runner = KatanaRunner::load();
     let controller = runner
-        .deploy_controller("username".to_owned(), signer, Version::LATEST)
+        .deploy_controller_with_guardian("username".to_owned(), signer, Version::LATEST)
         .await;
 
     let new_account = ContractAddress(felt!("0x18301129"));
@@ -46,7 +46,7 @@ pub async fn test_verify_execute(signer: Signer) {
 
 #[cfg(feature = "webauthn")]
 #[tokio::test]
-async fn test_verify_execute_webauthn() {
+async fn test_verify_execute_guardian_owner_webauthn() {
     let signer = Signer::Webauthn(
         WebauthnSigner::register(
             "cartridge.gg".to_string(),
@@ -61,6 +61,39 @@ async fn test_verify_execute_webauthn() {
 }
 
 #[tokio::test]
-async fn test_verify_execute_starkpair() {
+async fn test_verify_execute_guardian_owner_starknet() {
     test_verify_execute(Signer::new_starknet_random()).await;
 }
+
+#[tokio::test]
+async fn test_verify_execute_guardian_should_fail_no_guardian() {
+    let runner = KatanaRunner::load();
+    let signer = Signer::new_starknet_random();
+    let controller = runner
+        .deploy_controller("username".to_owned(), signer, Version::LATEST)
+        .await;
+
+    let new_account = ContractAddress(felt!("0x18301129"));
+
+    let contract_erc20 = Erc20::new(*FEE_TOKEN_ADDRESS, &controller);
+
+    contract_erc20
+        .balanceOf(&new_account)
+        .block_id(BlockId::Tag(BlockTag::Latest))
+        .call()
+        .await
+        .expect("failed to call contract");
+
+    let result = ensure_txn(
+        contract_erc20.transfer(
+            &new_account,
+            &U256 {
+                low: 0x10_u128,
+                high: 0,
+            },
+        ),
+        runner.client(),
+    )
+    .await;
+    matches!(result, Err(EnsureTxnError::TransactionWaitingError(_)));
+}

packages/account_sdk/src/tests/mod.rs

@@ -37,7 +37,7 @@ where
     P: Provider + Sync + Send,
 {
     let tx = execution
-        .fee_estimate_multiplier(1.5)
+        .fee_estimate_multiplier(1.6)
         .send()
         .await
         .map_err(EnsureTxnError::from)?;