💰 Token Contract

#![no_std]
use soroban_sdk::{
    contract, contractimpl, contracttype,
    Address, Env, String,
    token::{self, Interface as TokenInterface},
};

#[contracttype]
pub enum DataKey {
    Balance(Address),
    Allowance(Address, Address),
    Admin,
    TotalSupply,
}

#[contract]
pub struct GoldToken;

#[contractimpl]
impl GoldToken {
    /// Initialize the Gold Token with admin and supply
    pub fn initialize(
        env: Env,
        admin: Address,
        name: String,
        symbol: String,
        initial_supply: i128,
    ) {
        admin.require_auth();
        env.storage().instance().set(&DataKey::Admin, &admin);
        env.storage().instance().set(&DataKey::TotalSupply, &initial_supply);
        env.storage().persistent().set(
            &DataKey::Balance(admin.clone()), &initial_supply
        );
    }

    /// Transfer tokens between accounts
    pub fn transfer(
        env: Env,
        from: Address,
        to: Address,
        amount: i128,
    ) {
        from.require_auth();
        let from_bal: i128 = env.storage().persistent()
            .get(&DataKey::Balance(from.clone()))
            .unwrap_or(0);
        assert!(from_bal >= amount, "insufficient balance");

        env.storage().persistent().set(
            &DataKey::Balance(from), &(from_bal - amount)
        );
        let to_bal: i128 = env.storage().persistent()
            .get(&DataKey::Balance(to.clone()))
            .unwrap_or(0);
        env.storage().persistent().set(
            &DataKey::Balance(to), &(to_bal + amount)
        );
    }

    /// Mint new tokens (admin only)
    pub fn mint(env: Env, to: Address, amount: i128) {
        let admin: Address = env.storage().instance()
            .get(&DataKey::Admin).unwrap();
        admin.require_auth();
        // ... mint logic
    }

    /// Burn tokens from caller's balance
    pub fn burn(env: Env, from: Address, amount: i128) {
        from.require_auth();
        // ... burn logic
    }

    /// Get balance of an address
    pub fn balance(env: Env, addr: Address) -> i128 {
        env.storage().persistent()
            .get(&DataKey::Balance(addr))
            .unwrap_or(0)
    }
}

#[contracttype]
pub struct GoldStake {
    pub staker: Address,
    pub stake_amount: i128,      // $400 activation
    pub daily_reward: i128,      // $24 per day
    pub duration_days: u32,     // 90 | 180 | 365 days
    pub service_fee: i128,      // $160 platform fee
    pub sponsor: Address,       // direct inviter (Gen 1)
    pub start_time: u64,
    pub claimed_days: u32,
}

// 8-generation binary tree commission rates (in $)
const GEN_COMMISSIONS: [i128; 8] = [
    40_0000000, // Gen 1: $40 (direct inviter)
    24_0000000, // Gen 2: $24
    16_0000000, // Gen 3: $16
    16_0000000, // Gen 4: $16
    16_0000000, // Gen 5: $16
    16_0000000, // Gen 6: $16
    16_0000000, // Gen 7: $16
    16_0000000, // Gen 8: $16
];  // Total referral: $160 | Main wallet: $240 | Grand total: $400

#[contractimpl]
impl GoldToken {

    /// Activate Gold staking — $400 deposit + $160 service fee
    /// $400 split: $240 main wallet + $160 across 8-gen binary tree
    /// duration: 90 (3mo) | 180 (6mo) | 365 (1yr)
    pub fn activate_stake(
        env: Env, staker: Address, sponsor: Address,
        duration: u32,
    ) {
        staker.require_auth();

        // Valid periods: 90 (3mo), 180 (6mo), 365 (1yr)
        assert!(duration == 90 || duration == 180 || duration == 365);

        let token = get_payment_token(&env);
        let tok = token::Client::new(&env, &token);
        let activation = 400_0000000; // $400
        let fee = 160_0000000;        // $160 service fee

        // Transfer $400 + $160 fee from user to contract
        tok.transfer(&staker, &env.current_contract_address(),
                     &(activation + fee));

        // ── Distribute $400 activation across binary tree ──
        let main_wallet = get_main_wallet(&env);
        let mut remaining = activation; // $400
        let mut current = sponsor.clone();

        for gen in 0..8 {
            let commission = GEN_COMMISSIONS[gen];
            if let Some(upline) = get_sponsor(&env, ¤t) {
                tok.transfer(
                    &env.current_contract_address(),
                    ¤t, &commission,
                );
                remaining -= commission;
                current = upline;
            } else {
                // No upline — remaining goes to main wallet
                break;
            }
        }

        // Send remainder ($240 or more) to main wallet
        tok.transfer(
            &env.current_contract_address(),
            &main_wallet, &remaining,
        );

        let stake = GoldStake {
            staker: staker.clone(),
            stake_amount: activation,
            daily_reward: 24_0000000,  // $24/day
            duration_days: duration,
            service_fee: fee,
            sponsor: sponsor.clone(),
            start_time: env.ledger().timestamp(),
            claimed_days: 0,
        };
        env.storage().persistent().set(&staker, &stake);
    }

    /// Claim accrued daily rewards
    pub fn claim_rewards(env: Env, staker: Address) -> i128 {
        staker.require_auth();
        let mut stake: GoldStake = env.storage().persistent().get(&staker).unwrap();

        let elapsed = (env.ledger().timestamp() - stake.start_time) / 86400;
        let claimable = elapsed.min(stake.duration_days as u64) as u32
                        - stake.claimed_days;

        let payout = (claimable as i128) * stake.daily_reward;
        stake.claimed_days += claimable;
        env.storage().persistent().set(&staker, &stake);

        // Transfer rewards to staker
        token::Client::new(&env, &get_payment_token(&env))
            .transfer(&env.current_contract_address(), &staker, &payout);
        payout  // 90d→$2,160 | 180d→$4,320 | 365d→$8,760
    }
}

#[test]
fn test_transfer() {
    let env = Env::default();
    env.mock_all_auths();
    let admin = Address::generate(&env);
    let user  = Address::generate(&env);
    let client = GoldTokenClient::new(&env, &env.register_contract(None, GoldToken));

    client.initialize(&admin, &String::from_str(&env, "Gold"),
        &String::from_str(&env, "GOLD"), &1000_0000000);

    client.transfer(&admin, &user, &100_0000000);
    assert_eq!(client.balance(&user), 100_0000000);
    assert_eq!(client.balance(&admin), 900_0000000);
}