staking_contract - [mainnet]

public fun stake_pool_address(staker: address, operator: address): address acquires Store {
    assert_staking_contract_exists(staker, operator);
    let staking_contracts = &borrow_global<Store>(staker).staking_contracts;
    simple_map::borrow(staking_contracts, &operator).pool_address
}

public fun last_recorded_principal(staker: address, operator: address): u64 acquires Store {
    assert_staking_contract_exists(staker, operator);
    let staking_contracts = &borrow_global<Store>(staker).staking_contracts;
    simple_map::borrow(staking_contracts, &operator).principal
}

public fun commission_percentage(staker: address, operator: address): u64 acquires Store {
    assert_staking_contract_exists(staker, operator);
    let staking_contracts = &borrow_global<Store>(staker).staking_contracts;
    simple_map::borrow(staking_contracts, &operator).commission_percentage
}

public fun staking_contract_amounts(staker: address, operator: address): (u64, u64, u64) acquires Store {
    assert_staking_contract_exists(staker, operator);
    let staking_contracts = &borrow_global<Store>(staker).staking_contracts;
    let staking_contract = simple_map::borrow(staking_contracts, &operator);
    get_staking_contract_amounts_internal(staking_contract)
}

public fun pending_distribution_counts(staker: address, operator: address): u64 acquires Store {
    assert_staking_contract_exists(staker, operator);
    let staking_contracts = &borrow_global<Store>(staker).staking_contracts;
    pool_u64::shareholders_count(&simple_map::borrow(staking_contracts, &operator).distribution_pool)
}

public fun staking_contract_exists(staker: address, operator: address): bool acquires Store {
    if (!exists<Store>(staker)) {
        return false
    };

    let store = borrow_global<Store>(staker);
    simple_map::contains_key(&store.staking_contracts, &operator)
}

public fun beneficiary_for_operator(operator: address): address acquires BeneficiaryForOperator {
    if (exists<BeneficiaryForOperator>(operator)) {
        return borrow_global<BeneficiaryForOperator>(operator).beneficiary_for_operator
    } else {
        operator
    }
}

public fun get_expected_stake_pool_address(
    staker: address,
    operator: address,
    contract_creation_seed: vector<u8>,
): address {
    let seed = create_resource_account_seed(staker, operator, contract_creation_seed);
    account::create_resource_address(&staker, seed)
}

public entry fun create_staking_contract(
    staker: &signer,
    operator: address,
    voter: address,
    amount: u64,
    commission_percentage: u64,
    // Optional seed used when creating the staking contract account.
    contract_creation_seed: vector<u8>,
) acquires Store {
    let staked_coins = coin::withdraw<AptosCoin>(staker, amount);
    create_staking_contract_with_coins(
        staker, operator, voter, staked_coins, commission_percentage, contract_creation_seed);
}

public fun create_staking_contract_with_coins(
    staker: &signer,
    operator: address,
    voter: address,
    coins: Coin<AptosCoin>,
    commission_percentage: u64,
    // Optional seed used when creating the staking contract account.
    contract_creation_seed: vector<u8>,
): address acquires Store {
    assert!(
        commission_percentage >= 0 && commission_percentage <= 100,
        error::invalid_argument(EINVALID_COMMISSION_PERCENTAGE),
    );
    // The amount should be at least the min_stake_required, so the stake pool will be eligible to join the
    // validator set.
    let (min_stake_required, _) = staking_config::get_required_stake(&staking_config::get());
    let principal = coin::value(&coins);
    assert!(principal >= min_stake_required, error::invalid_argument(EINSUFFICIENT_STAKE_AMOUNT));

    // Initialize Store resource if this is the first time the staker has delegated to anyone.
    let staker_address = signer::address_of(staker);
    if (!exists<Store>(staker_address)) {
        move_to(staker, new_staking_contracts_holder(staker));
    };

    // Cannot create the staking contract if it already exists.
    let store = borrow_global_mut<Store>(staker_address);
    let staking_contracts = &mut store.staking_contracts;
    assert!(
        !simple_map::contains_key(staking_contracts, &operator),
        error::already_exists(ESTAKING_CONTRACT_ALREADY_EXISTS)
    );

    // Initialize the stake pool in a new resource account. This allows the same staker to contract with multiple
    // different operators.
    let (stake_pool_signer, stake_pool_signer_cap, owner_cap) =
        create_stake_pool(staker, operator, voter, contract_creation_seed);

    // Add the stake to the stake pool.
    stake::add_stake_with_cap(&owner_cap, coins);

    // Create the contract record.
    let pool_address = signer::address_of(&stake_pool_signer);
    simple_map::add(staking_contracts, operator, StakingContract {
        principal,
        pool_address,
        owner_cap,
        commission_percentage,
        // Make sure we don't have too many pending recipients in the distribution pool.
        // Otherwise, a griefing attack is possible where the staker can keep switching operators and create too
        // many pending distributions. This can lead to out-of-gas failure whenever distribute() is called.
        distribution_pool: pool_u64::create(MAXIMUM_PENDING_DISTRIBUTIONS),
        signer_cap: stake_pool_signer_cap,
    });

    if (std::features::module_event_migration_enabled()) {
        emit(CreateStakingContract { operator, voter, pool_address, principal, commission_percentage });
    } else {
        emit_event(
            &mut store.create_staking_contract_events,
            CreateStakingContractEvent { operator, voter, pool_address, principal, commission_percentage },
        );
    };
    pool_address
}

public entry fun add_stake(staker: &signer, operator: address, amount: u64) acquires Store {
    let staker_address = signer::address_of(staker);
    assert_staking_contract_exists(staker_address, operator);

    let store = borrow_global_mut<Store>(staker_address);
    let staking_contract = simple_map::borrow_mut(&mut store.staking_contracts, &operator);

    // Add the stake to the stake pool.
    let staked_coins = coin::withdraw<AptosCoin>(staker, amount);
    stake::add_stake_with_cap(&staking_contract.owner_cap, staked_coins);

    staking_contract.principal = staking_contract.principal + amount;
    let pool_address = staking_contract.pool_address;
    if (std::features::module_event_migration_enabled()) {
        emit(AddStake { operator, pool_address, amount });
    } else {
        emit_event(
            &mut store.add_stake_events,
            AddStakeEvent { operator, pool_address, amount },
        );
    };
}

public entry fun update_voter(staker: &signer, operator: address, new_voter: address) acquires Store {
    let staker_address = signer::address_of(staker);
    assert_staking_contract_exists(staker_address, operator);

    let store = borrow_global_mut<Store>(staker_address);
    let staking_contract = simple_map::borrow_mut(&mut store.staking_contracts, &operator);
    let pool_address = staking_contract.pool_address;
    let old_voter = stake::get_delegated_voter(pool_address);
    stake::set_delegated_voter_with_cap(&staking_contract.owner_cap, new_voter);

    if (std::features::module_event_migration_enabled()) {
        emit(UpdateVoter { operator, pool_address, old_voter, new_voter });
    } else {
        emit_event(
            &mut store.update_voter_events,
            UpdateVoterEvent { operator, pool_address, old_voter, new_voter },
        );
    };
}

public entry fun reset_lockup(staker: &signer, operator: address) acquires Store {
    let staker_address = signer::address_of(staker);
    assert_staking_contract_exists(staker_address, operator);

    let store = borrow_global_mut<Store>(staker_address);
    let staking_contract = simple_map::borrow_mut(&mut store.staking_contracts, &operator);
    let pool_address = staking_contract.pool_address;
    stake::increase_lockup_with_cap(&staking_contract.owner_cap);

    if (std::features::module_event_migration_enabled()) {
        emit(ResetLockup { operator, pool_address });
    } else {
        emit_event(&mut store.reset_lockup_events, ResetLockupEvent { operator, pool_address });
    };
}

public entry fun update_commision(
    staker: &signer,
    operator: address,
    new_commission_percentage: u64
) acquires Store, BeneficiaryForOperator, StakingGroupUpdateCommissionEvent {
    assert!(
        new_commission_percentage >= 0 && new_commission_percentage <= 100,
        error::invalid_argument(EINVALID_COMMISSION_PERCENTAGE),
    );

    let staker_address = signer::address_of(staker);
    assert!(exists<Store>(staker_address), error::not_found(ENO_STAKING_CONTRACT_FOUND_FOR_STAKER));

    let store = borrow_global_mut<Store>(staker_address);
    let staking_contract = simple_map::borrow_mut(&mut store.staking_contracts, &operator);
    distribute_internal(staker_address, operator, staking_contract, &mut store.distribute_events);
    request_commission_internal(
        operator,
        staking_contract,
        &mut store.add_distribution_events,
        &mut store.request_commission_events,
    );
    let old_commission_percentage = staking_contract.commission_percentage;
    staking_contract.commission_percentage = new_commission_percentage;
    if (!exists<StakingGroupUpdateCommissionEvent>(staker_address)) {
        move_to(
            staker,
            StakingGroupUpdateCommissionEvent {
                update_commission_events: account::new_event_handle<UpdateCommissionEvent>(
                    staker
                )
            }
        )
    };
    if (std::features::module_event_migration_enabled()) {
        emit(
            UpdateCommission { staker: staker_address, operator, old_commission_percentage, new_commission_percentage }
        );
    } else {
        emit_event(
            &mut borrow_global_mut<StakingGroupUpdateCommissionEvent>(staker_address).update_commission_events,
            UpdateCommissionEvent { staker: staker_address, operator, old_commission_percentage, new_commission_percentage }
        );
    };
}

public entry fun request_commission(
    account: &signer,
    staker: address,
    operator: address
) acquires Store, BeneficiaryForOperator {
    let account_addr = signer::address_of(account);
    assert!(
        account_addr == staker || account_addr == operator || account_addr == beneficiary_for_operator(operator),
        error::unauthenticated(ENOT_STAKER_OR_OPERATOR_OR_BENEFICIARY)
    );
    assert_staking_contract_exists(staker, operator);

    let store = borrow_global_mut<Store>(staker);
    let staking_contract = simple_map::borrow_mut(&mut store.staking_contracts, &operator);
    // Short-circuit if zero commission.
    if (staking_contract.commission_percentage == 0) {
        return
    };

    // Force distribution of any already inactive stake.
    distribute_internal(staker, operator, staking_contract, &mut store.distribute_events);

    request_commission_internal(
        operator,
        staking_contract,
        &mut store.add_distribution_events,
        &mut store.request_commission_events,
    );
}

fun request_commission_internal(
    operator: address,
    staking_contract: &mut StakingContract,
    add_distribution_events: &mut EventHandle<AddDistributionEvent>,
    request_commission_events: &mut EventHandle<RequestCommissionEvent>,
): u64 {
    // Unlock just the commission portion from the stake pool.
    let (total_active_stake, accumulated_rewards, commission_amount) =
        get_staking_contract_amounts_internal(staking_contract);
    staking_contract.principal = total_active_stake - commission_amount;

    // Short-circuit if there's no commission to pay.
    if (commission_amount == 0) {
        return 0
    };

    // Add a distribution for the operator.
    add_distribution(operator, staking_contract, operator, commission_amount, add_distribution_events);

    // Request to unlock the commission from the stake pool.
    // This won't become fully unlocked until the stake pool's lockup expires.
    stake::unlock_with_cap(commission_amount, &staking_contract.owner_cap);

    let pool_address = staking_contract.pool_address;
    if (std::features::module_event_migration_enabled()) {
        emit(RequestCommission { operator, pool_address, accumulated_rewards, commission_amount });
    } else {
        emit_event(
            request_commission_events,
            RequestCommissionEvent { operator, pool_address, accumulated_rewards, commission_amount },
        );
    };

    commission_amount
}

public entry fun unlock_stake(
    staker: &signer,
    operator: address,
    amount: u64
) acquires Store, BeneficiaryForOperator {
    // Short-circuit if amount is 0.
    if (amount == 0) return;

    let staker_address = signer::address_of(staker);
    assert_staking_contract_exists(staker_address, operator);

    let store = borrow_global_mut<Store>(staker_address);
    let staking_contract = simple_map::borrow_mut(&mut store.staking_contracts, &operator);

    // Force distribution of any already inactive stake.
    distribute_internal(staker_address, operator, staking_contract, &mut store.distribute_events);

    // For simplicity, we request commission to be paid out first. This avoids having to ensure to staker doesn't
    // withdraw into the commission portion.
    let commission_paid = request_commission_internal(
        operator,
        staking_contract,
        &mut store.add_distribution_events,
        &mut store.request_commission_events,
    );

    // If there's less active stake remaining than the amount requested (potentially due to commission),
    // only withdraw up to the active amount.
    let (active, _, _, _) = stake::get_stake(staking_contract.pool_address);
    if (active < amount) {
        amount = active;
    };
    staking_contract.principal = staking_contract.principal - amount;

    // Record a distribution for the staker.
    add_distribution(operator, staking_contract, staker_address, amount, &mut store.add_distribution_events);

    // Request to unlock the distribution amount from the stake pool.
    // This won't become fully unlocked until the stake pool's lockup expires.
    stake::unlock_with_cap(amount, &staking_contract.owner_cap);

    let pool_address = staking_contract.pool_address;
    if (std::features::module_event_migration_enabled()) {
        emit(UnlockStake { pool_address, operator, amount, commission_paid });
    } else {
        emit_event(
            &mut store.unlock_stake_events,
            UnlockStakeEvent { pool_address, operator, amount, commission_paid },
        );
    };
}

public entry fun unlock_rewards(staker: &signer, operator: address) acquires Store, BeneficiaryForOperator {
    let staker_address = signer::address_of(staker);
    assert_staking_contract_exists(staker_address, operator);

    // Calculate how much rewards belongs to the staker after commission is paid.
    let (_, accumulated_rewards, unpaid_commission) = staking_contract_amounts(staker_address, operator);
    let staker_rewards = accumulated_rewards - unpaid_commission;
    unlock_stake(staker, operator, staker_rewards);
}

public entry fun switch_operator_with_same_commission(
    staker: &signer,
    old_operator: address,
    new_operator: address,
) acquires Store, BeneficiaryForOperator {
    let staker_address = signer::address_of(staker);
    assert_staking_contract_exists(staker_address, old_operator);

    let commission_percentage = commission_percentage(staker_address, old_operator);
    switch_operator(staker, old_operator, new_operator, commission_percentage);
}

public entry fun switch_operator(
    staker: &signer,
    old_operator: address,
    new_operator: address,
    new_commission_percentage: u64,
) acquires Store, BeneficiaryForOperator {
    let staker_address = signer::address_of(staker);
    assert_staking_contract_exists(staker_address, old_operator);

    // Merging two existing staking contracts is too complex as we'd need to merge two separate stake pools.
    let store = borrow_global_mut<Store>(staker_address);
    let staking_contracts = &mut store.staking_contracts;
    assert!(
        !simple_map::contains_key(staking_contracts, &new_operator),
        error::invalid_state(ECANT_MERGE_STAKING_CONTRACTS),
    );

    let (_, staking_contract) = simple_map::remove(staking_contracts, &old_operator);
    // Force distribution of any already inactive stake.
    distribute_internal(staker_address, old_operator, &mut staking_contract, &mut store.distribute_events);

    // For simplicity, we request commission to be paid out first. This avoids having to ensure to staker doesn't
    // withdraw into the commission portion.
    request_commission_internal(
        old_operator,
        &mut staking_contract,
        &mut store.add_distribution_events,
        &mut store.request_commission_events,
    );

    // Update the staking contract's commission rate and stake pool's operator.
    stake::set_operator_with_cap(&staking_contract.owner_cap, new_operator);
    staking_contract.commission_percentage = new_commission_percentage;

    let pool_address = staking_contract.pool_address;
    simple_map::add(staking_contracts, new_operator, staking_contract);
    if (std::features::module_event_migration_enabled()) {
        emit(SwitchOperator { pool_address, old_operator, new_operator });
    } else {
        emit_event(
            &mut store.switch_operator_events,
            SwitchOperatorEvent { pool_address, old_operator, new_operator }
        );
    };
}

public entry fun set_beneficiary_for_operator(
    operator: &signer,
    new_beneficiary: address
) acquires BeneficiaryForOperator {
    assert!(features::operator_beneficiary_change_enabled(), std::error::invalid_state(
        EOPERATOR_BENEFICIARY_CHANGE_NOT_SUPPORTED
    ));
    // The beneficiay address of an operator is stored under the operator's address.
    // So, the operator does not need to be validated with respect to a staking pool.
    let operator_addr = signer::address_of(operator);
    let old_beneficiary = beneficiary_for_operator(operator_addr);
    if (exists<BeneficiaryForOperator>(operator_addr)) {
        borrow_global_mut<BeneficiaryForOperator>(operator_addr).beneficiary_for_operator = new_beneficiary;
    } else {
        move_to(operator, BeneficiaryForOperator { beneficiary_for_operator: new_beneficiary });
    };

    emit(SetBeneficiaryForOperator {
        operator: operator_addr,
        old_beneficiary,
        new_beneficiary,
    });
}

public entry fun distribute(staker: address, operator: address) acquires Store, BeneficiaryForOperator {
    assert_staking_contract_exists(staker, operator);
    let store = borrow_global_mut<Store>(staker);
    let staking_contract = simple_map::borrow_mut(&mut store.staking_contracts, &operator);
    distribute_internal(staker, operator, staking_contract, &mut store.distribute_events);
}

fun distribute_internal(
    staker: address,
    operator: address,
    staking_contract: &mut StakingContract,
    distribute_events: &mut EventHandle<DistributeEvent>,
) acquires BeneficiaryForOperator {
    let pool_address = staking_contract.pool_address;
    let (_, inactive, _, pending_inactive) = stake::get_stake(pool_address);
    let total_potential_withdrawable = inactive + pending_inactive;
    let coins = stake::withdraw_with_cap(&staking_contract.owner_cap, total_potential_withdrawable);
    let distribution_amount = coin::value(&coins);
    if (distribution_amount == 0) {
        coin::destroy_zero(coins);
        return
    };

    let distribution_pool = &mut staking_contract.distribution_pool;
    update_distribution_pool(
        distribution_pool, distribution_amount, operator, staking_contract.commission_percentage);

    // Buy all recipients out of the distribution pool.
    while (pool_u64::shareholders_count(distribution_pool) > 0) {
        let recipients = pool_u64::shareholders(distribution_pool);
        let recipient = *vector::borrow(&recipients, 0);
        let current_shares = pool_u64::shares(distribution_pool, recipient);
        let amount_to_distribute = pool_u64::redeem_shares(distribution_pool, recipient, current_shares);
        // If the recipient is the operator, send the commission to the beneficiary instead.
        if (recipient == operator) {
            recipient = beneficiary_for_operator(operator);
        };
        aptos_account::deposit_coins(recipient, coin::extract(&mut coins, amount_to_distribute));

        if (std::features::module_event_migration_enabled()) {
            emit(Distribute { operator, pool_address, recipient, amount: amount_to_distribute });
        } else {
            emit_event(
                distribute_events,
                DistributeEvent { operator, pool_address, recipient, amount: amount_to_distribute }
            );
        };
    };

    // In case there's any dust left, send them all to the staker.
    if (coin::value(&coins) > 0) {
        aptos_account::deposit_coins(staker, coins);
        pool_u64::update_total_coins(distribution_pool, 0);
    } else {
        coin::destroy_zero(coins);
    }
}

fun assert_staking_contract_exists(staker: address, operator: address) acquires Store {
    assert!(exists<Store>(staker), error::not_found(ENO_STAKING_CONTRACT_FOUND_FOR_STAKER));
    let staking_contracts = &borrow_global<Store>(staker).staking_contracts;
    assert!(
        simple_map::contains_key(staking_contracts, &operator),
        error::not_found(ENO_STAKING_CONTRACT_FOUND_FOR_OPERATOR),
    );
}

fun add_distribution(
    operator: address,
    staking_contract: &mut StakingContract,
    recipient: address,
    coins_amount: u64,
    add_distribution_events: &mut EventHandle<AddDistributionEvent>
) {
    let distribution_pool = &mut staking_contract.distribution_pool;
    let (_, _, _, total_distribution_amount) = stake::get_stake(staking_contract.pool_address);
    update_distribution_pool(
        distribution_pool, total_distribution_amount, operator, staking_contract.commission_percentage);

    pool_u64::buy_in(distribution_pool, recipient, coins_amount);
    let pool_address = staking_contract.pool_address;
    if (std::features::module_event_migration_enabled()) {
        emit(AddDistribution { operator, pool_address, amount: coins_amount });
    } else {
        emit_event(
            add_distribution_events,
            AddDistributionEvent { operator, pool_address, amount: coins_amount }
        );
    };
}

fun get_staking_contract_amounts_internal(staking_contract: &StakingContract): (u64, u64, u64) {
    // Pending_inactive is not included in the calculation because pending_inactive can only come from:
    // 1. Outgoing commissions. This means commission has already been extracted.
    // 2. Stake withdrawals from stakers. This also means commission has already been extracted as
    // request_commission_internal is called in unlock_stake
    let (active, _, pending_active, _) = stake::get_stake(staking_contract.pool_address);
    let total_active_stake = active + pending_active;
    let accumulated_rewards = total_active_stake - staking_contract.principal;
    let commission_amount = accumulated_rewards * staking_contract.commission_percentage / 100;

    (total_active_stake, accumulated_rewards, commission_amount)
}

fun create_stake_pool(
    staker: &signer,
    operator: address,
    voter: address,
    contract_creation_seed: vector<u8>,
): (signer, SignerCapability, OwnerCapability) {
    // Generate a seed that will be used to create the resource account that hosts the staking contract.
    let seed = create_resource_account_seed(
        signer::address_of(staker), operator, contract_creation_seed);

    let (stake_pool_signer, stake_pool_signer_cap) = account::create_resource_account(staker, seed);
    stake::initialize_stake_owner(&stake_pool_signer, 0, operator, voter);

    // Extract owner_cap from the StakePool, so we have control over it in the staking_contracts flow.
    // This is stored as part of the staking_contract. Thus, the staker would not have direct control over it without
    // going through well-defined functions in this module.
    let owner_cap = stake::extract_owner_cap(&stake_pool_signer);

    (stake_pool_signer, stake_pool_signer_cap, owner_cap)
}

fun update_distribution_pool(
    distribution_pool: &mut Pool,
    updated_total_coins: u64,
    operator: address,
    commission_percentage: u64,
) {
    // Short-circuit and do nothing if the pool's total value has not changed.
    if (pool_u64::total_coins(distribution_pool) == updated_total_coins) {
        return
    };

    // Charge all stakeholders (except for the operator themselves) commission on any rewards earnt relatively to the
    // previous value of the distribution pool.
    let shareholders = &pool_u64::shareholders(distribution_pool);
    vector::for_each_ref(shareholders, |shareholder| {
        let shareholder: address = *shareholder;
        if (shareholder != operator) {
            let shares = pool_u64::shares(distribution_pool, shareholder);
            let previous_worth = pool_u64::balance(distribution_pool, shareholder);
            let current_worth = pool_u64::shares_to_amount_with_total_coins(
                distribution_pool, shares, updated_total_coins);
            let unpaid_commission = (current_worth - previous_worth) * commission_percentage / 100;
            // Transfer shares from current shareholder to the operator as payment.
            // The value of the shares should use the updated pool's total value.
            let shares_to_transfer = pool_u64::amount_to_shares_with_total_coins(
                distribution_pool, unpaid_commission, updated_total_coins);
            pool_u64::transfer_shares(distribution_pool, shareholder, operator, shares_to_transfer);
        };
    });

    pool_u64::update_total_coins(distribution_pool, updated_total_coins);
}

fun create_resource_account_seed(
    staker: address,
    operator: address,
    contract_creation_seed: vector<u8>,
): vector<u8> {
    let seed = bcs::to_bytes(&staker);
    vector::append(&mut seed, bcs::to_bytes(&operator));
    // Include a salt to avoid conflicts with any other modules out there that might also generate
    // deterministic resource accounts for the same staker + operator addresses.
    vector::append(&mut seed, SALT);
    // Add an extra salt given by the staker in case an account with the same address has already been created.
    vector::append(&mut seed, contract_creation_seed);
    seed
}

fun new_staking_contracts_holder(staker: &signer): Store {
    Store {
        staking_contracts: simple_map::create<address, StakingContract>(),
        // Events.
        create_staking_contract_events: account::new_event_handle<CreateStakingContractEvent>(staker),
        update_voter_events: account::new_event_handle<UpdateVoterEvent>(staker),
        reset_lockup_events: account::new_event_handle<ResetLockupEvent>(staker),
        add_stake_events: account::new_event_handle<AddStakeEvent>(staker),
        request_commission_events: account::new_event_handle<RequestCommissionEvent>(staker),
        unlock_stake_events: account::new_event_handle<UnlockStakeEvent>(staker),
        switch_operator_events: account::new_event_handle<SwitchOperatorEvent>(staker),
        add_distribution_events: account::new_event_handle<AddDistributionEvent>(staker),
        distribute_events: account::new_event_handle<DistributeEvent>(staker),
    }
}