Add StorageDepositReturnMismatch check

Co-Authored-By: Thoralf-M <[email protected]>

bee-ledger/src/workers/consensus/white_flag.rs

@@ -129,6 +129,17 @@ fn apply_regular_essence<B: StorageBackend>(
             }
         }
 
+        if let Some(storage_deposit_return) = unlock_conditions.storage_deposit_return() {
+            let amount = context
+                .storage_deposit_returns
+                .entry(*storage_deposit_return.return_address())
+                .or_default();
+
+            *amount = amount
+                .checked_add(storage_deposit_return.amount())
+                .ok_or(Error::StorageDepositReturnOverflow)?;
+        }
+
         context.input_amount = context
             .input_amount
             .checked_add(amount)
@@ -172,6 +183,28 @@ fn apply_regular_essence<B: StorageBackend>(
         }
     }
 
+    // Validation of storage deposit returns.
+    for (return_address, return_amount) in context.storage_deposit_returns.iter() {
+        if context
+            .essence
+            .outputs()
+            .iter()
+            .find(|output| {
+                if let Output::Basic(output) = output {
+                    output.address() == return_address
+                        && output.amount() == *return_amount
+                        && output.unlock_conditions().len() == 1
+                        && output.feature_blocks().len() == 0
+                } else {
+                    false
+                }
+            })
+            .is_none()
+        {
+            return Ok(ConflictReason::StorageDepositReturnMismatch);
+        }
+    }
+
     // Validation of amounts.
     if context.input_amount != context.output_amount {
         return Ok(ConflictReason::CreatedConsumedAmountMismatch);

bee-ledger/src/workers/error.rs

@@ -83,6 +83,9 @@ pub enum Error {
     /// Storage backend error.
     #[error("storage backend error: {0}")]
     Storage(Box<dyn std::error::Error + Send>),
+    /// Storage deposit return overflow.
+    #[error("storage deposit return overflow")]
+    StorageDepositReturnOverflow,
 }
 
 impl<E: Into<Error>> From<UnpackError<E, std::io::Error>> for Error {

bee-message/src/output/mod.rs

@@ -254,9 +254,9 @@ impl Output {
     }
 
     /// Verify if a valid storage deposit was made. Each [`Output`] has to have an amount that covers its associated
-    /// byte cost, given by [`ByteCostConfig`]. If there is a
-    /// [`StorageDepositReturnUnlockCondition`](unlock_condition::StorageDepositReturnUnlockCondition), its amount
-    /// is also checked.
+    /// byte cost, given by [`ByteCostConfig`].
+    /// If there is a [`StorageDepositReturnUnlockCondition`](unlock_condition::StorageDepositReturnUnlockCondition),
+    /// its amount is also checked.
     pub fn verify_storage_deposit(&self, config: &ByteCostConfig) -> Result<(), Error> {
         let required_output_amount = self.byte_cost(config);
 

bee-message/src/semantic.rs

@@ -57,6 +57,8 @@ pub enum ConflictReason {
     IncorrectUnlockMethod = 11,
     /// The inputs commitments do not match.
     InputsCommitmentsMismatch = 12,
+    /// Storage deposit return mismatch.
+    StorageDepositReturnMismatch = 13,
     /// The semantic validation failed for a reason not covered by the previous variants.
     SemanticValidationFailed = 255,
 }
@@ -85,6 +87,7 @@ impl TryFrom<u8> for ConflictReason {
             10 => Self::UnverifiedSender,
             11 => Self::IncorrectUnlockMethod,
             12 => Self::InputsCommitmentsMismatch,
+            13 => Self::StorageDepositReturnMismatch,
             255 => Self::SemanticValidationFailed,
             x => return Err(Self::Error::InvalidConflict(x)),
         })
@@ -119,6 +122,8 @@ pub struct ValidationContext<'a> {
     pub output_chains: HashMap<ChainId, &'a Output>,
     ///
     pub unlocked_addresses: HashSet<Address>,
+    ///
+    pub storage_deposit_returns: HashMap<Address, u64>,
 }
 
 impl<'a> ValidationContext<'a> {
@@ -163,6 +168,7 @@ impl<'a> ValidationContext<'a> {
                 })
                 .collect(),
             unlocked_addresses: HashSet::new(),
+            storage_deposit_returns: HashMap::new(),
         }
     }
 }

bee-message/tip.md

@@ -15,14 +15,6 @@ amounts per `Return Addresses` are summed up and the output side must deposit th
 - `Return Amount` must be ≥ than `Minimum Storage Deposit` and must not be `0`.
 - It must hold true, that `0` ≤ `Amount` - `Return Amount` ≤ `Required Storage Deposit of the Output`.
 
-###### Additional semantic transaction validation rule:
-- An output that has <i>Storage Deposit Return Unlock Condition</i> specified must only be consumed and unlocked in a
-  transaction that deposits `Return Amount` IOTA coins to `Return Address` via an output that has no additional spending
-  constraints. (<i>Basic Output</i> with only an <i>Address Unlock Condition</i>)
-- When several outputs with <i>Storage Deposit Return Unlock Condition</i> and the same `Return Address` are consumed,
-  their return amounts per `Return Addresses` are summed up and the output side of the transaction must deposit this
-  total sum per `Return Address`.
-
 ##### Expiration Unlock Conditions Additional semantic transaction validation rules:
 - If `Milestone Index` != `0`, an output that has <i>Expiration Unlock Condition</i> set must only be consumed and
   unlocked by the target `Address` (defined in <i>Address Unlock Condition</i>) in a transaction that has a confirming