cougr-core 1.0.0

Cougr - A Soroban-compatible ECS framework for on-chain gaming on Stellar
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use soroban_sdk::{Address, Env};

use super::error::AccountError;
use super::intent::{AuthMethod, AuthResult, SignedIntent};
use super::traits::{CougrAccount, IntentAccount};
use super::types::{AccountCapabilities, GameAction};

/// A mock account for testing that always authorizes actions.
///
/// Capabilities are configurable at construction time.
pub struct MockAccount {
    address: Address,
    capabilities: AccountCapabilities,
}

impl MockAccount {
    /// Create a mock account with default (full) capabilities.
    pub fn new(env: &Env) -> Self {
        use soroban_sdk::testutils::Address as _;
        Self {
            address: Address::generate(env),
            capabilities: AccountCapabilities {
                can_batch: true,
                has_session_keys: true,
                has_social_recovery: true,
                has_passkey_auth: true,
            },
        }
    }

    /// Create a mock account with custom capabilities.
    pub fn with_capabilities(env: &Env, capabilities: AccountCapabilities) -> Self {
        use soroban_sdk::testutils::Address as _;
        Self {
            address: Address::generate(env),
            capabilities,
        }
    }
}

impl CougrAccount for MockAccount {
    fn address(&self) -> &Address {
        &self.address
    }

    fn capabilities(&self) -> AccountCapabilities {
        self.capabilities.clone()
    }

    fn authorize(&self, _env: &Env, _action: &GameAction) -> Result<(), AccountError> {
        // Mock always succeeds
        Ok(())
    }
}

impl IntentAccount for MockAccount {
    fn authorize_intent(
        &mut self,
        _env: &Env,
        intent: &SignedIntent,
    ) -> Result<AuthResult, AccountError> {
        Ok(AuthResult {
            method: match intent.signer.kind {
                super::intent::IntentSigner::Direct => AuthMethod::Direct,
                super::intent::IntentSigner::Session => AuthMethod::Session,
                super::intent::IntentSigner::Passkey => AuthMethod::Passkey,
            },
            nonce_consumed: intent.nonce,
            session_key_id: intent.signer.session_key_id.clone(),
            remaining_operations: 0,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use soroban_sdk::{symbol_short, Bytes, Env};

    #[test]
    fn test_mock_account_creation() {
        let env = Env::default();
        let account = MockAccount::new(&env);
        let caps = account.capabilities();
        assert!(caps.can_batch);
        assert!(caps.has_session_keys);
    }

    #[test]
    fn test_mock_account_custom_capabilities() {
        let env = Env::default();
        let caps = AccountCapabilities {
            can_batch: false,
            has_session_keys: false,
            has_social_recovery: true,
            has_passkey_auth: false,
        };
        let account = MockAccount::with_capabilities(&env, caps);
        let result = account.capabilities();
        assert!(!result.can_batch);
        assert!(!result.has_session_keys);
        assert!(result.has_social_recovery);
    }

    #[test]
    fn test_mock_account_always_authorizes() {
        let env = Env::default();
        let account = MockAccount::new(&env);
        let action = GameAction {
            system_name: symbol_short!("attack"),
            data: Bytes::new(&env),
        };
        assert!(account.authorize(&env, &action).is_ok());
    }
}