From 1124cf1b45430241a232d4e05b6e9f72962ddbbf Mon Sep 17 00:00:00 2001 From: Tarrence van As Date: Tue, 1 Oct 2024 17:20:37 -0400 Subject: [PATCH] Add session as registered test (#791) --- .../account_sdk/src/account/session/mod.rs | 5 +- packages/account_sdk/src/session.rs | 16 +- packages/account_sdk/src/session_test.rs | 254 ++++++++++++++++++ packages/account_sdk/src/tests/mod.rs | 2 - .../src/tests/register_session_test.rs | 79 ------ .../account_sdk/src/tests/session_test.rs | 127 --------- 6 files changed, 270 insertions(+), 213 deletions(-) create mode 100644 packages/account_sdk/src/session_test.rs delete mode 100644 packages/account_sdk/src/tests/register_session_test.rs delete mode 100644 packages/account_sdk/src/tests/session_test.rs diff --git a/packages/account_sdk/src/account/session/mod.rs b/packages/account_sdk/src/account/session/mod.rs index e38a56a21..53a8119a0 100644 --- a/packages/account_sdk/src/account/session/mod.rs +++ b/packages/account_sdk/src/account/session/mod.rs @@ -127,11 +127,12 @@ where .session .message_hash(hash, self.chain_id, self.address)?; let result = self.sign(tx_hash, calls).await?; - Ok([ + let sig = [ vec![Self::session_magic()], RawSessionToken::cairo_serialize(&result), ] - .concat()) + .concat(); + Ok(sig) } } diff --git a/packages/account_sdk/src/session.rs b/packages/account_sdk/src/session.rs index 79287d638..9c7174302 100644 --- a/packages/account_sdk/src/session.rs +++ b/packages/account_sdk/src/session.rs @@ -15,6 +15,10 @@ use crate::storage::{Credentials, Selectors, SessionMetadata, StorageValue}; use crate::utils::time::get_current_timestamp; use crate::Backend; +#[cfg(test)] +#[path = "session_test.rs"] +mod session_test; + impl Controller where P: CartridgeProvider + Send + Sync + Clone, @@ -83,8 +87,6 @@ where public_key: Felt, max_fee: Felt, ) -> Result { - let call = self.register_session_call(policies.clone(), expires_at, public_key)?; - let txn = self.execute(vec![call], max_fee).await?; let session = Session::new( policies, expires_at, @@ -93,15 +95,23 @@ where }), )?; + let txn = self + .contract() + .register_session(&session.raw(), &self.owner_guid()) + .max_fee(max_fee) + .send() + .await?; + self.backend.set( &Selectors::session(&self.address, &self.app_id, &self.chain_id), &StorageValue::Session(SessionMetadata { session: session.clone(), max_fee: None, credentials: None, - is_registered: false, + is_registered: true, }), )?; + Ok(txn) } diff --git a/packages/account_sdk/src/session_test.rs b/packages/account_sdk/src/session_test.rs new file mode 100644 index 000000000..dc985068b --- /dev/null +++ b/packages/account_sdk/src/session_test.rs @@ -0,0 +1,254 @@ +use crate::{ + abigen::erc_20::Erc20, + account::session::{ + hash::{Policy, Session}, + SessionAccount, + }, + artifacts::Version, + signers::{webauthn::WebauthnSigner, HashSigner, Signer, SignerTrait}, + tests::{ + account::{webauthn::SoftPasskeySigner, FEE_TOKEN_ADDRESS}, + ensure_txn, + runners::katana::KatanaRunner, + }, + transaction_waiter::TransactionWaiter, +}; +use cainome::cairo_serde::{ContractAddress, U256}; +use starknet::{ + accounts::{Account, ConnectedAccount}, + core::types::{BlockId, BlockTag}, + macros::{felt, selector}, + providers::Provider, + signers::SigningKey, +}; +use starknet_crypto::Felt; + +pub async fn test_verify_execute(signer: Signer) { + let runner = KatanaRunner::load(); + let mut controller = runner + .deploy_controller("username".to_owned(), signer, Version::LATEST) + .await; + + let policies = vec![ + Policy::new(*FEE_TOKEN_ADDRESS, selector!("tdfs")), + Policy::new(*FEE_TOKEN_ADDRESS, selector!("transfds")), + Policy::new(*FEE_TOKEN_ADDRESS, selector!("transfer")), + ]; + + let session_account = controller + .create_session(policies.clone(), u64::MAX) + .await + .unwrap(); + + let recipient = ContractAddress(felt!("0x18301129")); + let contract_erc20 = Erc20::new(*FEE_TOKEN_ADDRESS, &session_account); + + contract_erc20 + .balanceOf(&recipient) + .block_id(BlockId::Tag(BlockTag::Latest)) + .call() + .await + .expect("failed to call contract"); + + contract_erc20 + .transfer( + &recipient, + &U256 { + low: 0x10_u128, + high: 0, + }, + ) + .send() + .await + .unwrap(); +} + +#[tokio::test] +async fn test_verify_execute_session_webauthn_starknet_starknet() { + let signer = Signer::Webauthn( + WebauthnSigner::register( + "cartridge.gg".to_string(), + "username".to_string(), + "challenge".as_bytes(), + SoftPasskeySigner::new("https://cartridge.gg".try_into().unwrap()), + ) + .await + .unwrap(), + ); + + test_verify_execute(signer).await; +} + +#[tokio::test] +async fn test_verify_execute_session_starknet_x3() { + test_verify_execute(Signer::new_starknet_random()).await; +} + +#[tokio::test] +async fn test_verify_execute_session_multiple() { + let signer = Signer::new_starknet_random(); + let runner = KatanaRunner::load(); + let mut controller = runner + .deploy_controller("username".to_owned(), signer, Version::LATEST) + .await; + + let session_account = controller + .create_session( + vec![ + Policy::new(*FEE_TOKEN_ADDRESS, selector!("tdfs")), + Policy::new(*FEE_TOKEN_ADDRESS, selector!("transfds")), + Policy::new(*FEE_TOKEN_ADDRESS, selector!("transfer")), + ], + u64::MAX, + ) + .await + .unwrap(); + + let recipient = ContractAddress(felt!("0x18301129")); + let contract_erc20 = Erc20::new(*FEE_TOKEN_ADDRESS, &session_account); + + contract_erc20 + .balanceOf(&recipient) + .block_id(BlockId::Tag(BlockTag::Latest)) + .call() + .await + .expect("failed to call contract"); + + for _ in 0u32..3 { + let tx = contract_erc20 + .transfer( + &recipient, + &U256 { + low: 0x1_u128, + high: 0, + }, + ) + .send() + .await + .unwrap(); + + TransactionWaiter::new(tx.transaction_hash, runner.client()) + .wait() + .await + .unwrap(); + } +} + +#[tokio::test] +async fn test_verify_execute_session_registered() { + let owner_signer = Signer::new_starknet_random(); + let session_signer = Signer::new_starknet_random(); + + let runner = KatanaRunner::load(); + let controller = runner + .deploy_controller("username".to_owned(), owner_signer.clone(), Version::LATEST) + .await; + + let session = Session::new( + vec![ + Policy::new(*FEE_TOKEN_ADDRESS, selector!("tdfs")), + Policy::new(*FEE_TOKEN_ADDRESS, selector!("transfds")), + Policy::new(*FEE_TOKEN_ADDRESS, selector!("transfer")), + ], + u64::MAX, + &session_signer.signer(), + ) + .unwrap(); + + ensure_txn( + controller + .contract() + .register_session(&session.raw(), &owner_signer.signer().guid()), + controller.provider(), + ) + .await + .unwrap(); + + let session_account = SessionAccount::new_as_registered( + runner.client(), + session_signer, + controller.address(), + runner.client().chain_id().await.unwrap(), + owner_signer.signer().guid(), + session, + ); + + let recipient = ContractAddress(felt!("0x18301129")); + let contract_erc20 = Erc20::new(*FEE_TOKEN_ADDRESS, &session_account); + + contract_erc20 + .balanceOf(&recipient) + .block_id(BlockId::Tag(BlockTag::Latest)) + .call() + .await + .expect("failed to call contract"); + + contract_erc20 + .transfer( + &recipient, + &U256 { + low: 0x10_u128, + high: 0, + }, + ) + .send() + .await + .unwrap(); +} + +#[tokio::test] +async fn test_create_and_use_registered_session() { + let owner_signer = Signer::new_starknet_random(); + let runner = KatanaRunner::load(); + let mut controller = runner + .deploy_controller("username".to_owned(), owner_signer.clone(), Version::LATEST) + .await; + + // Create policies for the session + let policies = vec![ + Policy::new(*FEE_TOKEN_ADDRESS, selector!("transfer")), + Policy::new(*FEE_TOKEN_ADDRESS, selector!("approve")), + ]; + + // Generate a new key pair for the session + let session_key = SigningKey::from_random(); + let session_signer = Signer::Starknet(session_key.clone()); + let public_key = session_key.verifying_key().scalar(); + + // Register the session + let expires_at = u64::MAX; + let max_fee = Felt::from(277600000000000_u128); + let txn = controller + .register_session(policies.clone(), expires_at, public_key, max_fee) + .await + .expect("Failed to register session"); + + TransactionWaiter::new(txn.transaction_hash, runner.client()) + .wait() + .await + .unwrap(); + + // Create a SessionAccount using new_from_registered + let session_account = SessionAccount::new_as_registered( + runner.client(), + session_signer.clone(), + controller.address(), + controller.chain_id(), + owner_signer.signer().guid(), + Session::new(policies, expires_at, &session_signer.signer()).unwrap(), + ); + + // Use the session account to perform a transfer + let recipient = ContractAddress(felt!("0x18301129")); + let contract_erc20 = Erc20::new(*FEE_TOKEN_ADDRESS, &session_account); + + let tx = contract_erc20.transfer( + &recipient, + &U256 { + low: 0x1_u128, + high: 0, + }, + ); + + ensure_txn(tx, controller.provider()).await.unwrap(); +} diff --git a/packages/account_sdk/src/tests/mod.rs b/packages/account_sdk/src/tests/mod.rs index a7b992ec6..9b1a01479 100644 --- a/packages/account_sdk/src/tests/mod.rs +++ b/packages/account_sdk/src/tests/mod.rs @@ -20,8 +20,6 @@ mod guardian_test; mod outside_execution_test; mod owner_test; mod paymaster_test; -mod register_session_test; -mod session_test; mod upgrade_test; #[derive(Error, Debug)] diff --git a/packages/account_sdk/src/tests/register_session_test.rs b/packages/account_sdk/src/tests/register_session_test.rs deleted file mode 100644 index fccdfc25d..000000000 --- a/packages/account_sdk/src/tests/register_session_test.rs +++ /dev/null @@ -1,79 +0,0 @@ -use crate::{ - abigen::erc_20::Erc20, - account::session::{ - hash::{Policy, Session}, - SessionAccount, - }, - artifacts::Version, - signers::{HashSigner, Signer, SignerTrait}, - tests::{account::FEE_TOKEN_ADDRESS, ensure_txn, runners::katana::KatanaRunner}, -}; -use cainome::cairo_serde::{ContractAddress, U256}; -use starknet::{ - accounts::{Account, ConnectedAccount}, - core::types::{BlockId, BlockTag}, - macros::{felt, selector}, - providers::Provider, -}; - -#[tokio::test] -async fn test_verify_execute_session_registered() { - let signer = Signer::new_starknet_random(); - let session_signer = Signer::new_starknet_random(); - - let runner = KatanaRunner::load(); - let controller = runner - .deploy_controller("username".to_owned(), signer.clone(), Version::LATEST) - .await; - - let session = Session::new( - vec![ - Policy::new(*FEE_TOKEN_ADDRESS, selector!("tdfs")), - Policy::new(*FEE_TOKEN_ADDRESS, selector!("transfds")), - Policy::new(*FEE_TOKEN_ADDRESS, selector!("transfer")), - ], - u64::MAX, - &session_signer.signer(), - ) - .unwrap(); - - ensure_txn( - controller - .contract() - .register_session(&session.raw(), &signer.signer().guid()), - controller.provider(), - ) - .await - .unwrap(); - - let session_account = SessionAccount::new_as_registered( - runner.client(), - session_signer, - controller.address(), - runner.client().chain_id().await.unwrap(), - signer.signer().guid(), - session, - ); - - let recipient = ContractAddress(felt!("0x18301129")); - let contract_erc20 = Erc20::new(*FEE_TOKEN_ADDRESS, &session_account); - - contract_erc20 - .balanceOf(&recipient) - .block_id(BlockId::Tag(BlockTag::Latest)) - .call() - .await - .expect("failed to call contract"); - - contract_erc20 - .transfer( - &recipient, - &U256 { - low: 0x10_u128, - high: 0, - }, - ) - .send() - .await - .unwrap(); -} diff --git a/packages/account_sdk/src/tests/session_test.rs b/packages/account_sdk/src/tests/session_test.rs deleted file mode 100644 index 5d6668a39..000000000 --- a/packages/account_sdk/src/tests/session_test.rs +++ /dev/null @@ -1,127 +0,0 @@ -use crate::{ - abigen::erc_20::Erc20, - account::session::hash::Policy, - artifacts::Version, - signers::{webauthn::WebauthnSigner, Signer}, - tests::{ - account::{webauthn::SoftPasskeySigner, FEE_TOKEN_ADDRESS}, - runners::katana::KatanaRunner, - }, - transaction_waiter::TransactionWaiter, -}; -use cainome::cairo_serde::{ContractAddress, U256}; -use starknet::{ - core::types::{BlockId, BlockTag}, - macros::{felt, selector}, -}; - -pub async fn test_verify_execute(signer: Signer) { - let runner = KatanaRunner::load(); - let mut controller = runner - .deploy_controller("username".to_owned(), signer, Version::LATEST) - .await; - - let policies = vec![ - Policy::new(*FEE_TOKEN_ADDRESS, selector!("tdfs")), - Policy::new(*FEE_TOKEN_ADDRESS, selector!("transfds")), - Policy::new(*FEE_TOKEN_ADDRESS, selector!("transfer")), - ]; - - let session_account = controller - .create_session(policies.clone(), u64::MAX) - .await - .unwrap(); - - let recipient = ContractAddress(felt!("0x18301129")); - let contract_erc20 = Erc20::new(*FEE_TOKEN_ADDRESS, &session_account); - - contract_erc20 - .balanceOf(&recipient) - .block_id(BlockId::Tag(BlockTag::Latest)) - .call() - .await - .expect("failed to call contract"); - - contract_erc20 - .transfer( - &recipient, - &U256 { - low: 0x10_u128, - high: 0, - }, - ) - .send() - .await - .unwrap(); -} - -#[tokio::test] -async fn test_verify_execute_session_webauthn_starknet_starknet() { - let signer = Signer::Webauthn( - WebauthnSigner::register( - "cartridge.gg".to_string(), - "username".to_string(), - "challenge".as_bytes(), - SoftPasskeySigner::new("https://cartridge.gg".try_into().unwrap()), - ) - .await - .unwrap(), - ); - - test_verify_execute(signer).await; -} - -#[tokio::test] -async fn test_verify_execute_session_starknet_x3() { - test_verify_execute(Signer::new_starknet_random()).await; -} - -#[tokio::test] -async fn test_verify_execute_session_multiple() { - let signer = Signer::new_starknet_random(); - let runner = KatanaRunner::load(); - let mut controller = runner - .deploy_controller("username".to_owned(), signer, Version::LATEST) - .await; - - let session_account = controller - .create_session( - vec![ - Policy::new(*FEE_TOKEN_ADDRESS, selector!("tdfs")), - Policy::new(*FEE_TOKEN_ADDRESS, selector!("transfds")), - Policy::new(*FEE_TOKEN_ADDRESS, selector!("transfer")), - ], - u64::MAX, - ) - .await - .unwrap(); - - let recipient = ContractAddress(felt!("0x18301129")); - let contract_erc20 = Erc20::new(*FEE_TOKEN_ADDRESS, &session_account); - - contract_erc20 - .balanceOf(&recipient) - .block_id(BlockId::Tag(BlockTag::Latest)) - .call() - .await - .expect("failed to call contract"); - - for _ in 0u32..3 { - let tx = contract_erc20 - .transfer( - &recipient, - &U256 { - low: 0x1_u128, - high: 0, - }, - ) - .send() - .await - .unwrap(); - - TransactionWaiter::new(tx.transaction_hash, runner.client()) - .wait() - .await - .unwrap(); - } -}