stake.cairo

use core::option::OptionTrait;
use snforge_std::cheatcodes::contract_class::{ContractClassTrait, declare};
use array::ArrayTrait;
use core::traits::TryInto;

use governance::traits::{
    IStakingDispatcher, IStakingDispatcherTrait, IERC20Dispatcher, IERC20DispatcherTrait,
    IOptionTokenDispatcher, IOptionTokenDispatcherTrait
};
use governance::staking::Staking::Multiplier;

use snforge_std::{start_prank, start_warp, stop_prank, stop_warp, CheatTarget};
use starknet::{contract_address, ContractAddress, get_caller_address};
use serde::Serde;
use core::debug::PrintTrait;


fn deploy_contract() -> ContractAddress {
    let contract = declare("Staking");
    let mut calldata = ArrayTrait::new();
    let multiplier: Multiplier = Multiplier {
        three_month: 10, six_month: 12, one_year: 15, two_years: 35,
    };
    let owner: ContractAddress = 0x037089ce3ae015971c5caaf54fad708f823768094b362ecc08a4436809fcdebf
        .try_into()
        .unwrap();
    let min_lock_period = 1;
    let treasury: ContractAddress =
        0x037089ce3ae015971c5caaf54fad708f823709094b362ecc08a4436809fcdebf
        .try_into()
        .unwrap();

    owner.serialize(ref calldata);
    min_lock_period.serialize(ref calldata);
    multiplier.serialize(ref calldata);
    treasury.serialize(ref calldata);

    // let contract_address: ContractAddress = contract.precalculate_address(@calldata);
    let deployed_contract = contract.deploy(@calldata).unwrap();
    deployed_contract.print();
    deployed_contract
}

#[test]
#[fork("GOERLI")]
fn test_set_carm_address() {
    let contract_address = deploy_contract();

    let staking_dispatcher = IStakingDispatcher { contract_address };
    let CARM: ContractAddress = 0x062df1f543b13e0da5abd2a90910fa7a2fe44c6a5f70849b298c6b2a219783a1
        .try_into()
        .unwrap();
    let CARM_dispatcher = IERC20Dispatcher { contract_address: CARM };
    let owner: ContractAddress = 0x037089ce3ae015971c5caaf54fad708f823768094b362ecc08a4436809fcdebf
        .try_into()
        .unwrap();

    start_prank(CheatTarget::One(contract_address), owner);
    staking_dispatcher.set_CARM_address(CARM);
    stop_prank(CheatTarget::One(contract_address));
    CARM.print();
}

#[test]
#[fork("GOERLI")]
fn test_set_veCARM_token_address() {
    let contract_address = deploy_contract();

    let staking_dispatcher = IStakingDispatcher { contract_address };
    let veCARM: ContractAddress = 0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7
        .try_into()
        .unwrap();
    let CARM_dispatcher = IERC20Dispatcher { contract_address: veCARM };
    let owner: ContractAddress = 0x037089ce3ae015971c5caaf54fad708f823768094b362ecc08a4436809fcdebf
        .try_into()
        .unwrap();

    start_prank(CheatTarget::One(contract_address), owner);
    staking_dispatcher.set_veCARM_address(veCARM);
    stop_prank(CheatTarget::One(contract_address));

    veCARM.print();
}

#[test]
#[fork("GOERLI")]
fn test_stake() {
    let contract_address = deploy_contract();
    let staking_dispatcher = IStakingDispatcher { contract_address };
    let staker = get_caller_address();
    let CARM: ContractAddress = 0x062df1f543b13e0da5abd2a90910fa7a2fe44c6a5f70849b298c6b2a219783a1
        .try_into()
        .unwrap();
    let owner: ContractAddress = 0x037089ce3ae015971c5caaf54fad708f823768094b362ecc08a4436809fcdebf
        .try_into()
        .unwrap();

    let veCARM: ContractAddress = 0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7
        .try_into()
        .unwrap();
    
    let CARM_owner:ContractAddress = 0x0719947d6faa0cb9a9794d6442947cc30e2aa198e92f3fb30f875354e167f4e7.try_into().unwrap();
    let veCARM_owner: ContractAddress = 0x026fa92011b2f27eca57a44411837e38a4313dfb11d561146039b445815db35b.try_into().unwrap();

    start_prank(CheatTarget::One(contract_address), owner);
    staking_dispatcher.set_stake_start_time(5);
    staking_dispatcher.set_CARM_address(CARM);
    staking_dispatcher.set_veCARM_address(veCARM);
    stop_prank(CheatTarget::One(contract_address));
    

    start_prank(CheatTarget::One(veCARM), veCARM_owner);
    let veCARM_dispatcher = IOptionTokenDispatcher { contract_address: veCARM };
    veCARM_dispatcher.transfer(contract_address, 2000);
    stop_prank(CheatTarget::One(veCARM));

    start_prank(CheatTarget::One(CARM), CARM_owner);
    let CARM_dispatcher = IOptionTokenDispatcher { contract_address: CARM };
    CARM_dispatcher.transfer(staker, 2_000);
    stop_prank(CheatTarget::One(CARM));

    start_warp(CheatTarget::One(contract_address), 100);
    staking_dispatcher.stake(1000, 170);
    assert(staking_dispatcher.get_stake_balance(staker) == 1000, 'incorrect stake balance');
    assert(staking_dispatcher.get_yield(staker) == 1000, 'inaccurate yield');
}

#[test]
#[fork("GOERLI")]
fn test_unstake() {
    let contract_address = deploy_contract();
    let staking_dispatcher = IStakingDispatcher { contract_address };
    let staker = get_caller_address();
    test_stake();

    //warp time, lock_period + timestamp 
    start_warp(CheatTarget::One(contract_address), 180);
    staking_dispatcher.unstake(100);
    assert(staking_dispatcher.get_stake_balance(staker) == 900, 'incorrect stake balance');
}

// #[test]
fn test_increase_lock_period() {
    let contract_address = deploy_contract();
    let staking_dispatcher = IStakingDispatcher { contract_address };
    let staker = get_caller_address();

    staking_dispatcher.increase_lock_period(1717997982);
    assert(staking_dispatcher.get_lock_period(staker) == 1717997982, 'new lock period incorrect');
}