[Coinbase Go/No-Go] Bond balances in genesis block

ledger/block/src/ratify/bytes.rs

@@ -41,8 +41,22 @@ impl<N: Network> FromBytes for Ratify<N> {
                     // Insert the public balance.
                     public_balances.insert(address, amount);
                 }
+                // Read the number of bonded balances.
+                let num_bonded_balances: u16 = FromBytes::read_le(&mut reader)?;
+                // Read the bonded balances.
+                let mut bonded_balances = BondedBalances::with_capacity(num_bonded_balances as usize);
+                for _ in 0..num_bonded_balances {
+                    // Read the address.
+                    let address: Address<N> = FromBytes::read_le(&mut reader)?;
+                    // Read the validator address.
+                    let validator_address: Address<N> = FromBytes::read_le(&mut reader)?;
+                    // Read the amount.
+                    let amount: u64 = FromBytes::read_le(&mut reader)?;
+                    // Insert the bonded balance.
+                    bonded_balances.insert(address, (validator_address, amount));
+                }
                 // Return the ratify object.
-                Self::Genesis(committee, public_balances)
+                Self::Genesis(committee, public_balances, bonded_balances)
             }
             1 => {
                 // Read the amount.
@@ -69,14 +83,20 @@ impl<N: Network> ToBytes for Ratify<N> {
         1u8.write_le(&mut writer)?;
 
         match self {
-            Self::Genesis(committee, public_balances) => {
+            Self::Genesis(committee, public_balances, bonded_balances) => {
                 (0 as Variant).write_le(&mut writer)?;
                 committee.write_le(&mut writer)?;
                 u16::try_from(public_balances.len()).map_err(|e| error(e.to_string()))?.write_le(&mut writer)?;
                 for (address, amount) in public_balances {
                     address.write_le(&mut writer)?;
                     amount.write_le(&mut writer)?;
                 }
+                u16::try_from(bonded_balances.len()).map_err(|e| error(e.to_string()))?.write_le(&mut writer)?;
+                for (address, (validator_address, amount)) in bonded_balances {
+                    address.write_le(&mut writer)?;
+                    validator_address.write_le(&mut writer)?;
+                    amount.write_le(&mut writer)?;
+                }
                 Ok(())
             }
             Self::BlockReward(amount) => {

ledger/block/src/ratify/mod.rs

@@ -24,11 +24,15 @@ use indexmap::IndexMap;
 type Variant = u8;
 /// A helper type to represent the public balances.
 type PublicBalances<N> = IndexMap<Address<N>, u64>;
+/// A helper type to represent the bonded balances.
+type BondedBalances<N> = IndexMap<Address<N>, (Address<N>, u64)>;
 
+#[allow(clippy::large_enum_variant)]
+// Note: The size of the `Ratify` object is 240 bytes.
 #[derive(Clone, PartialEq, Eq)]
 pub enum Ratify<N: Network> {
     /// The genesis.
-    Genesis(Committee<N>, PublicBalances<N>),
+    Genesis(Committee<N>, PublicBalances<N>, BondedBalances<N>),
     /// The block reward.
     BlockReward(u64),
     /// The puzzle reward.
@@ -55,9 +59,11 @@ pub(crate) mod test_helpers {
         for (address, _) in committee.members().iter() {
             public_balances.insert(*address, rng.gen());
         }
+        let bonded_balances =
+            committee.members().iter().map(|(address, (amount, _))| (*address, (*address, *amount))).collect();
 
         vec![
-            Ratify::Genesis(committee, public_balances),
+            Ratify::Genesis(committee, public_balances, bonded_balances),
             Ratify::BlockReward(rng.gen()),
             Ratify::PuzzleReward(rng.gen()),
         ]

ledger/block/src/ratify/serialize.rs

@@ -19,11 +19,12 @@ impl<N: Network> Serialize for Ratify<N> {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         match serializer.is_human_readable() {
             true => match self {
-                Self::Genesis(committee, public_balances) => {
+                Self::Genesis(committee, public_balances, bonded_balances) => {
                     let mut input = serializer.serialize_struct("Ratify", 3)?;
                     input.serialize_field("type", "genesis")?;
                     input.serialize_field("committee", &committee)?;
                     input.serialize_field("public_balances", &public_balances)?;
+                    input.serialize_field("bonded_balances", &bonded_balances)?;
                     input.end()
                 }
                 Self::BlockReward(amount) => {
@@ -60,8 +61,11 @@ impl<'de, N: Network> Deserialize<'de> for Ratify<N> {
                         // Retrieve the public balances.
                         let public_balances: PublicBalances<N> =
                             DeserializeExt::take_from_value::<D>(&mut object, "public_balances")?;
+                        // Retrieve the bonded balances.
+                        let bonded_balances: BondedBalances<N> =
+                            DeserializeExt::take_from_value::<D>(&mut object, "bonded_balances")?;
                         // Construct the ratify object.
-                        Ratify::Genesis(committee, public_balances)
+                        Ratify::Genesis(committee, public_balances, bonded_balances)
                     }
                     Some("block_reward") => {
                         // Retrieve the amount.

synthesizer/src/vm/finalize.rs

@@ -182,12 +182,12 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
 
             // Initialize an iterator for ratifications before finalize.
             let pre_ratifications = ratifications.iter().filter(|r| match r {
-                Ratify::Genesis(_, _) => true,
+                Ratify::Genesis(_, _, _) => true,
                 Ratify::BlockReward(..) | Ratify::PuzzleReward(..) => false,
             });
             // Initialize an iterator for ratifications after finalize.
             let post_ratifications = ratifications.iter().filter(|r| match r {
-                Ratify::Genesis(_, _) => false,
+                Ratify::Genesis(_, _, _) => false,
                 Ratify::BlockReward(..) | Ratify::PuzzleReward(..) => true,
             });
 
@@ -464,12 +464,12 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
         atomic_finalize!(self.finalize_store(), FinalizeMode::RealRun, {
             // Initialize an iterator for ratifications before finalize.
             let pre_ratifications = ratifications.iter().filter(|r| match r {
-                Ratify::Genesis(_, _) => true,
+                Ratify::Genesis(_, _, _) => true,
                 Ratify::BlockReward(..) | Ratify::PuzzleReward(..) => false,
             });
             // Initialize an iterator for ratifications after finalize.
             let post_ratifications = ratifications.iter().filter(|r| match r {
-                Ratify::Genesis(_, _) => false,
+                Ratify::Genesis(_, _, _) => false,
                 Ratify::BlockReward(..) | Ratify::PuzzleReward(..) => true,
             });
 
@@ -707,7 +707,7 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
         // Iterate over the ratifications.
         for ratify in pre_ratifications {
             match ratify {
-                Ratify::Genesis(committee, public_balances) => {
+                Ratify::Genesis(committee, public_balances, bonded_balances) => {
                     // Ensure this is the genesis block.
                     ensure!(state.block_height() == 0, "Ratify::Genesis(..) expected a genesis block");
                     // Ensure the genesis committee round is 0.
@@ -730,17 +730,60 @@ 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() {
-                        // Insert the validator into the stakers.
-                        stakers.insert(*validator, (*validator, *microcredits));
+                    // Calculate the stake per validator using `bonded_balances`.
+                    let mut stake_per_validator = IndexMap::with_capacity(committee.members().len());
+                    for (address, (validator_address, amount)) in bonded_balances {
+                        // Check that the amount meets the minimum requirement, depending on whether the address is a validator.
+                        if *address == *validator_address {
+                            ensure!(
+                                *amount >= 1_000_000_000_000_u64,
+                                "Ratify::Genesis(..) the validator {address} must stake at least 1_000_000_000_000",
+                            );
+                        } else {
+                            ensure!(
+                                *amount >= 10_000_000_u64,
+                                "Ratify::Genesis(..) the delegator {address} must stake at least 10_000_000",
+                            );
+                            // If the address is a delegator, check that the corresponding validator is open.
+                            ensure!(
+                                committee.is_committee_member_open(*validator_address),
+                                "Ratify::Genesis(..) the delegator {address} is delegating to a closed validator {validator_address}",
+                            );
+                        }
+                        // Ensure that each staker has an entry in `public_balances`.
+                        ensure!(
+                            public_balances.contains_key(address),
+                            "Ratify::Genesis(..) the staker {address} is missing from the public balances",
+                        );
+                        // Accumulate the staked amount per validator.
+                        let total = stake_per_validator.entry(validator_address).or_insert(0u64);
+                        *total = total.saturating_add(*amount);
+                    }
+                    // Ensure the stake per validator matches the committee.
+                    ensure!(
+                        stake_per_validator.len() == committee.members().len(),
+                        "Ratify::Genesis(..) the number of validators in the committee does not match the number of validators in the bonded balances",
+                    );
+
+                    // Check that `committee` is consistent with `stake_per_validator`.
+                    for (validator_address, amount) in stake_per_validator {
+                        // Retrieve the expected validator stake from the committee.
+                        let expected_amount = match committee.members().get(validator_address) {
+                            Some((amount, _)) => *amount,
+                            None => bail!(
+                                "Ratify::Genesis(..) found a validator in the bonded balances that is not in the committee"
+                            ),
+                        };
+                        // Ensure the staked amount matches the committee.
+                        ensure!(
+                            expected_amount == amount,
+                            "Ratify::Genesis(..) inconsistent staked amount for validator {validator_address}",
+                        );
                     }
 
                     // Construct the next committee map and next bonded map.
                     let (next_committee_map, next_bonded_map) =
-                        to_next_commitee_map_and_bonded_map(committee, &stakers);
+                        to_next_commitee_map_and_bonded_map(committee, bonded_balances);
 
                     // Insert the next committee into storage.
                     store.committee_store().insert(state.block_height(), committee.clone())?;

synthesizer/src/vm/mod.rs

@@ -244,8 +244,11 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
             Address::try_from(private_keys[2])? => remaining_supply / 4,
             Address::try_from(private_keys[3])? => remaining_supply / 4,
         };
+        // Construct the bonded balances.
+        let bonded_balances =
+            committee.members().iter().map(|(address, (amount, _))| (*address, (*address, *amount))).collect();
         // Return the genesis block.
-        self.genesis_quorum(private_key, committee, public_balances, rng)
+        self.genesis_quorum(private_key, committee, public_balances, bonded_balances, rng)
     }
 
     /// Returns a new genesis block for a quorum chain.
@@ -254,6 +257,7 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
         private_key: &PrivateKey<N>,
         committee: Committee<N>,
         public_balances: IndexMap<Address<N>, u64>,
+        bonded_balances: IndexMap<Address<N>, (Address<N>, u64)>,
         rng: &mut R,
     ) -> Result<Block<N>> {
         // Retrieve the total stake.
@@ -275,7 +279,7 @@ impl<N: Network, C: ConsensusStorage<N>> VM<N, C> {
         let inputs = [caller.to_string(), format!("{amount}_u64")];
 
         // Prepare the ratifications.
-        let ratifications = vec![Ratify::Genesis(committee, public_balances)];
+        let ratifications = vec![Ratify::Genesis(committee, public_balances, bonded_balances)];
         // Prepare the solutions.
         let solutions = None; // The genesis block does not require solutions.
         // Prepare the transactions.