ARC-0038: Proposed Commission Rate for Staking: Ensuring Fair Compensation for Delegated Stakeholders

[OzielLa]

---

arc: ARC-0038
title: Proposed Commission Rate for Staking: Ensuring Fair Compensation for Delegated Stakeholders
authors: OzielLa
topic: Protocol
status: Draft
created: 11/19/2023

Abstract

Validators contribute to the security of the network by verifying and confirming transactions, as well as monitoring and preventing malicious behavior. In return for their contributions, stakers receive rewards or earnings. Throughout this process, validators incur costs and must ensure the stability of their services and the network. To account for these expenses, it is proposed to set a commission rate for delegated staking.

The commission rate would serve as compensation to validators for their costs and as an incentive for their services. This rate would represent a portion of the rewards or earnings that validators receive from delegated stakers. The specific value of the commission rate can be determined based on the network's requirements and economic model. When setting the commission rate, the following factors should be considered:

1. Validator service and network stability: Validators allocate resources to verify and confirm transactions, as well as monitor and prevent malicious behavior. To ensure the stability of their services, validators need to charge a commission to cover their operational costs.
2. Rewards or earnings for delegated stakers: Delegated stakers contribute to the network by staking their assets and securing the network. They should receive fair rewards or earnings based on their contributions. The commission rate should be set to ensure that delegated stakers receive a reasonable share of rewards or earnings.
3. Economic model and network requirements: The specific value of the commission rate should consider the economic model and the network's needs. This may involve factors such as supply and demand dynamics, the number of participants, competition, and the overall health of the network.

The final commission rate should strike a balance, incentivizing validator participation and the provision of stable services, while providing fair returns to delegated stakers. Determining the commission rate may require community or consensus-based discussions and decision-making processes to ensure the sustainability and fairness of the network.

Specification

• Add a extra field in credits.aleo/struct committee_state

// The `committee_state` struct tracks the total stake of the validator, and whether they are open to stakers.
struct committee_state:
    // The commission rate set by validators.
    commission as u8;
    // The amount of microcredits bonded to the validator, by the validator and its delegators.
    microcredits as u64;
    // The boolean flag indicating if the validator is open to stakers.
    is_open as boolean;

• Add a extra field in credits.aleo/struct bond_state

// The `bond_state` struct tracks the amount of microcredits that are currently bonded to the specified validator.
struct bond_state:
    // The address of the validator.
    validator as address;
    // The commission rate set by validators.
    commission as u8;
    // The amount of microcredits that are currently bonded to the specified validator.
    microcredits as u64;

• Modified credits.aleo/finalize bond_public:

finalize bond_public:
    // Input the staker's address.
    input r0 as address.public;
    // Input the validator's address.
    input r1 as address.public;
    // Input the amount of microcredits to bond.
    input r2 as u64.public;

    // Determine whether the caller is a validator.
    is.eq r0 r1 into r3;
    // If the caller is a validator, jump to the `bond_validator` logic.
    branch.eq r3 true to bond_validator;
    // If the caller is not a validator, jump to the `bond_delegator` logic.
    branch.eq r3 false to bond_delegator;

    /******* Bond Validator *******/

    // Starts the `bond_validator` logic.
    position bond_validator;

    /* Committee */

    // Construct the initial committee state.
    // Note: We set the initial 'is_open' state to 'true'.
    cast 0u8 0u64 true into r4 as committee_state;
    // Retrieve the committee state of the specified validator.
    get.or_use committee[r0] r4 into r5;
    // Ensure that the validator is open to stakers.
    assert.eq r5.is_open true;

    // Increment the stake for the specified validator.
    add r5.microcredits r2 into r6;
    // Construct the updated committee state.
    cast r5.commission r6 r5.is_open into r7 as committee_state;

    /* Bonded */

    // Construct the initial bond state.
    cast r1 r5.commission 0u64 into r8 as bond_state;
    // Get the bond state for the caller, or default to the initial bond state.
    get.or_use bonded[r0] r8 into r9;
    // Enforce the validator matches in the bond state.
    assert.eq r9.validator r1;

    // Increment the microcredits in the bond state.
    add r9.microcredits r2 into r10;
    // Determine if the amount is at least one million credits.
    gte r10 1_000_000_000_000u64 into r11;
    // Enforce the amount is at least one million credits.
    assert.eq r11 true;

    // Construct the updated bond state, add bond use current commission.
    cast r1 r5.commission r10 into r12 as bond_state;

    /* Account */

    // Get the balance of the caller.
    // If the account does not exist, this finalize scope will fail.
    get account[r0] into r13;
    // Decrement the balance of the caller.
    sub r13 r2 into r14;

    /* Writes */

    // Update the committee state of the specified validator.
    set r7 into committee[r0];
    // Update the bond state for the caller.
    set r12 into bonded[r0];
    // Update the balance of the caller.
    set r14 into account[r0];

    // Ends the `bond_validator` logic.
    branch.eq true true to end;

    /******* Bond Delegator *******/

    // Starts the `bond_delegator` logic.
    position bond_delegator;

    /* Committee */

    // Check if the caller is a validator.
    contains committee[r0] into r15;
    // Enforce the caller is *not* a validator.
    assert.eq r15 false;

    // Get the stake for the specified validator.
    // If the validator does not exist, this finalize scope will fail.
    get committee[r1] into r16;
    // Ensure that the validator is open to stakers.
    assert.eq r16.is_open true;

    // Increment the stake for the specified validator.
    add r16.microcredits r2 into r17;
    // Construct the updated committee state.
    cast r16.commission r17 r16.is_open into r18 as committee_state;

    /* Bonded */

    // Construct the initial bond state.
    cast r1 r16.commission 0u64 into r19 as bond_state;
    // Get the bond state for the caller, or default to the initial bond state.
    get.or_use bonded[r0] r19 into r20;
    // Enforce the validator matches in the bond state.
    assert.eq r20.validator r1;

    // Increment the microcredits in the bond state.
    add r20.microcredits r2 into r21;
    // Determine if the amount is at least 10 credits.
    gte r21 10_000_000u64 into r22;
    // Enforce the amount is at least 10 credits.
    assert.eq r22 true;

    // Construct the updated bond state.
    cast r1 r16.commission r21 into r23 as bond_state;

    /* Account */

    // Get the balance of the caller.
    // If the account does not exist, this finalize scope will fail.
    get account[r0] into r24;
    // Decrement the balance of the caller.
    sub r24 r2 into r25;

    /* Writes */

    // Update the committee state for the specified validator.
    set r18 into committee[r1];
    // Update the bond state for the caller.
    set r23 into bonded[r0];
    // Update the balance of the caller.
    set r25 into account[r0];

    // The terminus.
    position end;	

• Modified credits.aleo/finalize unbond_public

finalize unbond_public:
    // Input the staker's address.
    input r0 as address.public;
    // Input the amount of microcredits to unbond.
    input r1 as u64.public;

    // Construct the initial unbond state.
    cast 0u64 0u32 into r2 as unbond_state;
    // Get the unbond state for the caller, or default to the initial unbond state.
    get.or_use unbonding[r0] r2 into r3;

    // Compute the height at which the unbonding will be complete, starting from the current block.
    // Note: Calling unbond across multiple blocks before the unbonding is complete will reset the height each time.
    add block.height 360u32 into r4;

    // Determine if the caller is a validator or delegator.
    contains committee[r0] into r5;

    // If the caller is a validator, jump to the `unbond_validator` logic.
    branch.eq r5 true to unbond_validator;
    // If the caller is not a validator, jump to the `unbond_delegator` logic.
    branch.eq r5 false to unbond_delegator;

    /******* Unbond Validator *******/

    // Starts the `unbond_validator` logic.
    position unbond_validator;

    /* Committee */

    // Get the committee state for the specified validator.
    get committee[r0] into r6;
    // Decrement the stake for the specified validator.
    sub r6.microcredits r1 into r7;

    /* Bonded */

    // Get the bond state for the validator, or fail if it does not exist.
    get bonded[r0] into r8;
    // Ensure that the validator matches in the bond state.
    assert.eq r8.validator r0;
    // Decrement the microcredits in the bond state.
    sub r8.microcredits r1 into r9;

    // Determine if the remaining bond is at least one million credits.
    gte r9 1_000_000_000_000u64 into r10;

    // If the remaining balance is at least 1 million credits, jump to the `decrement_validator` logic.
    branch.eq r10 true to decrement_validator;
    // If the remaining balance is less than 1 million credits, jump to the `remove_validator` logic.
    branch.eq r10 false to remove_validator;

    /*** Decrement Validator ***/

    // Starts the `decrement_validator` logic.
    position decrement_validator;

    /* Committee */

    // Construct the updated committee state.
    cast r6.commission r7 r6.is_open into r11 as committee_state;
    // Update the committee state for the validator.
    set r11 into committee[r0];

    /* Bonded */

    // Construct the updated bond state.
    cast r0 r6.commission r9 into r12 as bond_state;
    // Update the bond state for the validator.
    set r12 into bonded[r0];

    /* Unbonding */

    // Increment the microcredits in the unbond state.
    add r3.microcredits r1 into r13;

    // Construct the updated unbond state.
    cast r13 r4 into r14 as unbond_state;
    // Update the unbond state for the caller.
    set r14 into unbonding[r0];

    // Ends the `decrement_validator` logic.
    branch.eq true true to end;

    /*** Remove Validator ***/

    // Starts the `remove_validator` logic.
    position remove_validator;

    // Ensure that the validator has no delegators.
    assert.eq r6.microcredits r8.microcredits;

    /* Committee */

    // Remove the validator from the committee.
    remove committee[r0];

    /* Bonded */

    // Remove the bond state for the validator.
    remove bonded[r0];

    /* Unbonding */

    // Increment the microcredits in the unbond state.
    add r3.microcredits r8.microcredits into r15;

    // Construct the updated unbond state.
    cast r15 r4 into r16 as unbond_state;
    // Update the unbond state for the caller.
    set r16 into unbonding[r0];

    // Ends the `remove_validator` logic.
    branch.eq true true to end;

    /******* Unbond Delegator *******/

    // Starts the `unbond_delegator` logic.
    position unbond_delegator;

    // Get the bond state for the caller, or fail if it does not exist.
    get bonded[r0] into r17;
    // Decrement the microcredits in the bond state.
    sub r17.microcredits r1 into r18;

    // Determine if the remaining bond is at least 10 credits.
    gte r18 10_000_000u64 into r19;

    // If the remaining balance is at least 10 credits, jump to the `decrement_delegator` logic.
    branch.eq r19 true to decrement_delegator;
    // If the remaining balance is less than 10 credits, jump to the `remove_delegator` logic.
    branch.eq r19 false to remove_delegator;

    /*** Decrement Delegator ***/

    // Starts the `decrement_delegator` logic.
    position decrement_delegator;

    /* Committee */

    // Get the stake for the specified validator.
    // If the validator does not exist, this finalize scope will fail.
    get committee[r17.validator] into r20;
    // Decrement the stake for the specified validator.
    sub r20.microcredits r1 into r21;
    // Construct the updated committee state.
    cast r20.commission r21 r20.is_open into r22 as committee_state;
    // Update the stake for the specified validator.
    set r22 into committee[r17.validator];

    /* Bonded */

    // Construct the updated bond state.
    cast r17.validator r17.commission r18 into r23 as bond_state;
    // Update the bond state for the caller.
    set r23 into bonded[r0];

    /* Unbonding */

    // Increment the microcredits in the unbond state.
    add r3.microcredits r1 into r24;

    // Construct the updated unbond state.
    cast r24 r4 into r25 as unbond_state;
    // Update the unbond state for the caller.
    set r25 into unbonding[r0];

    // Ends the `decrement_delegator` logic.
    branch.eq true true to end;

    /*** Remove Delegator ***/

    // Starts the `remove_delegator` logic.
    position remove_delegator;

    /* Committee */

    // Get the stake for the specified validator.
    // If the validator does not exist, this finalize scope will fail.
    get committee[r17.validator] into r26;
    // Decrement the stake for the specified validator.
    sub r26.microcredits r17.microcredits into r27;
    // Construct the updated committee state.
    cast r26.commission r27 r26.is_open into r28 as committee_state;
    // Update the stake for the specified validator.
    set r28 into committee[r17.validator];

    /* Bonded */

    // Remove the caller from the bonded mapping.
    remove bonded[r0];

    /* Unbonding */

    // Increment the microcredits in the unbond state.
    add r3.microcredits r17.microcredits into r29;

    // Construct the updated unbond state.
    cast r29 r4 into r30 as unbond_state;
    // Update the unbond state for the caller.
    set r30 into unbonding[r0];

    // The terminus.
    position end;

• Modified credits.aleo/finalize unbond_delegator_as_validator

finalize unbond_delegator_as_validator:
    // Input the validator's address.
    input r0 as address.public;
    // Input the delegator's address.
    input r1 as address.public;

    /* Start Committee */

    // Get the committee state for the specified validator.
    // If the validator does not exist, this finalize scope will fail.
    get committee[r0] into r2;
    // Enforce that the validator is closed to stakers.
    assert.eq r2.is_open false;

    // Check if the delegator is a validator.
    contains committee[r1] into r3;
    // Enforce the delegator is *not* a validator.
    assert.eq r3 false;

    /* End Committee */

    /* Start Bonded */

    // Get the bond state for the delegator, or fail if it does not exist.
    get bonded[r1] into r4;
    // Enforce that the delegator is bonded to the validator.
    assert.eq r4.validator r0;

    /* End Bonded */

    /* Start Committee */

    // Decrement the stake for the specified validator.
    sub r2.microcredits r4.microcredits into r5;
    // Construct the updated committee state.
    cast r2.commission r5 r2.is_open into r6 as committee_state;

    /* End Committee */

    /* Start Unbond */

    // Construct the initial unbond state.
    cast 0u64 0u32 into r7 as unbond_state;
    // Get the unbond state for the delegator, or default to the initial unbond state.
    get.or_use unbonding[r1] r7 into r8;

    // Increment the microcredits in the unbond state.
    add r8.microcredits r4.microcredits into r9;
    // Compute the height at which the unbonding will be complete, starting from the current block.
    // Note: Calling unbond across multiple blocks before the unbonding is complete will reset the height each time.
    add block.height 360u32 into r10;

    // Construct the updated unbond state.
    cast r9 r10 into r11 as unbond_state;

    /* End Unbond */

    /* Start Writes */

    // Update the committee state for the specified validator.
    set r6 into committee[r0];
    // Remove the bond state for the delegator.
    remove bonded[r1];
    // Update the unbond state for the delegator.
    set r11 into unbonding[r1];

    /* End Writes */

• Modified credits.aleo/finalize set_validator_state

finalize set_validator_state:
    // Input the validator's address.
    input r0 as address.public;
    // Input the 'is_open' state.
    input r1 as boolean.public;

    // Get the committee state for the specified validator.
    // If the validator does not exist, this finalize scope will fail.
    get committee[r0] into r2;

    // Construct the updated committee state.
    cast r2.commission r2.microcredits r1 into r3 as committee_state;
    // Update the committee state for the specified validator.
    set r3 into committee[r0];

• add function credits.aleo/finalize set_validator_commission

/**********************************************************************************************************************/

// Setting or updating the commission rate for validators.
// Updata commission rate, new delegators or additional delegations will be calculated based on the latest commission percentage value. 
// Previous delegators will continue to have their commissions calculated based on the original commission percentage value they had.
// Commissions will be collected during the unbond_public and unbond_delegator_as_validator operations.
function set_validator_commission:
    // Input the 'commission' value.
    input r0 as u8.public;
    lte r0 100u8 into r1;
    assert.eq r1 true;

    // Set the validator's commission 
    async set_validator_commission self.caller r0 into r2;
    // Output the finalize future.
    output r2 as credits.aleo/set_validator_commission.future;

finalize set_validator_commission:
    // Input the validator's address.
    input r0 as address.public;
    // Input the 'commission' state.
    input r1 as u8.public;

    // Get the committee state for the specified validator.
    // If the validator does not exist, this finalize scope will fail.
    get committee[r0] into r2;

    // Construct the updated committee state.
    cast r1 r2.microcredits r2.is_open into r3 as committee_state;
    // Update the committee state for the specified validator.
    set r3 into committee[r0];

• Modified synthesizer/src/vm/helpers/rewards.rs

pub fn staking_rewards<N: Network>(
    stakers: &IndexMap<Address<N>, (Address<N>, u8, u64)>,
    committee: &Committee<N>,
    block_reward: u64,
) -> IndexMap<Address<N>, (Address<N>, u8, u64)> {
    // If the list of stakers is empty, there is no stake, or the block reward is 0, return the stakers.
    if stakers.is_empty() || committee.total_stake() == 0 || block_reward == 0 {
        return stakers.clone();
    }

    // let total_commission = AtomicU64::new(0);
    let map_commission: Mutex<IndexMap<Address<N>, u64>> = Default::default();

    // Compute the updated stakers.
    let stakers: IndexMap<Address<N>, (Address<N>, u8, u64)> = cfg_iter!(stakers)
        .map(|(staker, (validator, commission, stake))| {
            // If the validator has more than 25% of the total stake, skip the staker.
            if committee.get_stake(*validator) > committee.total_stake().saturating_div(4) {
                trace!("Validator {validator} has more than 25% of the total stake - skipping {staker}");
                return (*staker, (*validator, *commission, *stake));
            }
            // If the staker has less than the minimum required stake, skip the staker.
            if *stake < MIN_DELEGATOR_STAKE {
                trace!("Staker has less than {MIN_DELEGATOR_STAKE} microcredits - skipping {staker}");
                return (*staker, (*validator, *commission, *stake));
            }

            // Compute the numerator.
            let numerator = (block_reward as u128).saturating_mul(*stake as u128);
            // Compute the denominator.
            // Note: We guarantee this denominator cannot be 0 (as we return early if the total stake is 0).
            let denominator = committee.total_stake() as u128;
            // Compute the quotient.
            let quotient = numerator.saturating_div(denominator);
            // Ensure the staking reward is within a safe bound.
            if quotient > MAX_COINBASE_REWARD as u128 {
                error!("Staking reward ({quotient}) is too large - skipping {staker}");
                return (*staker, (*validator, *commission, *stake));
            }

            let mut commission_u128 = *commission as u128;
            if commission_u128 > MAX_PERCENT {
                commission_u128 = MAX_PERCENT
            }
            // The net income for a delegator
            let net_income = quotient.saturating_mul(MAX_PERCENT - commission_u128).saturating_div(MAX_PERCENT);
            let staker_commission = quotient.saturating_sub(net_income);
            // Cast the staking reward as a u64.
            // Note: This '.expect' is guaranteed to be safe, as we ensure the quotient is within a safe bound.
            let staking_reward = u64::try_from(net_income).expect("Staking reward is too large");
            let commission_reward = u64::try_from(staker_commission).expect("Staking reward is too large");
            let mut lock_map_commission = map_commission.lock();
            let v = lock_map_commission.get(validator).unwrap_or(&MIN_PERCENT);
            let total_commission_reward = *v;

            lock_map_commission.insert(*validator, total_commission_reward + commission_reward);

            // total_commission.fetch_add(commission_reward, Ordering::Relaxed);
            // Return the staker and the updated stake.
            (*staker, (*validator, *commission, stake.saturating_add(staking_reward)))
        })
        .collect();

    cfg_iter!(stakers)
        .map(|(staker, (validator, commission, stake))| {
            if staker != validator {
                // Return the staker and the updated stake.
                (*staker, (*validator, *commission, *stake))
            } else {
                let total_map_commission = map_commission.lock();
                let v = total_map_commission.get(validator).unwrap_or(&MIN_PERCENT);
                let total_value = *v;
                (*staker, (*validator, *commission, stake.saturating_add(total_value)))
            }
        })
        .collect()
}

• updata patch

diff --git a/ledger/committee/src/bytes.rs b/ledger/committee/src/bytes.rs
index 2c3eba977..8bb0d32e6 100644
--- a/ledger/committee/src/bytes.rs
+++ b/ledger/committee/src/bytes.rs
@@ -40,12 +40,14 @@ impl<N: Network> FromBytes for Committee<N> {
         for _ in 0..num_members {
             // Read the address.
             let member = Address::read_le(&mut reader)?;
+            // Read the commission.
+            let commission = u8::read_le(&mut reader)?;
             // Read the stake.
             let stake = u64::read_le(&mut reader)?;
             // Read the is_open flag.
             let is_open = bool::read_le(&mut reader)?;
             // Insert the member and (stake, is_open).
-            members.insert(member, (stake, is_open));
+            members.insert(member, (commission, stake, is_open));
         }
         // Read the total stake.
         let total_stake = u64::read_le(&mut reader)?;
@@ -69,9 +71,11 @@ impl<N: Network> ToBytes for Committee<N> {
         // Write the number of members.
         u16::try_from(self.members.len()).map_err(|e| error(e.to_string()))?.write_le(&mut writer)?;
         // Write the members.
-        for (address, (stake, is_open)) in &self.members {
+        for (address, (commission, stake, is_open)) in &self.members {
             // Write the address.
             address.write_le(&mut writer)?;
+            // Write the commission.
+            commission.write_le(&mut writer)?;
             // Write the stake.
             stake.write_le(&mut writer)?;
             // Write the is_open flag.
diff --git a/ledger/committee/src/lib.rs b/ledger/committee/src/lib.rs
index 5d81de441..861e45a4d 100644
--- a/ledger/committee/src/lib.rs
+++ b/ledger/committee/src/lib.rs
@@ -37,8 +37,8 @@ pub const MIN_DELEGATOR_STAKE: u64 = 10_000_000u64; // microcredits
 pub struct Committee<N: Network> {
     /// The starting round number for this committee.
     starting_round: u64,
-    /// A map of `address` to `(stake, is_open)` state.
-    members: IndexMap<Address<N>, (u64, bool)>,
+    /// A map of `address` to `(commission, stake, is_open)` state.
+    members: IndexMap<Address<N>, (u8, u64, bool)>,
     /// The total stake of all `members`.
     total_stake: u64,
 }
@@ -48,7 +48,7 @@ impl<N: Network> Committee<N> {
     pub const MAX_COMMITTEE_SIZE: u16 = 200;
 
     /// Initializes a new `Committee` instance.
-    pub fn new_genesis(members: IndexMap<Address<N>, (u64, bool)>) -> Result<Self> {
+    pub fn new_genesis(members: IndexMap<Address<N>, (u8, u64, bool)>) -> Result<Self> {
         // Ensure there are exactly 4 members.
         ensure!(members.len() == 4, "Genesis committee must have 4 members");
         // Return the new committee.
@@ -56,7 +56,7 @@ impl<N: Network> Committee<N> {
     }
 
     /// Initializes a new `Committee` instance.
-    pub fn new(starting_round: u64, members: IndexMap<Address<N>, (u64, bool)>) -> Result<Self> {
+    pub fn new(starting_round: u64, members: IndexMap<Address<N>, (u8, u64, bool)>) -> Result<Self> {
         // Ensure there are at least 4 members.
         ensure!(members.len() >= 4, "Committee must have at least 4 members");
         // Ensure there are no more than the maximum number of members.
@@ -67,7 +67,7 @@ impl<N: Network> Committee<N> {
         );
         // Ensure all members have the minimum required stake.
         ensure!(
-            members.values().all(|(stake, _)| *stake >= MIN_VALIDATOR_STAKE),
+            members.values().all(|(_, stake, _)| *stake >= MIN_VALIDATOR_STAKE),
             "All members must have at least {MIN_VALIDATOR_STAKE} microcredits in stake"
         );
         // Compute the total stake of the committee for this round.
@@ -84,7 +84,7 @@ impl<N: Network> Committee<N> {
     }
 
     /// Returns the committee members alongside their stake.
-    pub const fn members(&self) -> &IndexMap<Address<N>, (u64, bool)> {
+    pub const fn members(&self) -> &IndexMap<Address<N>, (u8, u64, bool)> {
         &self.members
     }
 
@@ -100,11 +100,16 @@ impl<N: Network> Committee<N> {
 
     /// Returns `true` if the given address is in the committee and is open.
     pub fn is_committee_member_open(&self, address: Address<N>) -> bool {
-        self.members.get(&address).copied().unwrap_or_default().1
+        self.members.get(&address).copied().unwrap_or_default().2
     }
 
     /// Returns the amount of stake for the given address.
     pub fn get_stake(&self, address: Address<N>) -> u64 {
+        self.members.get(&address).copied().unwrap_or_default().1
+    }
+
+    /// Returns the amount of commission for the given address.
+    pub fn get_commission(&self, address: Address<N>) -> u8 {
         self.members.get(&address).copied().unwrap_or_default().0
     }
 
@@ -179,7 +184,7 @@ impl<N: Network> Committee<N> {
         // Sort the committee members.
         let candidates = self.sorted_members();
         // Determine the leader of the previous round.
-        for (candidate, (stake, _)) in candidates {
+        for (candidate, (_, stake, _)) in candidates {
             // Increment the current stake index by the candidate's stake.
             current_stake_index = current_stake_index.saturating_add(stake);
             // If the current stake index is greater than or equal to the stake index,
@@ -196,11 +201,18 @@ impl<N: Network> Committee<N> {
     /// Returns the committee members sorted by stake in decreasing order.
     /// For members with matching stakes, we further sort by their address' x-coordinate in decreasing order.
     /// Note: This ensures the method returns a deterministic result that is SNARK-friendly.
-    fn sorted_members(&self) -> indexmap::map::IntoIter<Address<N>, (u64, bool)> {
+    fn sorted_members(&self) -> indexmap::map::IntoIter<Address<N>, (u8, u64, bool)> {
         let members = self.members.clone();
-        members.sorted_unstable_by(|address1, stake1, address2, stake2| {
+        members.sorted_unstable_by(|address1, stake1: &(u8, u64, bool), address2, stake2| {
             // Sort by stake in decreasing order.
-            let cmp = stake2.cmp(stake1);
+            let cmp = if stake2.1 > stake1.1 {
+                Ordering::Greater
+            } else if stake2.1 == stake1.1 {
+                Ordering::Equal
+            } else {
+                Ordering::Less
+            };
+
             // If the stakes are equal, sort by x-coordinate in decreasing order.
             if cmp == Ordering::Equal { address2.to_x_coordinate().cmp(&address1.to_x_coordinate()) } else { cmp }
         })
@@ -209,9 +221,9 @@ impl<N: Network> Committee<N> {
 
 impl<N: Network> Committee<N> {
     /// Compute the total stake of the given members.
-    fn compute_total_stake(members: &IndexMap<Address<N>, (u64, bool)>) -> Result<u64> {
+    fn compute_total_stake(members: &IndexMap<Address<N>, (u8, u64, bool)>) -> Result<u64> {
         let mut power = 0u64;
-        for (stake, _) in members.values() {
+        for (_, stake, _) in members.values() {
             // Accumulate the stake, checking for overflow.
             power = match power.checked_add(*stake) {
                 Some(power) => power,
@@ -260,7 +272,7 @@ pub mod test_helpers {
         let mut members = IndexMap::new();
         for _ in 0..num_members {
             let is_open = rng.gen();
-            members.insert(Address::<CurrentNetwork>::new(rng.gen()), (2 * MIN_VALIDATOR_STAKE, is_open));
+            members.insert(Address::<CurrentNetwork>::new(rng.gen()), (0u8, 2 * MIN_VALIDATOR_STAKE, is_open));
         }
         // Return the committee.
         Committee::<CurrentNetwork>::new(round, members).unwrap()
@@ -276,7 +288,7 @@ pub mod test_helpers {
         let mut committee_members = IndexMap::new();
         for member in members {
             let is_open = rng.gen();
-            committee_members.insert(member, (2 * MIN_VALIDATOR_STAKE, is_open));
+            committee_members.insert(member, (0u8, 2 * MIN_VALIDATOR_STAKE, is_open));
         }
         // Return the committee.
         Committee::<CurrentNetwork>::new(round, committee_members).unwrap()
@@ -294,18 +306,18 @@ pub mod test_helpers {
         // Sample the members.
         let mut members = IndexMap::new();
         // Add in the minimum and maximum staked nodes.
-        members.insert(Address::<CurrentNetwork>::new(rng.gen()), (MIN_VALIDATOR_STAKE, false));
+        members.insert(Address::<CurrentNetwork>::new(rng.gen()), (0u8, MIN_VALIDATOR_STAKE, false));
         while members.len() < num_members as usize - 1 {
             loop {
                 let stake = MIN_VALIDATOR_STAKE as f64 + range * distribution.sample(rng);
                 if stake >= MIN_VALIDATOR_STAKE as f64 && stake <= MAX_STAKE as f64 {
                     let is_open = rng.gen();
-                    members.insert(Address::<CurrentNetwork>::new(rng.gen()), (stake as u64, is_open));
+                    members.insert(Address::<CurrentNetwork>::new(rng.gen()), (0u8, stake as u64, is_open));
                     break;
                 }
             }
         }
-        members.insert(Address::<CurrentNetwork>::new(rng.gen()), (MAX_STAKE, false));
+        members.insert(Address::<CurrentNetwork>::new(rng.gen()), (0u8, MAX_STAKE, false));
         // Return the committee.
         Committee::<CurrentNetwork>::new(1, members).unwrap()
     }
@@ -397,8 +409,8 @@ mod tests {
         println!("sorted_members: {}ms", timer.elapsed().as_millis());
         // Check that the members are sorted based on our sorting criteria.
         for i in 0..sorted_members.len() - 1 {
-            let (address1, (stake1, _)) = sorted_members[i];
-            let (address2, (stake2, _)) = sorted_members[i + 1];
+            let (address1, (_, stake1, _)) = sorted_members[i];
+            let (address2, (_, stake2, _)) = sorted_members[i + 1];
             assert!(stake1 >= stake2);
             if stake1 == stake2 {
                 assert!(address1.to_x_coordinate() > address2.to_x_coordinate());
diff --git a/parameters/src/testnet3/mod.rs b/parameters/src/testnet3/mod.rs
index 403957745..ae2d5be80 100644
--- a/parameters/src/testnet3/mod.rs
+++ b/parameters/src/testnet3/mod.rs
@@ -73,6 +73,9 @@ impl_local!(ClaimUnbondPublicVerifier, "resources/", "claim_unbond_public", "ver
 // SetValidatorState
 impl_remote!(SetValidatorStateProver, REMOTE_URL, "resources/", "set_validator_state", "prover");
 impl_local!(SetValidatorStateVerifier, "resources/", "set_validator_state", "verifier");
+// SetValidatorCommission
+impl_remote!(SetValidatorCommissionProver, REMOTE_URL, "resources/", "set_validator_commission", "prover");
+impl_local!(SetValidatorCommissionVerifier, "resources/", "set_validator_commission", "verifier");
 // TransferPrivate
 impl_remote!(TransferPrivateProver, REMOTE_URL, "resources/", "transfer_private", "prover");
 impl_local!(TransferPrivateVerifier, "resources/", "transfer_private", "verifier");
@@ -108,6 +111,7 @@ macro_rules! insert_credit_keys {
             $crate::insert_key!($map, string, $type<$network>, ("unbond_delegator_as_validator", $crate::testnet3::[<UnbondDelegatorAsValidator $variant>]::load_bytes()));
             $crate::insert_key!($map, string, $type<$network>, ("claim_unbond_public", $crate::testnet3::[<ClaimUnbondPublic $variant>]::load_bytes()));
             $crate::insert_key!($map, string, $type<$network>, ("set_validator_state", $crate::testnet3::[<SetValidatorState $variant>]::load_bytes()));
+            $crate::insert_key!($map, string, $type<$network>, ("set_validator_commission", $crate::testnet3::[<SetValidatorCommission $variant>]::load_bytes()));
             $crate::insert_key!($map, string, $type<$network>, ("transfer_private", $crate::testnet3::[<TransferPrivate $variant>]::load_bytes()));
             $crate::insert_key!($map, string, $type<$network>, ("transfer_public", $crate::testnet3::[<TransferPublic $variant>]::load_bytes()));
             $crate::insert_key!($map, string, $type<$network>, ("transfer_private_to_public", $crate::testnet3::[<TransferPrivateToPublic $variant>]::load_bytes()));
@@ -165,6 +169,7 @@ mod tests {
             .expect("Failed to load unbond_delegator_as_validator verifier");
         ClaimUnbondPublicVerifier::load_bytes().expect("Failed to load claim_unbond_public verifier");
         SetValidatorStateVerifier::load_bytes().expect("Failed to load set_validator_state verifier");
+        SetValidatorCommissionVerifier::load_bytes().expect("Failed to load set_validator_commission verifier");
         TransferPrivateVerifier::load_bytes().expect("Failed to load transfer_private verifier");
         TransferPublicVerifier::load_bytes().expect("Failed to load transfer_public verifier");
         TransferPrivateToPublicVerifier::load_bytes().expect("Failed to load transfer_private_to_public verifier");
diff --git a/synthesizer/program/src/resources/credits.aleo b/synthesizer/program/src/resources/credits.aleo
index 534bb4ce8..3c7b0f5c0 100644
--- a/synthesizer/program/src/resources/credits.aleo
+++ b/synthesizer/program/src/resources/credits.aleo
@@ -27,6 +27,8 @@ mapping committee:
 
 // The `committee_state` struct tracks the total stake of the validator, and whether they are open to stakers.
 struct committee_state:
+    // The commission rate set by validators.
+    commission as u8;
     // The amount of microcredits bonded to the validator, by the validator and its delegators.
     microcredits as u64;
     // The boolean flag indicating if the validator is open to stakers.
@@ -45,6 +47,8 @@ mapping bonded:
 struct bond_state:
     // The address of the validator.
     validator as address;
+    // The commission rate set by validators.
+    commission as u8;
     // The amount of microcredits that are currently bonded to the specified validator.
     microcredits as u64;
 
@@ -126,7 +130,7 @@ finalize bond_public:
 
     // Construct the initial committee state.
     // Note: We set the initial 'is_open' state to 'true'.
-    cast 0u64 true into r4 as committee_state;
+    cast 0u8 0u64 true into r4 as committee_state;
     // Retrieve the committee state of the specified validator.
     get.or_use committee[r0] r4 into r5;
     // Ensure that the validator is open to stakers.
@@ -135,12 +139,12 @@ finalize bond_public:
     // Increment the stake for the specified validator.
     add r5.microcredits r2 into r6;
     // Construct the updated committee state.
-    cast r6 r5.is_open into r7 as committee_state;
+    cast r5.commission r6 r5.is_open into r7 as committee_state;
 
     /* Bonded */
 
     // Construct the initial bond state.
-    cast r1 0u64 into r8 as bond_state;
+    cast r1 r5.commission 0u64 into r8 as bond_state;
     // Get the bond state for the caller, or default to the initial bond state.
     get.or_use bonded[r0] r8 into r9;
     // Enforce the validator matches in the bond state.
@@ -153,8 +157,8 @@ finalize bond_public:
     // Enforce the amount is at least one million credits.
     assert.eq r11 true;
 
-    // Construct the updated bond state.
-    cast r1 r10 into r12 as bond_state;
+    // Construct the updated bond state, add bond use current commission.
+    cast r1 r5.commission r10 into r12 as bond_state;
 
     /* Account */
 
@@ -197,12 +201,12 @@ finalize bond_public:
     // Increment the stake for the specified validator.
     add r16.microcredits r2 into r17;
     // Construct the updated committee state.
-    cast r17 r16.is_open into r18 as committee_state;
+    cast r16.commission r17 r16.is_open into r18 as committee_state;
 
     /* Bonded */
 
     // Construct the initial bond state.
-    cast r1 0u64 into r19 as bond_state;
+    cast r1 r16.commission 0u64 into r19 as bond_state;
     // Get the bond state for the caller, or default to the initial bond state.
     get.or_use bonded[r0] r19 into r20;
     // Enforce the validator matches in the bond state.
@@ -216,7 +220,7 @@ finalize bond_public:
     assert.eq r22 true;
 
     // Construct the updated bond state.
-    cast r1 r21 into r23 as bond_state;
+    cast r1 r16.commission r21 into r23 as bond_state;
 
     /* Account */
 
@@ -241,6 +245,7 @@ finalize bond_public:
 /**********************************************************************************************************************/
 
 // This function allows any staker to unbond their microcredits from a validator.
+// The commission will be calculated as a percentage of the total rewards and paid to the validator.
 // The corresponding functions for 'unbond_public' is 'claim_unbond_public'.
 function unbond_public:
     // Input the amount of microcredits to unbond.
@@ -311,14 +316,14 @@ finalize unbond_public:
     /* Committee */
 
     // Construct the updated committee state.
-    cast r7 r6.is_open into r11 as committee_state;
+    cast r6.commission r7 r6.is_open into r11 as committee_state;
     // Update the committee state for the validator.
     set r11 into committee[r0];
 
     /* Bonded */
 
     // Construct the updated bond state.
-    cast r0 r9 into r12 as bond_state;
+    cast r0 r6.commission r9 into r12 as bond_state;
     // Update the bond state for the validator.
     set r12 into bonded[r0];
 
@@ -397,14 +402,14 @@ finalize unbond_public:
     // Decrement the stake for the specified validator.
     sub r20.microcredits r1 into r21;
     // Construct the updated committee state.
-    cast r21 r20.is_open into r22 as committee_state;
+    cast r20.commission r21 r20.is_open into r22 as committee_state;
     // Update the stake for the specified validator.
     set r22 into committee[r17.validator];
 
     /* Bonded */
 
     // Construct the updated bond state.
-    cast r17.validator r18 into r23 as bond_state;
+    cast r17.validator r17.commission r18 into r23 as bond_state;
     // Update the bond state for the caller.
     set r23 into bonded[r0];
 
@@ -434,7 +439,7 @@ finalize unbond_public:
     // Decrement the stake for the specified validator.
     sub r26.microcredits r17.microcredits into r27;
     // Construct the updated committee state.
-    cast r27 r26.is_open into r28 as committee_state;
+    cast r26.commission r27 r26.is_open into r28 as committee_state;
     // Update the stake for the specified validator.
     set r28 into committee[r17.validator];
 
@@ -503,7 +508,7 @@ finalize unbond_delegator_as_validator:
     // Decrement the stake for the specified validator.
     sub r2.microcredits r4.microcredits into r5;
     // Construct the updated committee state.
-    cast r5 r2.is_open into r6 as committee_state;
+    cast r2.commission r5 r2.is_open into r6 as committee_state;
 
     /* End Committee */
 
@@ -595,7 +600,39 @@ finalize set_validator_state:
     get committee[r0] into r2;
 
     // Construct the updated committee state.
-    cast r2.microcredits r1 into r3 as committee_state;
+    cast r2.commission r2.microcredits r1 into r3 as committee_state;
+    // Update the committee state for the specified validator.
+    set r3 into committee[r0];
+
+/**********************************************************************************************************************/
+
+// Setting or updating the commission rate for validators.
+// Updata commission rate, new delegators or additional delegations will be calculated based on the latest commission percentage value. 
+// Previous delegators will continue to have their commissions calculated based on the original commission percentage value they had.
+// Commissions will be collected during the unbond_public and unbond_delegator_as_validator operations.
+function set_validator_commission:
+    // Input the 'commission' value.
+    input r0 as u8.public;
+    lte r0 100u8 into r1;
+    assert.eq r1 true;
+
+    // Set the validator's commission 
+    async set_validator_commission self.caller r0 into r2;
+    // Output the finalize future.
+    output r2 as credits.aleo/set_validator_commission.future;
+
+finalize set_validator_commission:
+    // Input the validator's address.
+    input r0 as address.public;
+    // Input the 'commission' state.
+    input r1 as u8.public;
+
+    // Get the committee state for the specified validator.
+    // If the validator does not exist, this finalize scope will fail.
+    get committee[r0] into r2;
+
+    // Construct the updated committee state.
+    cast r1 r2.microcredits r2.is_open into r3 as committee_state;
     // Update the committee state for the specified validator.
     set r3 into committee[r0];
 
diff --git a/synthesizer/src/vm/finalize.rs b/synthesizer/src/vm/finalize.rs
index 29f239e71..b89eae56f 100644
--- a/synthesizer/src/vm/finalize.rs
+++ b/synthesizer/src/vm/finalize.rs
@@ -678,9 +678,9 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
                     // Initialize the stakers.
                     let mut stakers = IndexMap::with_capacity(committee.members().len());
                     // Iterate over the committee members.
-                    for (validator, (microcredits, _)) in committee.members() {
+                    for (validator, (commission, microcredits, _)) in committee.members() {
                         // Insert the validator into the stakers.
-                        stakers.insert(*validator, (*validator, *microcredits));
+                        stakers.insert(*validator, (*validator, *commission, *microcredits));
                     }
 
                     // Construct the next committee map and next bonded map.
diff --git a/synthesizer/src/vm/helpers/committee.rs b/synthesizer/src/vm/helpers/committee.rs
index d44c4eafd..c1b85e4d3 100644
--- a/synthesizer/src/vm/helpers/committee.rs
+++ b/synthesizer/src/vm/helpers/committee.rs
@@ -19,7 +19,7 @@ use console::{
     network::Network,
     prelude::{cfg_into_iter, cfg_iter, cfg_reduce},
     program::{Identifier, Literal, Plaintext, Value},
-    types::{Boolean, U64},
+    types::{Boolean, U64, U8},
 };
 use ledger_committee::Committee;
 
@@ -36,6 +36,7 @@ pub fn committee_map_into_committee<N: Network>(
     committee_map: Vec<(Plaintext<N>, Value<N>)>,
 ) -> Result<Committee<N>> {
     // Prepare the identifiers.
+    let commission_identifier = Identifier::from_str("commission")?;
     let microcredits_identifier = Identifier::from_str("microcredits")?;
     let is_open_identifier = Identifier::from_str("is_open")?;
 
@@ -51,6 +52,11 @@ pub fn committee_map_into_committee<N: Network>(
             // Extract the committee state from the value.
             match value {
                 Value::Plaintext(Plaintext::Struct(state, _)) => {
+                    // Extract the commission from the value.
+                    let commission = match state.get(&commission_identifier) {
+                        Some(Plaintext::Literal(Literal::U8(commission), _)) => **commission,
+                        _ => bail!("Invalid committee state (missing commission) - {value}"),
+                    };
                     // Extract the microcredits from the value.
                     let microcredits = match state.get(&microcredits_identifier) {
                         Some(Plaintext::Literal(Literal::U64(microcredits), _)) => **microcredits,
@@ -62,7 +68,7 @@ pub fn committee_map_into_committee<N: Network>(
                         _ => bail!("Invalid committee state (missing boolean) - {value}"),
                     };
                     // Return the committee state.
-                    Ok((*address, (microcredits, is_open)))
+                    Ok((*address, (commission, microcredits, is_open)))
                 }
                 _ => bail!("Invalid committee value (missing struct) - {value}"),
             }
@@ -76,9 +82,10 @@ pub fn committee_map_into_committee<N: Network>(
 /// Returns the stakers given the bonded map from finalize storage.
 pub fn bonded_map_into_stakers<N: Network>(
     bonded_map: Vec<(Plaintext<N>, Value<N>)>,
-) -> Result<IndexMap<Address<N>, (Address<N>, u64)>> {
+) -> Result<IndexMap<Address<N>, (Address<N>, u8, u64)>> {
     // Prepare the identifiers.
     let validator_identifier = Identifier::from_str("validator")?;
+    let commission_identifier = Identifier::from_str("commission")?;
     let microcredits_identifier = Identifier::from_str("microcredits")?;
 
     // Convert the given key and value into a staker entry.
@@ -96,13 +103,18 @@ pub fn bonded_map_into_stakers<N: Network>(
                     Some(Plaintext::Literal(Literal::Address(validator), _)) => *validator,
                     _ => bail!("Invalid bonded state (missing validator) - {value}"),
                 };
+                // Extract the commission from the value.
+                let commission = match state.get(&commission_identifier) {
+                    Some(Plaintext::Literal(Literal::U8(commission), _)) => **commission,
+                    _ => bail!("Invalid bonded state (missing commission) - {value}"),
+                };
                 // Extract the microcredits from the value.
                 let microcredits = match state.get(&microcredits_identifier) {
                     Some(Plaintext::Literal(Literal::U64(microcredits), _)) => **microcredits,
                     _ => bail!("Invalid bonded state (missing microcredits) - {value}"),
                 };
                 // Return the bonded state.
-                Ok((address, (validator, microcredits)))
+                Ok((address, (validator, commission, microcredits)))
             }
             _ => bail!("Invalid bonded value (missing struct) - {value}"),
         }
@@ -115,11 +127,11 @@ pub fn bonded_map_into_stakers<N: Network>(
 /// Checks that the given committee from committee storage matches the given stakers.
 pub fn ensure_stakers_matches<N: Network>(
     committee: &Committee<N>,
-    stakers: &IndexMap<Address<N>, (Address<N>, u64)>,
+    stakers: &IndexMap<Address<N>, (Address<N>, u8, u64)>,
 ) -> Result<()> {
     // Construct the validator map.
     let validator_map: IndexMap<_, _> = cfg_reduce!(
-        cfg_into_iter!(stakers).map(|(_, (validator, microcredits))| indexmap! {*validator => *microcredits}),
+        cfg_into_iter!(stakers).map(|(_, (validator, _, microcredits))| indexmap! {*validator => *microcredits}),
         || IndexMap::new(),
         |mut acc, e| {
             for (validator, microcredits) in e {
@@ -143,7 +155,7 @@ pub fn ensure_stakers_matches<N: Network>(
     ensure!(committee.total_stake() == total_microcredits, "Committee and validator map total stake do not match");
 
     // Iterate over the committee and ensure the committee and validators match.
-    for (validator, (microcredits, _)) in committee.members() {
+    for (validator, (_, microcredits, _)) in committee.members() {
         let candidate_microcredits = validator_map.get(validator);
         ensure!(candidate_microcredits.is_some(), "A validator is missing in finalize storage");
         ensure!(
@@ -159,11 +171,11 @@ pub fn ensure_stakers_matches<N: Network>(
 pub fn to_next_committee<N: Network>(
     current_committee: &Committee<N>,
     next_round: u64,
-    next_stakers: &IndexMap<Address<N>, (Address<N>, u64)>,
+    next_stakers: &IndexMap<Address<N>, (Address<N>, u8, u64)>,
 ) -> Result<Committee<N>> {
     // Construct the validator map.
     let validator_map: IndexMap<_, _> = cfg_reduce!(
-        cfg_into_iter!(next_stakers).map(|(_, (validator, microcredits))| indexmap! {*validator => *microcredits}),
+        cfg_into_iter!(next_stakers).map(|(_, (validator, _, microcredits))| indexmap! {*validator => *microcredits}),
         || IndexMap::new(),
         |mut acc, e| {
             for (validator, microcredits) in e {
@@ -178,7 +190,7 @@ pub fn to_next_committee<N: Network>(
     let mut members = IndexMap::with_capacity(validator_map.len());
     // Iterate over the validators.
     for (validator, microcredits) in validator_map {
-        members.insert(validator, (microcredits, current_committee.is_committee_member_open(validator)));
+        members.insert(validator, (current_committee.get_commission(validator), microcredits, current_committee.is_committee_member_open(validator)));
     }
     // Return the next committee.
     Committee::new(next_round, members)
@@ -187,18 +199,20 @@ pub fn to_next_committee<N: Network>(
 /// Returns the committee map and bonded map, given the committee and stakers.
 pub fn to_next_commitee_map_and_bonded_map<N: Network>(
     next_committee: &Committee<N>,
-    next_stakers: &IndexMap<Address<N>, (Address<N>, u64)>,
+    next_stakers: &IndexMap<Address<N>, (Address<N>, u8, u64)>,
 ) -> (Vec<(Plaintext<N>, Value<N>)>, Vec<(Plaintext<N>, Value<N>)>) {
     // Prepare the identifiers.
     let validator_identifier = Identifier::from_str("validator").expect("Failed to parse 'validator'");
+    let commission_identifier = Identifier::from_str("commission").expect("Failed to parse 'commission'");
     let microcredits_identifier = Identifier::from_str("microcredits").expect("Failed to parse 'microcredits'");
     let is_open_identifier = Identifier::from_str("is_open").expect("Failed to parse 'is_open'");
 
     // Construct the committee map.
     let committee_map = cfg_iter!(next_committee.members())
-        .map(|(validator, (microcredits, is_open))| {
+        .map(|(validator, (commission, microcredits, is_open))| {
             // Construct the committee state.
             let committee_state = indexmap! {
+                commission_identifier => Plaintext::from(Literal::U8(U8::new(*commission))),
                 microcredits_identifier => Plaintext::from(Literal::U64(U64::new(*microcredits))),
                 is_open_identifier => Plaintext::from(Literal::Boolean(Boolean::new(*is_open))),
             };
@@ -212,10 +226,11 @@ pub fn to_next_commitee_map_and_bonded_map<N: Network>(
 
     // Construct the bonded map.
     let bonded_map = cfg_iter!(next_stakers)
-        .map(|(staker, (validator, microcredits))| {
+        .map(|(staker, (validator, commission, microcredits))| {
             // Construct the bonded state.
             let bonded_state = indexmap! {
                 validator_identifier => Plaintext::from(Literal::Address(*validator)),
+                commission_identifier => Plaintext::from(Literal::U8(U8::new(*commission))),
                 microcredits_identifier => Plaintext::from(Literal::U64(U64::new(*microcredits))),
             };
             // Return the bonded state.
diff --git a/synthesizer/src/vm/helpers/rewards.rs b/synthesizer/src/vm/helpers/rewards.rs
index ae5f9d4fb..37d196eb8 100644
--- a/synthesizer/src/vm/helpers/rewards.rs
+++ b/synthesizer/src/vm/helpers/rewards.rs
@@ -16,12 +16,15 @@ use console::{account::Address, network::prelude::*};
 use ledger_committee::{Committee, MIN_DELEGATOR_STAKE};
 
 use indexmap::IndexMap;
+use parking_lot::Mutex;
 
 #[cfg(not(feature = "serial"))]
 use rayon::prelude::*;
 
 /// A safety bound (sanity-check) for the coinbase reward.
 const MAX_COINBASE_REWARD: u64 = ledger_block::MAX_COINBASE_REWARD; // Coinbase reward at block 1.
+const MAX_PERCENT: u128 = 100u128; 
+const MIN_PERCENT: u64 = 0u64; 
 
 /// Returns the updated stakers reflecting the staking rewards for the given committee and block reward.
 /// The staking reward is defined as: `block_reward * stake / total_stake`.
@@ -34,27 +37,30 @@ const MAX_COINBASE_REWARD: u64 = ledger_block::MAX_COINBASE_REWARD; // Coinbase
 /// since our security model adheres to 3f+1, where f=1. As such, we tolerate Byzantine behavior
 /// up to 33% of the total stake.
 pub fn staking_rewards<N: Network>(
-    stakers: &IndexMap<Address<N>, (Address<N>, u64)>,
+    stakers: &IndexMap<Address<N>, (Address<N>, u8, u64)>,
     committee: &Committee<N>,
     block_reward: u64,
-) -> IndexMap<Address<N>, (Address<N>, u64)> {
+) -> IndexMap<Address<N>, (Address<N>, u8, u64)> {
     // If the list of stakers is empty, there is no stake, or the block reward is 0, return the stakers.
     if stakers.is_empty() || committee.total_stake() == 0 || block_reward == 0 {
         return stakers.clone();
     }
 
+    // let total_commission = AtomicU64::new(0);
+    let map_commission: Mutex<IndexMap<Address<N>, u64>> = Default::default();
+
     // Compute the updated stakers.
-    cfg_iter!(stakers)
-        .map(|(staker, (validator, stake))| {
+    let stakers: IndexMap<Address<N>, (Address<N>, u8, u64)> = cfg_iter!(stakers)
+        .map(|(staker, (validator, commission, stake))| {
             // If the validator has more than 25% of the total stake, skip the staker.
             if committee.get_stake(*validator) > committee.total_stake().saturating_div(4) {
                 trace!("Validator {validator} has more than 25% of the total stake - skipping {staker}");
-                return (*staker, (*validator, *stake));
+                return (*staker, (*validator, *commission, *stake));
             }
             // If the staker has less than the minimum required stake, skip the staker.
             if *stake < MIN_DELEGATOR_STAKE {
                 trace!("Staker has less than {MIN_DELEGATOR_STAKE} microcredits - skipping {staker}");
-                return (*staker, (*validator, *stake));
+                return (*staker, (*validator, *commission, *stake));
             }
 
             // Compute the numerator.
@@ -67,13 +73,43 @@ pub fn staking_rewards<N: Network>(
             // Ensure the staking reward is within a safe bound.
             if quotient > MAX_COINBASE_REWARD as u128 {
                 error!("Staking reward ({quotient}) is too large - skipping {staker}");
-                return (*staker, (*validator, *stake));
+                return (*staker, (*validator, *commission, *stake));
             }
+
+            let mut commission_u128 = *commission as u128;
+            if commission_u128 > MAX_PERCENT {
+                commission_u128 = MAX_PERCENT
+            }
+            // The net income for a delegator
+            let net_income = quotient.saturating_mul(MAX_PERCENT - commission_u128).saturating_div(MAX_PERCENT);
+            let staker_commission = quotient.saturating_sub(net_income);
             // Cast the staking reward as a u64.
             // Note: This '.expect' is guaranteed to be safe, as we ensure the quotient is within a safe bound.
-            let staking_reward = u64::try_from(quotient).expect("Staking reward is too large");
+            let staking_reward = u64::try_from(net_income).expect("Staking reward is too large");
+            let commission_reward = u64::try_from(staker_commission).expect("Staking reward is too large");
+            let mut lock_map_commission = map_commission.lock();
+            let v = lock_map_commission.get(validator).unwrap_or(&MIN_PERCENT);
+            let total_commission_reward = *v;
+
+            lock_map_commission.insert(*validator, total_commission_reward + commission_reward);
+
+            // total_commission.fetch_add(commission_reward, Ordering::Relaxed);
             // Return the staker and the updated stake.
-            (*staker, (*validator, stake.saturating_add(staking_reward)))
+            (*staker, (*validator, *commission, stake.saturating_add(staking_reward)))
+        })
+        .collect();
+
+    cfg_iter!(stakers)
+        .map(|(staker, (validator, commission, stake))| {
+            if staker != validator {
+                // Return the staker and the updated stake.
+                (*staker, (*validator, *commission, *stake))
+            } else {
+                let total_map_commission = map_commission.lock();
+                let v = total_map_commission.get(validator).unwrap_or(&MIN_PERCENT);
+                let total_value = *v;
+                (*staker, (*validator, *commission, stake.saturating_add(total_value)))
+            }
         })
         .collect()
 }
diff --git a/synthesizer/src/vm/mod.rs b/synthesizer/src/vm/mod.rs
index 237ed5f3c..0e3414767 100644
--- a/synthesizer/src/vm/mod.rs
+++ b/synthesizer/src/vm/mod.rs
@@ -191,10 +191,10 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
 
         // Construct the committee members.
         let members = indexmap::indexmap! {
-            Address::try_from(private_keys[0])? => (ledger_committee::MIN_VALIDATOR_STAKE, true),
-            Address::try_from(private_keys[1])? => (ledger_committee::MIN_VALIDATOR_STAKE, true),
-            Address::try_from(private_keys[2])? => (ledger_committee::MIN_VALIDATOR_STAKE, true),
-            Address::try_from(private_keys[3])? => (ledger_committee::MIN_VALIDATOR_STAKE, true),
+            Address::try_from(private_keys[0])? => (0u8, ledger_committee::MIN_VALIDATOR_STAKE, true),
+            Address::try_from(private_keys[1])? => (0u8, ledger_committee::MIN_VALIDATOR_STAKE, true),
+            Address::try_from(private_keys[2])? => (0u8, ledger_committee::MIN_VALIDATOR_STAKE, true),
+            Address::try_from(private_keys[3])? => (0u8, ledger_committee::MIN_VALIDATOR_STAKE, true),
         };
         // Construct the committee.
         let committee = Committee::<N>::new_genesis(members)?;

Test Cases

Build & Run

git clone https://github.com/SoterARC0038/snarkOS.git
./devnet.sh
# Enter the total number of validators (default: 4): 4
# Do you want to run 'cargo install --path .' to build the binary? (y/n, default: y): y
# Do you want to clear the existing ledger logs? (y/n, default: n): y

Validators

• APrivateKey1zkp8CZNn3yeCseEtxuVPbDCwSyhGW6yZKUYKfgXmcpoGPWH aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px
• APrivateKey1zkp2RWGDcde3efb89rjhME1VYA8QMxcxep5DShNBR6n8Yjh aleo1s3ws5tra87fjycnjrwsjcrnw2qxr8jfqqdugnf0xzqqw29q9m5pqem2u4t
• APrivateKey1zkp2GUmKbVsuc1NSj28pa1WTQuZaK5f1DQJAT6vPcHyWokG - aleo1ashyu96tjwe63u0gtnnv8z5lhapdu4l5pjsl2kha7fv7hvz2eqxs5dz0rg
• APrivateKey1zkpBjpEgLo4arVUkQmcLdKQMiAKGaHAQVVwmF8HQby8vdYs aleo12ux3gdauck0v60westgcpqj7v8rrcr3v346e4jtq04q7kkt22czsh808v2

Create Test Addresssnarkos account new

address for validator

1. validator1

Private Key APrivateKey1zkp7XpQVgvYU5BvJWz5r1RMLVDW2sFdeeKmNeZ7b2rXCfAv
View Key AViewKey1fMWPM14rPbkSWRJMTaWexGGyjynjyNFSCemHoRx5UoWY
Address aleo1mvnqajapz7pfk4gzu6feptyukdtvx9tgguwu78pc627u727vwyyqk7z893

2. validator2

Private Key APrivateKey1zkpGA2HBjpAoGaqUwPt6tGyN4qsnGBCLtwd1Qsy6wP1m1sJ
View Key AViewKey1e8wHruBhgTpL3rCfCmWPG2kVX5fTUfqSRdHUo4URrELP
Address aleo1dhu8eqmw9c3r6epca9p3ypshek5whmccz3kesyj5uy2jkyu7cuyq0qdfpc

address for delegator

1. delegator1

Private Key APrivateKey1zkpHZfW4B35P69CbqJx1URWPnNZgE9yyN9XTUFrTBzbQV6c
View Key AViewKey1tGkGsWVT8vht9s1YLvBcpV7cXZuHSDYbGSLGyEczqW8h
Address aleo1nkn799uj6v6d2dsv7xjp05swkw8dg44c62e28mptdxz9lkyunszsx7tmcv

2. delegator2

Private Key APrivateKey1zkp8aDjEp9f7vgCy58BHateQnSXmna7Gs1TC139t8GVsRiu
View Key AViewKey1iZ4FDms57Rjqqc1d7vXtA3sQMgG8kSRzyUp7bn9W29ao
Address aleo1zmz7wqhv4zad0j0ll6fl7z4ev9tpw4ycup2t74l9m7dl9tjxdsgqd9g6gw

3. delegator3

Private Key APrivateKey1zkp2fAhJBwVHgaXriFtdh1WNA2cx5F4NjBhX2w8nuyN2Fr8
View Key AViewKey1nqv9AFdjXSp5FSmTdto3Y5WUHSonrDKmRf4K5GUpHzJK
Address aleo13stxlgsae3qrr4exepj0zcx8dlq4qmyfzz8kc6t6uczseh5df5fqy3zmn3

Transfer_public 200w

1. snarkos developer execute "credits.aleo" transfer_public "aleo1mvnqajapz7pfk4gzu6feptyukdtvx9tgguwu78pc627u727vwyyqk7z893" 2000000000000u64 --private-key "APrivateKey1zkp8CZNn3yeCseEtxuVPbDCwSyhGW6yZKUYKfgXmcpoGPWH" --query "http://127.0.0.1:3033" --broadcast "http://127.0.0.1:3033/testnet3/transaction/broadcast" --priority-fee 1000000

2. snarkos developer execute "credits.aleo" transfer_public "aleo1dhu8eqmw9c3r6epca9p3ypshek5whmccz3kesyj5uy2jkyu7cuyq0qdfpc" 2000000000000u64 --private-key "APrivateKey1zkp8CZNn3yeCseEtxuVPbDCwSyhGW6yZKUYKfgXmcpoGPWH" --query "http://127.0.0.1:3033" --broadcast "http://127.0.0.1:3033/testnet3/transaction/broadcast" --priority-fee 1000000

3. snarkos developer execute "credits.aleo" transfer_public "aleo1nkn799uj6v6d2dsv7xjp05swkw8dg44c62e28mptdxz9lkyunszsx7tmcv" 2000000000000u64 --private-key "APrivateKey1zkp8CZNn3yeCseEtxuVPbDCwSyhGW6yZKUYKfgXmcpoGPWH" --query "http://127.0.0.1:3033" --broadcast "http://127.0.0.1:3033/testnet3/transaction/broadcast" --priority-fee 1000000

4. snarkos developer execute "credits.aleo" transfer_public "aleo1zmz7wqhv4zad0j0ll6fl7z4ev9tpw4ycup2t74l9m7dl9tjxdsgqd9g6gw" 2000000000000u64 --private-key "APrivateKey1zkp8CZNn3yeCseEtxuVPbDCwSyhGW6yZKUYKfgXmcpoGPWH" --query "http://127.0.0.1:3033" --broadcast "http://127.0.0.1:3033/testnet3/transaction/broadcast" --priority-fee 1000000

5. snarkos developer execute "credits.aleo" transfer_public "aleo13stxlgsae3qrr4exepj0zcx8dlq4qmyfzz8kc6t6uczseh5df5fqy3zmn3" 2000000000000u64 --private-key "APrivateKey1zkp8CZNn3yeCseEtxuVPbDCwSyhGW6yZKUYKfgXmcpoGPWH" --query "http://127.0.0.1:3033" --broadcast "http://127.0.0.1:3033/testnet3/transaction/broadcast" --priority-fee 1000000

Validator bond

1. validator1 bond

   snarkos developer execute "credits.aleo" bond_public "aleo1mvnqajapz7pfk4gzu6feptyukdtvx9tgguwu78pc627u727vwyyqk7z893" 1000000000000u64 --private-key "APrivateKey1zkp7XpQVgvYU5BvJWz5r1RMLVDW2sFdeeKmNeZ7b2rXCfAv" --query "http://127.0.0.1:3033" --broadcast "http://127.0.0.1:3033/testnet3/transaction/broadcast" --priority-fee 1000000

2. Validator2 bond

   snarkos developer execute "credits.aleo" bond_public "aleo1dhu8eqmw9c3r6epca9p3ypshek5whmccz3kesyj5uy2jkyu7cuyq0qdfpc" 1000000000000u64 --private-key "APrivateKey1zkpGA2HBjpAoGaqUwPt6tGyN4qsnGBCLtwd1Qsy6wP1m1sJ" --query "http://127.0.0.1:3033" --broadcast "http://127.0.0.1:3033/testnet3/transaction/broadcast" --priority-fee 1000000

Set commission

1. validator1 commission set 100u8

   snarkos developer execute "credits.aleo" set_validator_commission 100u8 --private-key "APrivateKey1zkp7XpQVgvYU5BvJWz5r1RMLVDW2sFdeeKmNeZ7b2rXCfAv" --query "http://127.0.0.1:3033" --broadcast "http://127.0.0.1:3033/testnet3/transaction/broadcast" --priority-fee 1000000

2. validator2 commission set 50u8

   snarkos developer execute "credits.aleo" set_validator_commission 50u8 --private-key "APrivateKey1zkpGA2HBjpAoGaqUwPt6tGyN4qsnGBCLtwd1Qsy6wP1m1sJ" --query "http://127.0.0.1:3033" --broadcast "http://127.0.0.1:3033/testnet3/transaction/broadcast" --priority-fee 1000000

Delegator bond

1. delegator1 bond 100w to validator1

   snarkos developer execute "credits.aleo" bond_public "aleo1mvnqajapz7pfk4gzu6feptyukdtvx9tgguwu78pc627u727vwyyqk7z893" 1000000000000u64 --private-key "APrivateKey1zkpHZfW4B35P69CbqJx1URWPnNZgE9yyN9XTUFrTBzbQV6c" --query "http://127.0.0.1:3033" --broadcast "http://127.0.0.1:3033/testnet3/transaction/broadcast" --priority-fee 1000000

2. delegator2 bond 100w to validator2

   snarkos developer execute "credits.aleo" bond_public "aleo1dhu8eqmw9c3r6epca9p3ypshek5whmccz3kesyj5uy2jkyu7cuyq0qdfpc" 1000000000000u64 --private-key "APrivateKey1zkp8aDjEp9f7vgCy58BHateQnSXmna7Gs1TC139t8GVsRiu" --query "http://127.0.0.1:3033" --broadcast "http://127.0.0.1:3033/testnet3/transaction/broadcast" --priority-fee 1000000

3. Result

   • http://127.0.0.1:3033/testnet3/program/credits.aleo/mapping/bonded/aleo1nkn799uj6v6d2dsv7xjp05swkw8dg44c62e28mptdxz9lkyunszsx7tmcv，Delegator1 did not receive any profits, while Validator1 received all the profits.
   • http://127.0.0.1:3033/testnet3/program/credits.aleo/mapping/bonded/aleo1zmz7wqhv4zad0j0ll6fl7z4ev9tpw4ycup2t74l9m7dl9tjxdsgqd9g6gw，Delegator2 received 50% of the profits, while Validator2 received the other 50% of the profits.

Updata commission

1. validator2 updata 100 to 30

   snarkos developer execute "credits.aleo" set_validator_commission 30u8 --private-key "APrivateKey1zkp7XpQVgvYU5BvJWz5r1RMLVDW2sFdeeKmNeZ7b2rXCfAv" --query "http://127.0.0.1:3033" --broadcast "http://127.0.0.1:3033/testnet3/transaction/broadcast" --priority-fee 1000000

2. delegator bond 100w to validator1

   snarkos developer execute "credits.aleo" bond_public "aleo1mvnqajapz7pfk4gzu6feptyukdtvx9tgguwu78pc627u727vwyyqk7z893" 1000000000000u64 --private-key "APrivateKey1zkp2fAhJBwVHgaXriFtdh1WNA2cx5F4NjBhX2w8nuyN2Fr8" --query "http://127.0.0.1:3033" --broadcast "http://127.0.0.1:3033/testnet3/transaction/broadcast" --priority-fee 1000000

3. Result

   • http://127.0.0.1:3033/testnet3/program/credits.aleo/mapping/bonded/aleo1nkn799uj6v6d2dsv7xjp05swkw8dg44c62e28mptdxz9lkyunszsx7tmcv，Delegator1 did not receive any profits, while Validator1 received all the profits.
   • http://127.0.0.1:3033/testnet3/program/credits.aleo/mapping/bonded/aleo13stxlgsae3qrr4exepj0zcx8dlq4qmyfzz8kc6t6uczseh5df5fqy3zmn3，Delegator3 received 50% of the profits, while Validator1 received the other 50% of the profits.

Reference Implementations

Dependencies

Backwards Compatibility

Security & Compliance

References

[Sayan7388]

Wow great innovation team Aleo 🫶

[Delaw258]

good to be part of this

[gouravghosh02]

Great

[mefisto-sudo]

not bad

[naji1368]

good job

[Snapsheep]

Good

[rohitsenindia]

great use of staking aleo

[nicanal69]

Nice

…

On Wed, 24 Apr 2024, 16:20 lawrence olayiwola, ***@***.***> wrote: good to be part of this — Reply to this email directly, view it on GitHub <#52 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/BGLI5YASIYNWJTRT7AW6R2DY67ESLAVCNFSM6AAAAAA7RQO25SVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TEMJVGA2DA> . You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>

[nicanal69]

Nice