Add work score trait and impls

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

@@ -11,7 +11,7 @@ use packable::{
 use crate::types::block::{
     core::{parent::verify_parents_sets, Block, Parents},
     payload::{OptionalPayload, Payload},
-    protocol::ProtocolParameters,
+    protocol::{ProtocolParameters, WorkScore, WorkScoreStructure},
     Error,
 };
 
@@ -156,6 +156,26 @@ impl BasicBlock {
     }
 }
 
+impl WorkScore for BasicBlock {
+    fn work_score(&self, work_score_params: WorkScoreStructure) -> u32 {
+        let missing_parent_score = {
+            let min_strong_parents_threshold = work_score_params.min_strong_parents_threshold as usize;
+            if self.strong_parents.len() < min_strong_parents_threshold {
+                let missing_parents_count = min_strong_parents_threshold - self.strong_parents.len();
+                work_score_params.missing_parent * missing_parents_count as u32
+            } else {
+                0
+            }
+        };
+        let payload_score = self
+            .payload
+            .as_ref()
+            .map(|p| p.work_score(work_score_params))
+            .unwrap_or(0);
+        work_score_params.block + missing_parent_score + payload_score
+    }
+}
+
 impl Packable for BasicBlock {
     type UnpackError = Error;
     type UnpackVisitor = ProtocolParameters;

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

@@ -23,8 +23,9 @@ pub use self::{
     validation::{ValidationBlock, ValidationBlockBuilder},
     wrapper::{BlockHeader, BlockWrapper, BlockWrapperBuilder},
 };
+use super::protocol::WorkScore;
 use crate::types::block::{
-    protocol::{ProtocolParameters, ProtocolParametersHash},
+    protocol::{ProtocolParameters, ProtocolParametersHash, WorkScoreStructure},
     Error,
 };
 
@@ -130,6 +131,15 @@ impl Block {
     }
 }
 
+impl WorkScore for Block {
+    fn work_score(&self, work_score_params: WorkScoreStructure) -> u32 {
+        match self {
+            Self::Basic(basic) => basic.work_score(work_score_params),
+            Self::Validation(validation) => 0,
+        }
+    }
+}
+
 impl Packable for Block {
     type UnpackError = Error;
     type UnpackVisitor = ProtocolParameters;

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

@@ -10,7 +10,7 @@ use packable::{
 
 use crate::types::block::{
     core::{parent::verify_parents_sets, Block, Parents},
-    protocol::{ProtocolParameters, ProtocolParametersHash},
+    protocol::{ProtocolParameters, ProtocolParametersHash, WorkScore, WorkScoreStructure},
     Error,
 };
 

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

@@ -16,7 +16,7 @@ use packable::{
 use crate::types::block::{
     block_id::{BlockHash, BlockId},
     core::{BasicBlock, ValidationBlock},
-    protocol::ProtocolParameters,
+    protocol::{ProtocolParameters, WorkScore, WorkScoreStructure},
     signature::Signature,
     slot::{SlotCommitmentId, SlotIndex},
     Block, Error, IssuerId,
@@ -290,6 +290,14 @@ impl BlockWrapper {
     }
 }
 
+impl WorkScore for BlockWrapper {
+    fn work_score(&self, work_score_params: WorkScoreStructure) -> u32 {
+        let block_score = self.block.work_score(work_score_params);
+        let signature_score = self.signature.work_score(work_score_params);
+        block_score + signature_score
+    }
+}
+
 impl Packable for BlockWrapper {
     type UnpackError = Error;
     type UnpackVisitor = ProtocolParameters;

sdk/src/types/block/output/account.rs

@@ -25,7 +25,7 @@ use crate::types::{
             NativeTokens, Output, OutputBuilderAmount, OutputId, Rent, RentStructure, StateTransitionError,
             StateTransitionVerifier,
         },
-        protocol::ProtocolParameters,
+        protocol::{ProtocolParameters, WorkScore, WorkScoreStructure},
         semantic::{TransactionFailureReason, ValidationContext},
         unlock::Unlock,
         Error,
@@ -651,6 +651,15 @@ impl StateTransitionVerifier for AccountOutput {
     }
 }
 
+impl WorkScore for AccountOutput {
+    fn work_score(&self, work_score_params: WorkScoreStructure) -> u32 {
+        let native_tokens_score = self.native_tokens().work_score(work_score_params);
+        let features_score = self.features().work_score(work_score_params);
+        let immutable_features_score = self.immutable_features().work_score(work_score_params);
+        work_score_params.output + native_tokens_score + features_score + immutable_features_score
+    }
+}
+
 impl Packable for AccountOutput {
     type UnpackError = Error;
     type UnpackVisitor = ProtocolParameters;

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

@@ -16,7 +16,7 @@ use crate::types::{
             verify_output_amount_min, verify_output_amount_packable, verify_output_amount_supply, NativeToken,
             NativeTokens, Output, OutputBuilderAmount, OutputId, Rent, RentStructure,
         },
-        protocol::ProtocolParameters,
+        protocol::{ProtocolParameters, WorkScore, WorkScoreStructure},
         semantic::{TransactionFailureReason, ValidationContext},
         unlock::Unlock,
         Error,
@@ -323,6 +323,14 @@ impl BasicOutput {
     }
 }
 
+impl WorkScore for BasicOutput {
+    fn work_score(&self, work_score_params: WorkScoreStructure) -> u32 {
+        let native_tokens_score = self.native_tokens().work_score(work_score_params);
+        let features_score = self.features().work_score(work_score_params);
+        work_score_params.output + native_tokens_score + features_score
+    }
+}
+
 fn verify_unlock_conditions<const VERIFY: bool>(unlock_conditions: &UnlockConditions) -> Result<(), Error> {
     if VERIFY {
         if unlock_conditions.address().is_none() {

sdk/src/types/block/output/delegation.rs

@@ -21,7 +21,7 @@ use crate::types::{
             verify_output_amount_min, verify_output_amount_packable, verify_output_amount_supply, Output,
             OutputBuilderAmount, OutputId, Rent, RentStructure, StateTransitionError, StateTransitionVerifier,
         },
-        protocol::ProtocolParameters,
+        protocol::{ProtocolParameters, WorkScore, WorkScoreStructure},
         semantic::{TransactionFailureReason, ValidationContext},
         slot::EpochIndex,
         unlock::Unlock,
@@ -405,6 +405,12 @@ impl StateTransitionVerifier for DelegationOutput {
     }
 }
 
+impl WorkScore for DelegationOutput {
+    fn work_score(&self, work_score_params: WorkScoreStructure) -> u32 {
+        work_score_params.output
+    }
+}
+
 impl Packable for DelegationOutput {
     type UnpackError = Error;
     type UnpackVisitor = ProtocolParameters;

sdk/src/types/block/output/feature/mod.rs

@@ -28,7 +28,11 @@ pub use self::{
     staking::StakingFeature,
     tag::TagFeature,
 };
-use crate::types::block::{create_bitflags, Error};
+use crate::types::block::{
+    create_bitflags,
+    protocol::{WorkScore, WorkScoreStructure},
+    Error,
+};
 
 ///
 #[derive(Clone, Eq, PartialEq, Hash, From, Packable)]
@@ -313,6 +317,19 @@ impl Features {
     }
 }
 
+impl WorkScore for Features {
+    fn work_score(&self, work_score_params: WorkScoreStructure) -> u32 {
+        self
+            .iter()
+            .map(|f| match f {
+                Feature::BlockIssuer(_) => work_score_params.block_issuer,
+                Feature::Staking(_) => work_score_params.staking,
+                _ => 0,
+            })
+            .sum::<u32>()
+    }
+}
+
 #[inline]
 fn verify_unique_sorted<const VERIFY: bool>(features: &[Feature], _: &()) -> Result<(), Error> {
     if VERIFY && !is_unique_sorted(features.iter().map(Feature::kind)) {

sdk/src/types/block/output/foundry.rs

@@ -25,7 +25,7 @@ use crate::types::{
             NativeTokens, Output, OutputBuilderAmount, OutputId, Rent, RentStructure, StateTransitionError,
             StateTransitionVerifier, TokenId, TokenScheme,
         },
-        protocol::ProtocolParameters,
+        protocol::{ProtocolParameters, WorkScore, WorkScoreStructure},
         semantic::{TransactionFailureReason, ValidationContext},
         unlock::Unlock,
         Error,
@@ -598,6 +598,20 @@ impl StateTransitionVerifier for FoundryOutput {
     }
 }
 
+impl WorkScore for FoundryOutput {
+    fn work_score(&self, work_score_params: WorkScoreStructure) -> u32 {
+        let native_tokens_score = self.native_tokens().work_score(work_score_params);
+        let features_score = self.features().work_score(work_score_params);
+        let immutable_features_score = self.immutable_features().work_score(work_score_params);
+        let token_scheme_score = self
+            .token_scheme()
+            .is_simple()
+            .then_some(work_score_params.native_token)
+            .unwrap_or(0);
+        work_score_params.output + native_tokens_score + features_score + immutable_features_score + token_scheme_score
+    }
+}
+
 impl Packable for FoundryOutput {
     type UnpackError = Error;
     type UnpackVisitor = ProtocolParameters;

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

@@ -58,7 +58,7 @@ pub use self::{
     token_scheme::{SimpleTokenScheme, TokenScheme},
     unlock_condition::{UnlockCondition, UnlockConditions},
 };
-use super::protocol::ProtocolParameters;
+use super::protocol::{ProtocolParameters, WorkScore, WorkScoreStructure};
 use crate::types::block::{address::Address, semantic::ValidationContext, slot::SlotIndex, Error};
 
 /// The maximum number of outputs of a transaction.
@@ -474,6 +474,18 @@ impl Rent for Output {
     }
 }
 
+impl WorkScore for Output {
+    fn work_score(&self, work_score_params: WorkScoreStructure) -> u32 {
+        match self {
+            Self::Basic(basic) => basic.work_score(work_score_params),
+            Self::Account(account) => account.work_score(work_score_params),
+            Self::Foundry(foundry) => foundry.work_score(work_score_params),
+            Self::Nft(nft) => nft.work_score(work_score_params),
+            Self::Delegation(delegation) => delegation.work_score(work_score_params),
+        }
+    }
+}
+
 pub(crate) fn verify_output_amount_min(amount: u64) -> Result<(), Error> {
     if amount < Output::AMOUNT_MIN {
         Err(Error::InvalidOutputAmount(amount))

sdk/src/types/block/output/native_token.rs

@@ -12,7 +12,11 @@ use iterator_sorted::is_unique_sorted;
 use packable::{bounded::BoundedU8, prefix::BoxedSlicePrefix, Packable};
 use primitive_types::U256;
 
-use crate::types::block::{output::foundry::FoundryId, Error};
+use crate::types::block::{
+    output::foundry::FoundryId,
+    protocol::{WorkScore, WorkScoreStructure},
+    Error,
+};
 
 impl_id!(pub TokenId, 38, "Unique identifiers of native tokens. The TokenId of native tokens minted by a specific foundry is the same as the FoundryId.");
 
@@ -247,6 +251,13 @@ impl NativeTokens {
     }
 }
 
+// TODO: should we also impl `WorkScore` for `NativeToken` for plain consistency?
+impl WorkScore for NativeTokens {
+    fn work_score(&self, work_score_params: WorkScoreStructure) -> u32 {
+        self.len() as u32 * work_score_params.native_token
+    }
+}
+
 #[inline]
 fn verify_unique_sorted<const VERIFY: bool>(native_tokens: &[NativeToken], _: &()) -> Result<(), Error> {
     if VERIFY && !is_unique_sorted(native_tokens.iter().map(NativeToken::token_id)) {

sdk/src/types/block/output/nft.rs

@@ -22,7 +22,7 @@ use crate::types::{
             NativeTokens, Output, OutputBuilderAmount, OutputId, Rent, RentStructure, StateTransitionError,
             StateTransitionVerifier,
         },
-        protocol::ProtocolParameters,
+        protocol::{ProtocolParameters, WorkScore, WorkScoreStructure},
         semantic::{TransactionFailureReason, ValidationContext},
         unlock::Unlock,
         Error,
@@ -461,6 +461,15 @@ impl StateTransitionVerifier for NftOutput {
     }
 }
 
+impl WorkScore for NftOutput {
+    fn work_score(&self, work_score_params: WorkScoreStructure) -> u32 {
+        let native_tokens_score = self.native_tokens().work_score(work_score_params);
+        let features_score = self.features().work_score(work_score_params);
+        let immutable_features_score = self.immutable_features().work_score(work_score_params);
+        work_score_params.output + native_tokens_score + features_score + immutable_features_score
+    }
+}
+
 impl Packable for NftOutput {
     type UnpackError = Error;
     type UnpackVisitor = ProtocolParameters;

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

@@ -7,7 +7,7 @@ pub mod tagged_data;
 pub mod transaction;
 
 use alloc::boxed::Box;
-use core::ops::Deref;
+use core::{mem::size_of, ops::Deref};
 
 use packable::{
     error::{UnpackError, UnpackErrorExt},
@@ -21,6 +21,7 @@ pub(crate) use self::{
     tagged_data::{TagLength, TaggedDataLength},
     transaction::{ContextInputCount, InputCount, OutputCount},
 };
+use super::protocol::{WorkScore, WorkScoreStructure};
 use crate::types::block::{protocol::ProtocolParameters, Error};
 
 /// A generic payload that can represent different types defining block payloads.
@@ -63,6 +64,18 @@ impl Payload {
     }
 }
 
+impl WorkScore for Payload {
+    fn work_score(&self, work_score_params: WorkScoreStructure) -> u32 {
+        // 1 byte for the payload kind
+        let score = size_of::<u8>() as u32
+            + match self {
+                Self::Transaction(transaction_payload) => transaction_payload.work_score(work_score_params),
+                Self::TaggedData(tagged_data_payload) => tagged_data_payload.work_score(work_score_params),
+            };
+        score
+    }
+}
+
 impl Packable for Payload {
     type UnpackError = Error;
     type UnpackVisitor = ProtocolParameters;

sdk/src/types/block/payload/tagged_data/mod.rs

@@ -9,10 +9,13 @@ use core::ops::RangeInclusive;
 use packable::{
     bounded::{BoundedU32, BoundedU8},
     prefix::BoxedSlicePrefix,
-    Packable,
+    Packable, PackableExt,
 };
 
-use crate::types::block::{BlockWrapper, Error};
+use crate::types::block::{
+    protocol::{WorkScore, WorkScoreStructure},
+    BlockWrapper, Error,
+};
 
 pub(crate) type TagLength =
     BoundedU8<{ *TaggedDataPayload::TAG_LENGTH_RANGE.start() }, { *TaggedDataPayload::TAG_LENGTH_RANGE.end() }>;
@@ -60,6 +63,13 @@ impl TaggedDataPayload {
     }
 }
 
+impl WorkScore for TaggedDataPayload {
+    fn work_score(&self, work_score_params: WorkScoreStructure) -> u32 {
+        let size_score = self.packed_len() as u32 * work_score_params.data_byte;
+        size_score
+    }
+}
+
 impl core::fmt::Debug for TaggedDataPayload {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("TaggedDataPayload")