Calculate and set max_burned_mana field

sdk/src/client/api/block_builder/mod.rs

@@ -8,9 +8,10 @@ pub use self::transaction::verify_semantic;
 use crate::{
     client::{ClientInner, Result},
     types::block::{
-        core::{BlockHeader, UnsignedBlock},
+        core::{basic::MaxBurnedManaAmount, BasicBlockBody, BlockHeader, UnsignedBlock},
         output::AccountId,
         payload::Payload,
+        protocol::{WorkScore, WorkScoreParameters},
         BlockBody,
     },
 };
@@ -43,12 +44,18 @@ impl ClientInner {
                 issuance.latest_finalized_slot,
                 issuer_id,
             ),
-            // TODO: burned mana calculation
-            BlockBody::build_basic(issuance.strong_parents()?, 0)
-                .with_weak_parents(issuance.weak_parents()?)
-                .with_shallow_like_parents(issuance.shallow_like_parents()?)
-                .with_payload(payload)
-                .finish_block_body()?,
+            BlockBody::build_basic(
+                issuance.strong_parents()?,
+                MaxBurnedManaAmount::MinimumAmount {
+                    params: protocol_params.work_score_parameters,
+                    reference_mana_cost: issuance.commitment.reference_mana_cost(),
+                },
+            )
+            .with_weak_parents(issuance.weak_parents()?)
+            .with_shallow_like_parents(issuance.shallow_like_parents()?)
+            .with_payload(payload)
+            .finish()?
+            .into(),
         ))
     }
 }

sdk/src/types/block/core/basic.rs

@@ -14,19 +14,54 @@ pub type StrongParents = Parents<1, 8>;
 pub type WeakParents = Parents<0, 8>;
 pub type ShallowLikeParents = Parents<0, 8>;
 
+#[derive(Copy, Clone)]
+pub enum MaxBurnedManaAmount {
+    Amount(u64),
+    MinimumAmount {
+        params: WorkScoreParameters,
+        reference_mana_cost: u64,
+    },
+}
+
 /// A builder for a [`BasicBlockBody`].
 pub struct BasicBlockBodyBuilder {
     strong_parents: StrongParents,
     weak_parents: WeakParents,
     shallow_like_parents: ShallowLikeParents,
     payload: OptionalPayload,
-    max_burned_mana: u64,
+    max_burned_mana: MaxBurnedManaAmount,
 }
 
 impl BasicBlockBodyBuilder {
+    /// Creates a new [`BasicBlockBodyBuilder`] with `max burned mana` set to the provided value.
+    #[inline(always)]
+    pub fn new_with_mana_amount(strong_parents: StrongParents, max_burned_mana: u64) -> Self {
+        Self::new(strong_parents, MaxBurnedManaAmount::Amount(max_burned_mana))
+    }
+
+    /// Creates a new [`BasicBlockBodyBuilder`] with `max burned mana` set to the minimum value according to the
+    /// provided reference mana cost.
+    #[inline(always)]
+    pub fn new_with_minimum_mana_amount(
+        strong_parents: StrongParents,
+        params: WorkScoreParameters,
+        reference_mana_cost: u64,
+    ) -> Self {
+        Self {
+            strong_parents,
+            weak_parents: WeakParents::default(),
+            shallow_like_parents: ShallowLikeParents::default(),
+            payload: OptionalPayload::default(),
+            max_burned_mana: MaxBurnedManaAmount::MinimumAmount {
+                params,
+                reference_mana_cost,
+            },
+        }
+    }
+
     /// Creates a new [`BasicBlockBodyBuilder`].
     #[inline(always)]
-    pub fn new(strong_parents: StrongParents, max_burned_mana: u64) -> Self {
+    pub fn new(strong_parents: StrongParents, max_burned_mana: MaxBurnedManaAmount) -> Self {
         Self {
             strong_parents,
             weak_parents: WeakParents::default(),
@@ -64,24 +99,27 @@ impl BasicBlockBodyBuilder {
         self
     }
 
-    /// Adds max burned mana to a [`BasicBlockBodyBuilder`].
-    #[inline(always)]
-    pub fn with_max_burned_mana(mut self, max_burned_mana: u64) -> Self {
-        self.max_burned_mana = max_burned_mana;
-        self
-    }
-
     /// Finishes the builder into a [`BasicBlockBody`].
     pub fn finish(self) -> Result<BasicBlockBody, Error> {
         verify_parents_sets(&self.strong_parents, &self.weak_parents, &self.shallow_like_parents)?;
 
-        Ok(BasicBlockBody {
+        let mut body = BasicBlockBody {
             strong_parents: self.strong_parents,
             weak_parents: self.weak_parents,
             shallow_like_parents: self.shallow_like_parents,
             payload: self.payload,
-            max_burned_mana: self.max_burned_mana,
-        })
+            max_burned_mana: 0,
+        };
+
+        body.max_burned_mana = match self.max_burned_mana {
+            MaxBurnedManaAmount::Amount(amount) => amount,
+            MaxBurnedManaAmount::MinimumAmount {
+                params,
+                reference_mana_cost,
+            } => body.work_score(params) as u64 * reference_mana_cost,
+        };
+
+        Ok(body)
     }
 
     /// Finishes the builder into a [`BlockBody`].
@@ -97,7 +135,7 @@ impl From<BasicBlockBody> for BasicBlockBodyBuilder {
             weak_parents: value.weak_parents,
             shallow_like_parents: value.shallow_like_parents,
             payload: value.payload,
-            max_burned_mana: value.max_burned_mana,
+            max_burned_mana: MaxBurnedManaAmount::Amount(value.max_burned_mana),
         }
     }
 }
@@ -228,15 +266,18 @@ pub(crate) mod dto {
             dto: BasicBlockBodyDto,
             params: Option<&ProtocolParameters>,
         ) -> Result<Self, Self::Error> {
-            BasicBlockBodyBuilder::new(StrongParents::from_set(dto.strong_parents)?, dto.max_burned_mana)
-                .with_weak_parents(WeakParents::from_set(dto.weak_parents)?)
-                .with_shallow_like_parents(ShallowLikeParents::from_set(dto.shallow_like_parents)?)
-                .with_payload(
-                    dto.payload
-                        .map(|payload| Payload::try_from_dto_with_params_inner(payload, params))
-                        .transpose()?,
-                )
-                .finish()
+            BasicBlockBodyBuilder::new_with_mana_amount(
+                StrongParents::from_set(dto.strong_parents)?,
+                dto.max_burned_mana,
+            )
+            .with_weak_parents(WeakParents::from_set(dto.weak_parents)?)
+            .with_shallow_like_parents(ShallowLikeParents::from_set(dto.shallow_like_parents)?)
+            .with_payload(
+                dto.payload
+                    .map(|payload| Payload::try_from_dto_with_params_inner(payload, params))
+                    .transpose()?,
+            )
+            .finish()
         }
     }
 }

sdk/src/types/block/core/mod.rs

@@ -19,6 +19,7 @@ pub use self::{
     validation::{ValidationBlockBody, ValidationBlockBodyBuilder},
 };
 use crate::types::block::{
+    core::basic::MaxBurnedManaAmount,
     protocol::{ProtocolParameters, ProtocolParametersHash, WorkScore, WorkScoreParameters},
     Error,
 };
@@ -81,7 +82,10 @@ impl BlockBody {
 
     /// Creates a new [`BasicBlockBodyBuilder`].
     #[inline(always)]
-    pub fn build_basic(strong_parents: self::basic::StrongParents, max_burned_mana: u64) -> BasicBlockBodyBuilder {
+    pub fn build_basic(
+        strong_parents: self::basic::StrongParents,
+        max_burned_mana: MaxBurnedManaAmount,
+    ) -> BasicBlockBodyBuilder {
         BasicBlockBodyBuilder::new(strong_parents, max_burned_mana)
     }
 

sdk/src/types/block/rand/block.rs

@@ -45,7 +45,7 @@ pub fn rand_basic_block_body_with_strong_parents(strong_parents: basic::StrongPa
 pub fn rand_basic_block_body_builder_with_strong_parents(
     strong_parents: basic::StrongParents,
 ) -> BasicBlockBodyBuilder {
-    BlockBody::build_basic(strong_parents, rand_number())
+    BlockBody::build_basic(strong_parents, basic::MaxBurnedManaAmount::Amount(rand_number()))
 }
 
 /// Generates a random block with given block body.