delegation_pool - [mainnet]

public fun owner_cap_exists(addr: address): bool {
    exists<DelegationPoolOwnership>(addr)
}

public fun get_owned_pool_address(owner: address): address acquires DelegationPoolOwnership {
    assert_owner_cap_exists(owner);
    borrow_global<DelegationPoolOwnership>(owner).pool_address
}

public fun delegation_pool_exists(addr: address): bool {
    exists<DelegationPool>(addr)
}

public fun partial_governance_voting_enabled(pool_address: address): bool {
    exists<GovernanceRecords>(pool_address) && stake::get_delegated_voter(pool_address) == pool_address
}

public fun observed_lockup_cycle(pool_address: address): u64 acquires DelegationPool {
    assert_delegation_pool_exists(pool_address);
    borrow_global<DelegationPool>(pool_address).observed_lockup_cycle.index
}

public fun is_next_commission_percentage_effective(pool_address: address): bool acquires NextCommissionPercentage {
    exists<NextCommissionPercentage>(pool_address) &&
        timestamp::now_seconds() >= borrow_global<NextCommissionPercentage>(pool_address).effective_after_secs
}

public fun operator_commission_percentage(
    pool_address: address
): u64 acquires DelegationPool, NextCommissionPercentage {
    assert_delegation_pool_exists(pool_address);
    if (is_next_commission_percentage_effective(pool_address)) {
        operator_commission_percentage_next_lockup_cycle(pool_address)
    } else {
        borrow_global<DelegationPool>(pool_address).operator_commission_percentage
    }
}

public fun operator_commission_percentage_next_lockup_cycle(
    pool_address: address
): u64 acquires DelegationPool, NextCommissionPercentage {
    assert_delegation_pool_exists(pool_address);
    if (exists<NextCommissionPercentage>(pool_address)) {
        borrow_global<NextCommissionPercentage>(pool_address).commission_percentage_next_lockup_cycle
    } else {
        borrow_global<DelegationPool>(pool_address).operator_commission_percentage
    }
}

public fun shareholders_count_active_pool(pool_address: address): u64 acquires DelegationPool {
    assert_delegation_pool_exists(pool_address);
    pool_u64::shareholders_count(&borrow_global<DelegationPool>(pool_address).active_shares)
}

public fun get_delegation_pool_stake(pool_address: address): (u64, u64, u64, u64) {
    assert_delegation_pool_exists(pool_address);
    stake::get_stake(pool_address)
}

public fun get_pending_withdrawal(
    pool_address: address,
    delegator_address: address
): (bool, u64) acquires DelegationPool {
    assert_delegation_pool_exists(pool_address);
    let pool = borrow_global<DelegationPool>(pool_address);
    let (
        lockup_cycle_ended,
        _,
        pending_inactive,
        _,
        commission_pending_inactive
    ) = calculate_stake_pool_drift(pool);

    let (withdrawal_exists, withdrawal_olc) = pending_withdrawal_exists(pool, delegator_address);
    if (!withdrawal_exists) {
        // if no pending withdrawal, there is neither inactive nor pending_inactive stake
        (false, 0)
    } else {
        // delegator has either inactive or pending_inactive stake due to automatic withdrawals
        let inactive_shares = table::borrow(&pool.inactive_shares, withdrawal_olc);
        if (withdrawal_olc.index < pool.observed_lockup_cycle.index) {
            // if withdrawal's lockup cycle ended on delegation pool then it is inactive
            (true, pool_u64::balance(inactive_shares, delegator_address))
        } else {
            pending_inactive = pool_u64::shares_to_amount_with_total_coins(
                inactive_shares,
                pool_u64::shares(inactive_shares, delegator_address),
                // exclude operator pending_inactive rewards not converted to shares yet
                pending_inactive - commission_pending_inactive
            );
            // if withdrawal's lockup cycle ended ONLY on stake pool then it is also inactive
            (lockup_cycle_ended, pending_inactive)
        }
    }
}

public fun get_stake(
    pool_address: address,
    delegator_address: address
): (u64, u64, u64) acquires DelegationPool, BeneficiaryForOperator {
    assert_delegation_pool_exists(pool_address);
    let pool = borrow_global<DelegationPool>(pool_address);
    let (
        lockup_cycle_ended,
        active,
        _,
        commission_active,
        commission_pending_inactive
    ) = calculate_stake_pool_drift(pool);

    let total_active_shares = pool_u64::total_shares(&pool.active_shares);
    let delegator_active_shares = pool_u64::shares(&pool.active_shares, delegator_address);

    let (_, _, pending_active, _) = stake::get_stake(pool_address);
    if (pending_active == 0) {
        // zero `pending_active` stake indicates that either there are no `add_stake` fees or
        // previous epoch has ended and should identify shares owning these fees as released
        total_active_shares = total_active_shares - pool_u64::shares(&pool.active_shares, NULL_SHAREHOLDER);
        if (delegator_address == NULL_SHAREHOLDER) {
            delegator_active_shares = 0
        }
    };
    active = pool_u64::shares_to_amount_with_total_stats(
        &pool.active_shares,
        delegator_active_shares,
        // exclude operator active rewards not converted to shares yet
        active - commission_active,
        total_active_shares
    );

    // get state and stake (0 if there is none) of the pending withdrawal
    let (withdrawal_inactive, withdrawal_stake) = get_pending_withdrawal(pool_address, delegator_address);
    // report non-active stakes accordingly to the state of the pending withdrawal
    let (inactive, pending_inactive) = if (withdrawal_inactive) (withdrawal_stake, 0) else (0, withdrawal_stake);

    // should also include commission rewards in case of the operator account
    // operator rewards are actually used to buy shares which is introducing
    // some imprecision (received stake would be slightly less)
    // but adding rewards onto the existing stake is still a good approximation
    if (delegator_address == beneficiary_for_operator(get_operator(pool_address))) {
        active = active + commission_active;
        // in-flight pending_inactive commission can coexist with already inactive withdrawal
        if (lockup_cycle_ended) {
            inactive = inactive + commission_pending_inactive
        } else {
            pending_inactive = pending_inactive + commission_pending_inactive
        }
    };

    (active, inactive, pending_inactive)
}

public fun get_add_stake_fee(
    pool_address: address,
    amount: u64
): u64 acquires DelegationPool, NextCommissionPercentage {
    if (stake::is_current_epoch_validator(pool_address)) {
        let (rewards_rate, rewards_rate_denominator) = staking_config::get_reward_rate(&staking_config::get());
        if (rewards_rate_denominator > 0) {
            assert_delegation_pool_exists(pool_address);

            rewards_rate = rewards_rate * (MAX_FEE - operator_commission_percentage(pool_address));
            rewards_rate_denominator = rewards_rate_denominator * MAX_FEE;
            ((((amount as u128) * (rewards_rate as u128)) / ((rewards_rate as u128) + (rewards_rate_denominator as u128))) as u64)
        } else { 0 }
    } else { 0 }
}

public fun can_withdraw_pending_inactive(pool_address: address): bool {
    stake::get_validator_state(pool_address) == VALIDATOR_STATUS_INACTIVE &&
        timestamp::now_seconds() >= stake::get_lockup_secs(pool_address)
}

public fun calculate_and_update_voter_total_voting_power(
    pool_address: address,
    voter: address
): u64 acquires DelegationPool, GovernanceRecords, BeneficiaryForOperator, NextCommissionPercentage {
    assert_partial_governance_voting_enabled(pool_address);
    // Delegation pool need to be synced to explain rewards(which could change the coin amount) and
    // commission(which could cause share transfer).
    synchronize_delegation_pool(pool_address);
    let pool = borrow_global<DelegationPool>(pool_address);
    let governance_records = borrow_global_mut<GovernanceRecords>(pool_address);
    let latest_delegated_votes = update_and_borrow_mut_delegated_votes(pool, governance_records, voter);
    calculate_total_voting_power(pool, latest_delegated_votes)
}

public fun calculate_and_update_remaining_voting_power(
    pool_address: address,
    voter_address: address,
    proposal_id: u64
): u64 acquires DelegationPool, GovernanceRecords, BeneficiaryForOperator, NextCommissionPercentage {
    assert_partial_governance_voting_enabled(pool_address);
    // If the whole stake pool has no voting power(e.g. it has already voted before partial
    // governance voting flag is enabled), the delegator also has no voting power.
    if (aptos_governance::get_remaining_voting_power(pool_address, proposal_id) == 0) {
        return 0
    };

    let total_voting_power = calculate_and_update_voter_total_voting_power(pool_address, voter_address);
    let governance_records = borrow_global<GovernanceRecords>(pool_address);
    total_voting_power - get_used_voting_power(governance_records, voter_address, proposal_id)
}

public fun calculate_and_update_delegator_voter(
    pool_address: address,
    delegator_address: address
): address acquires DelegationPool, GovernanceRecords {
    assert_partial_governance_voting_enabled(pool_address);
    calculate_and_update_delegator_voter_internal(
        borrow_global<DelegationPool>(pool_address),
        borrow_global_mut<GovernanceRecords>(pool_address),
        delegator_address
    )
}

public fun calculate_and_update_voting_delegation(
    pool_address: address,
    delegator_address: address
): (address, address, u64) acquires DelegationPool, GovernanceRecords {
    assert_partial_governance_voting_enabled(pool_address);
    let vote_delegation = update_and_borrow_mut_delegator_vote_delegation(
        borrow_global<DelegationPool>(pool_address),
        borrow_global_mut<GovernanceRecords>(pool_address),
        delegator_address
    );

    (vote_delegation.voter, vote_delegation.pending_voter, vote_delegation.last_locked_until_secs)
}

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

public fun min_remaining_secs_for_commission_change(): u64 {
    let config = staking_config::get();
    staking_config::get_recurring_lockup_duration(&config) / 4
}

public fun allowlisting_enabled(pool_address: address): bool {
    assert_delegation_pool_exists(pool_address);
    exists<DelegationPoolAllowlisting>(pool_address)
}

public fun delegator_allowlisted(
    pool_address: address,
    delegator_address: address,
): bool acquires DelegationPoolAllowlisting {
    if (!allowlisting_enabled(pool_address)) { return true };
    smart_table::contains(freeze(borrow_mut_delegators_allowlist(pool_address)), delegator_address)
}

public fun get_delegators_allowlist(
    pool_address: address,
): vector<address> acquires DelegationPoolAllowlisting {
    assert_allowlisting_enabled(pool_address);

    let allowlist = vector[];
    smart_table::for_each_ref(freeze(borrow_mut_delegators_allowlist(pool_address)), |delegator, _v| {
        vector::push_back(&mut allowlist, *delegator);
    });
    allowlist
}

inline fun check_delegation_pool_management_permission(s: &signer) {
    assert!(
        permissioned_signer::check_permission_exists(s, DelegationPermission::DelegationPoolManagementPermission {}),
        error::permission_denied(ENO_DELEGATION_PERMISSION),
    );
}

public fun grant_delegation_pool_management_permission(master: &signer, permissioned_signer: &signer) {
    permissioned_signer::authorize_unlimited(master, permissioned_signer, DelegationPermission::DelegationPoolManagementPermission {})
}

inline fun check_stake_management_permission(s: &signer) {
    assert!(
        permissioned_signer::check_permission_exists(s, DelegationPermission::StakeManagementPermission {}),
        error::permission_denied(ENO_DELEGATION_PERMISSION),
    );
}

public fun grant_stake_management_permission(master: &signer, permissioned_signer: &signer) {
    permissioned_signer::authorize_unlimited(master, permissioned_signer, DelegationPermission::StakeManagementPermission {})
}

public entry fun initialize_delegation_pool(
    owner: &signer,
    operator_commission_percentage: u64,
    delegation_pool_creation_seed: vector<u8>,
) acquires DelegationPool, GovernanceRecords, BeneficiaryForOperator, NextCommissionPercentage {
    check_delegation_pool_management_permission(owner);
    let owner_address = signer::address_of(owner);
    assert!(!owner_cap_exists(owner_address), error::already_exists(EOWNER_CAP_ALREADY_EXISTS));
    assert!(operator_commission_percentage <= MAX_FEE, error::invalid_argument(EINVALID_COMMISSION_PERCENTAGE));

    // generate a seed to be used to create the resource account hosting the delegation pool
    let seed = create_resource_account_seed(delegation_pool_creation_seed);

    let (stake_pool_signer, stake_pool_signer_cap) = account::create_resource_account(owner, seed);
    coin::register<AptosCoin>(&stake_pool_signer);

    // stake_pool_signer will be owner of the stake pool and have its `stake::OwnerCapability`
    let pool_address = signer::address_of(&stake_pool_signer);
    stake::initialize_stake_owner(&stake_pool_signer, 0, owner_address, owner_address);

    let inactive_shares = table::new<ObservedLockupCycle, pool_u64::Pool>();
    table::add(
        &mut inactive_shares,
        olc_with_index(0),
        pool_u64::create_with_scaling_factor(SHARES_SCALING_FACTOR)
    );

    move_to(&stake_pool_signer, DelegationPool {
        active_shares: pool_u64::create_with_scaling_factor(SHARES_SCALING_FACTOR),
        observed_lockup_cycle: olc_with_index(0),
        inactive_shares,
        pending_withdrawals: table::new<address, ObservedLockupCycle>(),
        stake_pool_signer_cap,
        total_coins_inactive: 0,
        operator_commission_percentage,
        add_stake_events: account::new_event_handle<AddStakeEvent>(&stake_pool_signer),
        reactivate_stake_events: account::new_event_handle<ReactivateStakeEvent>(&stake_pool_signer),
        unlock_stake_events: account::new_event_handle<UnlockStakeEvent>(&stake_pool_signer),
        withdraw_stake_events: account::new_event_handle<WithdrawStakeEvent>(&stake_pool_signer),
        distribute_commission_events: account::new_event_handle<DistributeCommissionEvent>(&stake_pool_signer),
    });

    // save delegation pool ownership and resource account address (inner stake pool address) on `owner`
    move_to(owner, DelegationPoolOwnership { pool_address });

    // All delegation pool enable partial governance voting by default once the feature flag is enabled.
    enable_partial_governance_voting(pool_address);
}

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 entry fun enable_partial_governance_voting(
    pool_address: address,
) acquires DelegationPool, GovernanceRecords, BeneficiaryForOperator, NextCommissionPercentage {
    assert_delegation_pool_exists(pool_address);
    // synchronize delegation and stake pools before any user operation.
    synchronize_delegation_pool(pool_address);

    let delegation_pool = borrow_global<DelegationPool>(pool_address);
    let stake_pool_signer = retrieve_stake_pool_owner(delegation_pool);
    // delegated_voter is managed by the stake pool itself, which signer capability is managed by DelegationPool.
    // So voting power of this stake pool can only be used through this module.
    stake::set_delegated_voter(&stake_pool_signer, signer::address_of(&stake_pool_signer));

    move_to(&stake_pool_signer, GovernanceRecords {
        votes: smart_table::new(),
        votes_per_proposal: smart_table::new(),
        vote_delegation: smart_table::new(),
        delegated_votes: smart_table::new(),
        vote_events: account::new_event_handle<VoteEvent>(&stake_pool_signer),
        create_proposal_events: account::new_event_handle<CreateProposalEvent>(&stake_pool_signer),
        delegate_voting_power_events: account::new_event_handle<DelegateVotingPowerEvent>(&stake_pool_signer),
    });
}

public entry fun vote(
    voter: &signer,
    pool_address: address,
    proposal_id: u64,
    voting_power: u64,
    should_pass: bool
) acquires DelegationPool, GovernanceRecords, BeneficiaryForOperator, NextCommissionPercentage {
    check_stake_management_permission(voter);
    assert_partial_governance_voting_enabled(pool_address);
    // synchronize delegation and stake pools before any user operation.
    synchronize_delegation_pool(pool_address);

    let voter_address = signer::address_of(voter);
    let remaining_voting_power = calculate_and_update_remaining_voting_power(
        pool_address,
        voter_address,
        proposal_id
    );
    if (voting_power > remaining_voting_power) {
        voting_power = remaining_voting_power;
    };
    aptos_governance::assert_proposal_expiration(pool_address, proposal_id);
    assert!(voting_power > 0, error::invalid_argument(ENO_VOTING_POWER));

    let governance_records = borrow_global_mut<GovernanceRecords>(pool_address);
    // Check a edge case during the transient period of enabling partial governance voting.
    assert_and_update_proposal_used_voting_power(governance_records, pool_address, proposal_id, voting_power);
    let used_voting_power = borrow_mut_used_voting_power(governance_records, voter_address, proposal_id);
    *used_voting_power = *used_voting_power + voting_power;

    let pool_signer = retrieve_stake_pool_owner(borrow_global<DelegationPool>(pool_address));
    aptos_governance::partial_vote(&pool_signer, pool_address, proposal_id, voting_power, should_pass);

    if (features::module_event_migration_enabled()) {
        event::emit(
            Vote {
                voter: voter_address,
                proposal_id,
                delegation_pool: pool_address,
                num_votes: voting_power,
                should_pass,
            }
        );
    } else {
        event::emit_event(
            &mut governance_records.vote_events,
            VoteEvent {
                voter: voter_address,
                proposal_id,
                delegation_pool: pool_address,
                num_votes: voting_power,
                should_pass,
            }
        );
    };
}

public entry fun create_proposal(
    voter: &signer,
    pool_address: address,
    execution_hash: vector<u8>,
    metadata_location: vector<u8>,
    metadata_hash: vector<u8>,
    is_multi_step_proposal: bool,
) acquires DelegationPool, GovernanceRecords, BeneficiaryForOperator, NextCommissionPercentage {
    check_stake_management_permission(voter);
    assert_partial_governance_voting_enabled(pool_address);

    // synchronize delegation and stake pools before any user operation
    synchronize_delegation_pool(pool_address);

    let voter_addr = signer::address_of(voter);
    let pool = borrow_global<DelegationPool>(pool_address);
    let governance_records = borrow_global_mut<GovernanceRecords>(pool_address);
    let total_voting_power = calculate_and_update_delegated_votes(pool, governance_records, voter_addr);
    assert!(
        total_voting_power >= aptos_governance::get_required_proposer_stake(),
        error::invalid_argument(EINSUFFICIENT_PROPOSER_STAKE));
    let pool_signer = retrieve_stake_pool_owner(borrow_global<DelegationPool>(pool_address));
    let proposal_id = aptos_governance::create_proposal_v2_impl(
        &pool_signer,
        pool_address,
        execution_hash,
        metadata_location,
        metadata_hash,
        is_multi_step_proposal,
    );

    let governance_records = borrow_global_mut<GovernanceRecords>(pool_address);

    if (features::module_event_migration_enabled()) {
        event::emit(
            CreateProposal {
                proposal_id,
                voter: voter_addr,
                delegation_pool: pool_address,
            }
        );
    } else {
        event::emit_event(
            &mut governance_records.create_proposal_events,
            CreateProposalEvent {
                proposal_id,
                voter: voter_addr,
                delegation_pool: pool_address,
            }
        );
    };
}

fun assert_owner_cap_exists(owner: address) {
    assert!(owner_cap_exists(owner), error::not_found(EOWNER_CAP_NOT_FOUND));
}

fun assert_delegation_pool_exists(pool_address: address) {
    assert!(delegation_pool_exists(pool_address), error::invalid_argument(EDELEGATION_POOL_DOES_NOT_EXIST));
}

fun assert_min_active_balance(pool: &DelegationPool, delegator_address: address) {
    let balance = pool_u64::balance(&pool.active_shares, delegator_address);
    assert!(balance >= MIN_COINS_ON_SHARES_POOL, error::invalid_argument(EDELEGATOR_ACTIVE_BALANCE_TOO_LOW));
}

fun assert_min_pending_inactive_balance(pool: &DelegationPool, delegator_address: address) {
    let balance = pool_u64::balance(pending_inactive_shares_pool(pool), delegator_address);
    assert!(
        balance >= MIN_COINS_ON_SHARES_POOL,
        error::invalid_argument(EDELEGATOR_PENDING_INACTIVE_BALANCE_TOO_LOW)
    );
}

fun assert_partial_governance_voting_enabled(pool_address: address) {
    assert_delegation_pool_exists(pool_address);
    assert!(
        partial_governance_voting_enabled(pool_address),
        error::invalid_state(EPARTIAL_GOVERNANCE_VOTING_NOT_ENABLED)
    );
}

fun assert_allowlisting_enabled(pool_address: address) {
    assert!(allowlisting_enabled(pool_address), error::invalid_state(EDELEGATORS_ALLOWLISTING_NOT_ENABLED));
}

fun assert_delegator_allowlisted(
    pool_address: address,
    delegator_address: address,
) acquires DelegationPoolAllowlisting {
    assert!(
        delegator_allowlisted(pool_address, delegator_address),
        error::permission_denied(EDELEGATOR_NOT_ALLOWLISTED)
    );
}

fun coins_to_redeem_to_ensure_min_stake(
    src_shares_pool: &pool_u64::Pool,
    shareholder: address,
    amount: u64,
): u64 {
    // find how many coins would be redeemed if supplying `amount`
    let redeemed_coins = pool_u64::shares_to_amount(
        src_shares_pool,
        amount_to_shares_to_redeem(src_shares_pool, shareholder, amount)
    );
    // if balance drops under threshold then redeem it entirely
    let src_balance = pool_u64::balance(src_shares_pool, shareholder);
    if (src_balance - redeemed_coins < MIN_COINS_ON_SHARES_POOL) {
        amount = src_balance;
    };
    amount
}

fun coins_to_transfer_to_ensure_min_stake(
    src_shares_pool: &pool_u64::Pool,
    dst_shares_pool: &pool_u64::Pool,
    shareholder: address,
    amount: u64,
): u64 {
    // find how many coins would be redeemed from source if supplying `amount`
    let redeemed_coins = pool_u64::shares_to_amount(
        src_shares_pool,
        amount_to_shares_to_redeem(src_shares_pool, shareholder, amount)
    );
    // if balance on destination would be less than threshold then redeem difference to threshold
    let dst_balance = pool_u64::balance(dst_shares_pool, shareholder);
    if (dst_balance + redeemed_coins < MIN_COINS_ON_SHARES_POOL) {
        // `redeemed_coins` >= `amount` - 1 as redeem can lose at most 1 coin
        amount = MIN_COINS_ON_SHARES_POOL - dst_balance + 1;
    };
    // check if new `amount` drops balance on source under threshold and adjust
    coins_to_redeem_to_ensure_min_stake(src_shares_pool, shareholder, amount)
}

fun retrieve_stake_pool_owner(pool: &DelegationPool): signer {
    account::create_signer_with_capability(&pool.stake_pool_signer_cap)
}

fun get_pool_address(pool: &DelegationPool): address {
    account::get_signer_capability_address(&pool.stake_pool_signer_cap)
}

fun get_delegator_active_shares(pool: &DelegationPool, delegator: address): u128 {
    pool_u64::shares(&pool.active_shares, delegator)
}

fun get_delegator_pending_inactive_shares(pool: &DelegationPool, delegator: address): u128 {
    pool_u64::shares(pending_inactive_shares_pool(pool), delegator)
}

fun get_used_voting_power(governance_records: &GovernanceRecords, voter: address, proposal_id: u64): u64 {
    let votes = &governance_records.votes;
    let key = VotingRecordKey {
        voter,
        proposal_id,
    };
    *smart_table::borrow_with_default(votes, key, &0)
}

fun create_resource_account_seed(
    delegation_pool_creation_seed: vector<u8>,
): vector<u8> {
    let seed = vector::empty<u8>();
    // include module salt (before any subseeds) to avoid conflicts with other modules creating resource accounts
    vector::append(&mut seed, MODULE_SALT);
    // include an additional salt in case the same resource account has already been created
    vector::append(&mut seed, delegation_pool_creation_seed);
    seed
}

inline fun borrow_mut_used_voting_power(
    governance_records: &mut GovernanceRecords,
    voter: address,
    proposal_id: u64
): &mut u64 {
    let votes = &mut governance_records.votes;
    let key = VotingRecordKey {
        proposal_id,
        voter,
    };
    smart_table::borrow_mut_with_default(votes, key, 0)
}

fun update_and_borrow_mut_delegator_vote_delegation(
    pool: &DelegationPool,
    governance_records: &mut GovernanceRecords,
    delegator: address
): &mut VoteDelegation {
    let pool_address = get_pool_address(pool);
    let locked_until_secs = stake::get_lockup_secs(pool_address);

    let vote_delegation_table = &mut governance_records.vote_delegation;
    // By default, a delegator's delegated voter is itself.
    // TODO: recycle storage when VoteDelegation equals to default value.
    if (!smart_table::contains(vote_delegation_table, delegator)) {
        return smart_table::borrow_mut_with_default(vote_delegation_table, delegator, VoteDelegation {
            voter: delegator,
            last_locked_until_secs: locked_until_secs,
            pending_voter: delegator,
        })
    };

    let vote_delegation = smart_table::borrow_mut(vote_delegation_table, delegator);
    // A lockup period has passed since last time `vote_delegation` was updated. Pending voter takes effect.
    if (vote_delegation.last_locked_until_secs < locked_until_secs) {
        vote_delegation.voter = vote_delegation.pending_voter;
        vote_delegation.last_locked_until_secs = locked_until_secs;
    };
    vote_delegation
}

fun update_and_borrow_mut_delegated_votes(
    pool: &DelegationPool,
    governance_records: &mut GovernanceRecords,
    voter: address
): &mut DelegatedVotes {
    let pool_address = get_pool_address(pool);
    let locked_until_secs = stake::get_lockup_secs(pool_address);

    let delegated_votes_per_voter = &mut governance_records.delegated_votes;
    // By default, a delegator's voter is itself.
    // TODO: recycle storage when DelegatedVotes equals to default value.
    if (!smart_table::contains(delegated_votes_per_voter, voter)) {
        let active_shares = get_delegator_active_shares(pool, voter);
        let inactive_shares = get_delegator_pending_inactive_shares(pool, voter);
        return smart_table::borrow_mut_with_default(delegated_votes_per_voter, voter, DelegatedVotes {
            active_shares,
            pending_inactive_shares: inactive_shares,
            active_shares_next_lockup: active_shares,
            last_locked_until_secs: locked_until_secs,
        })
    };

    let delegated_votes = smart_table::borrow_mut(delegated_votes_per_voter, voter);
    // A lockup period has passed since last time `delegated_votes` was updated. Pending voter takes effect.
    if (delegated_votes.last_locked_until_secs < locked_until_secs) {
        delegated_votes.active_shares = delegated_votes.active_shares_next_lockup;
        delegated_votes.pending_inactive_shares = 0;
        delegated_votes.last_locked_until_secs = locked_until_secs;
    };
    delegated_votes
}

fun olc_with_index(index: u64): ObservedLockupCycle {
    ObservedLockupCycle { index }
}

fun calculate_total_voting_power(delegation_pool: &DelegationPool, latest_delegated_votes: &DelegatedVotes): u64 {
    let active_amount = pool_u64::shares_to_amount(
        &delegation_pool.active_shares,
        latest_delegated_votes.active_shares);
    let pending_inactive_amount = pool_u64::shares_to_amount(
        pending_inactive_shares_pool(delegation_pool),
        latest_delegated_votes.pending_inactive_shares);
    active_amount + pending_inactive_amount
}

fun calculate_and_update_delegator_voter_internal(
    pool: &DelegationPool,
    governance_records: &mut GovernanceRecords,
    delegator: address
): address {
    let vote_delegation = update_and_borrow_mut_delegator_vote_delegation(pool, governance_records, delegator);
    vote_delegation.voter
}

fun calculate_and_update_delegated_votes(
    pool: &DelegationPool,
    governance_records: &mut GovernanceRecords,
    voter: address
): u64 {
    let delegated_votes = update_and_borrow_mut_delegated_votes(pool, governance_records, voter);
    calculate_total_voting_power(pool, delegated_votes)
}

inline fun borrow_mut_delegators_allowlist(
    pool_address: address
): &mut SmartTable<address, bool> acquires DelegationPoolAllowlisting {
    &mut borrow_global_mut<DelegationPoolAllowlisting>(pool_address).allowlist
}

public entry fun set_operator(
    owner: &signer,
    new_operator: address
) acquires DelegationPoolOwnership, DelegationPool, GovernanceRecords, BeneficiaryForOperator, NextCommissionPercentage {
    check_delegation_pool_management_permission(owner);
    let pool_address = get_owned_pool_address(signer::address_of(owner));
    // synchronize delegation and stake pools before any user operation
    // ensure the old operator is paid its uncommitted commission rewards
    synchronize_delegation_pool(pool_address);
    stake::set_operator(&retrieve_stake_pool_owner(borrow_global<DelegationPool>(pool_address)), new_operator);
}

public entry fun set_beneficiary_for_operator(
    operator: &signer,
    new_beneficiary: address
) acquires BeneficiaryForOperator {
    check_stake_management_permission(operator);
    // 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,
    });
}