StellarSplit/contracts/staking/src/test.rs at feat/cleaning · ghzhost/StellarSplit · GitHub

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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#![cfg(test)]

use crate::{StakingContract, StakingContractClient};
use soroban_sdk::{testutils::{Address as _, Ledger}, Address, Env};
use soroban_sdk::token::{Client as TokenClient, StellarAssetClient as TokenAdminClient};

#[test]
fn test_staking_success() {
    let env = Env::default();
    env.mock_all_auths();

    let admin = Address::generate(&env);
    let staker = Address::generate(&env);

    // Deploy token
    let token_admin = Address::generate(&env);
    let token_id = env.register_stellar_asset_contract_v2(token_admin.clone());
    let token_address = token_id.address();
    let token_client = TokenClient::new(&env, &token_address);
    let token_admin_client = TokenAdminClient::new(&env, &token_address);

    // Deploy Staking Contract
    let staking_id = env.register_contract(None, StakingContract);
    let staking_client = StakingContractClient::new(&env, &staking_id);
    staking_client.initialize(&admin, &token_address);

    // Mint tokens
    token_admin_client.mint(&staker, &1000);

    // Stake
    staking_client.stake(&staker, &500);
    assert_eq!(token_client.balance(&staker), 500);
    assert_eq!(token_client.balance(&staking_id), 500);
    assert_eq!(staking_client.get_voting_power(&staker), 500);

    // Unstake
    staking_client.unstake(&staker, &200);
    assert_eq!(staking_client.get_voting_power(&staker), 300);

    // Try withdraw (should fail - cooldown)
    let result = staking_client.try_withdraw(&staker);
    assert!(result.is_err());

    // Jump 7 days
    env.ledger().set_timestamp(604801);
    staking_client.withdraw(&staker);
    assert_eq!(token_client.balance(&staker), 700);
}

#[test]
fn test_staking_rewards() {
    let env = Env::default();
    env.mock_all_auths();

    let admin = Address::generate(&env);
    let staker1 = Address::generate(&env);
    let staker2 = Address::generate(&env);

    // Deploy token
    let token_admin = Address::generate(&env);
    let token_id = env.register_stellar_asset_contract_v2(token_admin.clone());
    let token_address = token_id.address();
    let token_admin_client = TokenAdminClient::new(&env, &token_address);

    // Deploy Staking Contract
    let staking_id = env.register_contract(None, StakingContract);
    let staking_client = StakingContractClient::new(&env, &staking_id);
    staking_client.initialize(&admin, &token_address);

    // Mint tokens & Stake
    token_admin_client.mint(&staker1, &1000);
    token_admin_client.mint(&staker2, &1000);
    staking_client.stake(&staker1, &600);
    staking_client.stake(&staker2, &400);

    // Admin deposits rewards
    token_admin_client.mint(&admin, &1000);
    staking_client.deposit_rewards(&admin, &100); // 60 for staker1, 40 for staker2

    // Claim rewards
    let claimed1 = staking_client.claim_staking_rewards(&staker1);
    let claimed2 = staking_client.claim_staking_rewards(&staker2);

    assert_eq!(claimed1, 60);
    assert_eq!(claimed2, 40);
}

#[test]
fn test_delegation() {
    let env = Env::default();
    env.mock_all_auths();

    let admin = Address::generate(&env);
    let staker1 = Address::generate(&env);
    let staker2 = Address::generate(&env);

    // Deploy token
    let token_admin = Address::generate(&env);
    let token_id = env.register_stellar_asset_contract_v2(token_admin.clone());
    let token_address = token_id.address();
    let token_admin_client = TokenAdminClient::new(&env, &token_address);

    // Deploy Staking Contract
    let staking_id = env.register_contract(None, StakingContract);
    let staking_client = StakingContractClient::new(&env, &staking_id);
    staking_client.initialize(&admin, &token_address);

    // Stake
    token_admin_client.mint(&staker1, &1000);
    token_admin_client.mint(&staker2, &1000);
    staking_client.stake(&staker1, &600);
    staking_client.stake(&staker2, &400);

    assert_eq!(staking_client.get_voting_power(&staker1), 600);
    assert_eq!(staking_client.get_voting_power(&staker2), 400);

    // Delegate staker1 -> staker2
    staking_client.delegate_voting_power(&staker1, &Some(staker2.clone()));

    assert_eq!(staking_client.get_voting_power(&staker1), 600); // Still has own voting power?
    // Wait, usually delegation means giving power to someone else.
    // The requirement says "Delegate voting power".
    // My implementation: get_voting_power = staked + delegated_to_me.
    // So staker2 should have 400 + 600 = 1000.
    assert_eq!(staking_client.get_voting_power(&staker2), 1000);

    // Unstake staker1 partial
    staking_client.unstake(&staker1, &100);
    assert_eq!(staking_client.get_voting_power(&staker2), 900);

    // Remove delegation
    staking_client.delegate_voting_power(&staker1, &None);
    assert_eq!(staking_client.get_voting_power(&staker2), 400);
}