fix(inx): fix ledger output rent structure logic (#759)

* Fix ledger output rent structure logic.

* Use bee output rent structure impl

* clipee

* Clippy

* Minor improvements to rent structure computation (#761)

* Minor improvements to rent structure computation

* Further improve (#85)

* Further improve

* slight refactor

Co-authored-by: /alex/ <[email protected]>

* Add test case

* Improve test

* Cleanup test

Co-authored-by: Jochen Görtler <[email protected]>
Co-authored-by: /alex/ <[email protected]>

Author: 3 people

src/db/collections/outputs/mod.rs

@@ -81,7 +81,6 @@ impl From<&LedgerOutput> for OutputDocument {
     fn from(rec: &LedgerOutput) -> Self {
         let address = rec.output.owning_address().copied();
         let is_trivial_unlock = rec.output.is_trivial_unlock();
-        let rent_structure = rec.output.rent_structure();
 
         Self {
             output_id: rec.output_id,
@@ -94,7 +93,7 @@ impl From<&LedgerOutput> for OutputDocument {
             details: OutputDetails {
                 address,
                 is_trivial_unlock,
-                rent_structure,
+                rent_structure: rec.rent_structure,
             },
         }
     }

src/types/ledger/output_metadata.rs

@@ -43,6 +43,7 @@ pub struct LedgerOutput {
     pub block_id: BlockId,
     pub booked: MilestoneIndexTimestamp,
     pub output: Output,
+    pub rent_structure: RentStructureBytes,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
@@ -51,13 +52,36 @@ pub struct LedgerSpent {
     pub spent_metadata: SpentMetadata,
 }
 
+#[cfg(feature = "inx")]
+fn compute_rent_structure(output: &bee_block_stardust::output::Output) -> RentStructureBytes {
+    use bee_block_stardust::output::{Rent, RentStructureBuilder};
+
+    let rent_cost = |byte_cost, data_factor, key_factor| {
+        output.rent_cost(
+            &RentStructureBuilder::new()
+                .byte_cost(byte_cost)
+                .data_factor(data_factor)
+                .key_factor(key_factor)
+                .finish(),
+        )
+    };
+
+    RentStructureBytes {
+        num_data_bytes: rent_cost(1, 1, 0),
+        num_key_bytes: rent_cost(1, 0, 1),
+    }
+}
+
 #[cfg(feature = "inx")]
 impl TryFrom<bee_inx::LedgerOutput> for LedgerOutput {
     type Error = bee_inx::Error;
 
     fn try_from(value: bee_inx::LedgerOutput) -> Result<Self, Self::Error> {
+        let bee_output = value.output.inner_unverified()?;
+
         Ok(Self {
-            output: Into::into(&value.output.inner_unverified()?),
+            rent_structure: compute_rent_structure(&bee_output),
+            output: Into::into(&bee_output),
             output_id: value.output_id.into(),
             block_id: value.block_id.into(),
             booked: MilestoneIndexTimestamp {
@@ -76,8 +100,11 @@ impl crate::types::context::TryFromWithContext<bee_inx::LedgerOutput> for Ledger
         ctx: &bee_block_stardust::protocol::ProtocolParameters,
         value: bee_inx::LedgerOutput,
     ) -> Result<Self, Self::Error> {
+        let bee_output = value.output.inner(ctx)?;
+
         Ok(Self {
-            output: Into::into(&value.output.inner(ctx)?),
+            rent_structure: compute_rent_structure(&bee_output),
+            output: Into::into(&bee_output),
             output_id: value.output_id.into(),
             block_id: value.block_id.into(),
             booked: MilestoneIndexTimestamp {
@@ -132,10 +159,40 @@ impl crate::types::context::TryFromWithContext<bee_inx::LedgerSpent> for LedgerS
 }
 
 /// The different number of bytes that are used for computing the rent cost.
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct RentStructureBytes {
     /// The number of key bytes in an output.
     pub num_key_bytes: u64,
     /// The number of data bytes in an output.
     pub num_data_bytes: u64,
 }
+
+#[cfg(test)]
+mod test {
+    #[cfg(all(feature = "inx", feature = "rand"))]
+    #[test]
+    fn test_compute_rent_structure() {
+        use bee_block_stardust::{output::Rent, rand::output};
+
+        use super::compute_rent_structure;
+
+        let protocol_params = bee_block_stardust::protocol::protocol_parameters();
+
+        let outputs = [
+            output::rand_basic_output(protocol_params.token_supply()).into(),
+            output::rand_alias_output(protocol_params.token_supply()).into(),
+            output::rand_foundry_output(protocol_params.token_supply()).into(),
+            output::rand_nft_output(protocol_params.token_supply()).into(),
+        ];
+
+        for output in outputs {
+            let rent = compute_rent_structure(&output);
+            assert_eq!(
+                (rent.num_data_bytes * protocol_params.rent_structure().v_byte_factor_data as u64
+                    + rent.num_key_bytes * protocol_params.rent_structure().v_byte_factor_key as u64)
+                    * protocol_params.rent_structure().v_byte_cost as u64,
+                output.rent_cost(protocol_params.rent_structure())
+            );
+        }
+    }
+}

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

@@ -14,7 +14,7 @@ pub mod treasury;
 
 use std::{borrow::Borrow, str::FromStr};
 
-use bee_block_stardust::output::{self as bee, Rent};
+use bee_block_stardust::output as bee;
 use mongodb::bson::{doc, Bson};
 use serde::{Deserialize, Serialize};
 
@@ -30,7 +30,6 @@ pub use self::{
 use super::Address;
 use crate::types::{
     context::{TryFromWithContext, TryIntoWithContext},
-    ledger::RentStructureBytes,
     stardust::block::payload::transaction::TransactionId,
 };
 
@@ -153,48 +152,6 @@ impl Output {
             Self::Foundry(_) => true,
         }
     }
-
-    pub fn rent_structure(&self) -> RentStructureBytes {
-        // Computing the rent structure is independent of the protocol parameters, we just need this for conversion.
-        let ctx = bee_block_stardust::protocol::protocol_parameters();
-        match self {
-            output @ (Self::Basic(_) | Self::Alias(_) | Self::Foundry(_) | Self::Nft(_)) => {
-                let bee_output = bee::Output::try_from_with_context(&ctx, output.clone())
-                    .expect("`Output` has to be convertible to `bee::Output`");
-
-                // The following computations of `data_bytes` and `key_bytes` makec use of the fact that the byte cost
-                // computation is a linear combination with respect to the type of the fields and their weight.
-
-                let num_data_bytes = {
-                    let config = bee::RentStructureBuilder::new()
-                        .byte_cost(1)
-                        .data_factor(1)
-                        .key_factor(0)
-                        .finish();
-                    bee_output.rent_cost(&config)
-                };
-
-                let num_key_bytes = {
-                    let config = bee::RentStructureBuilder::new()
-                        .byte_cost(1)
-                        .data_factor(0)
-                        .key_factor(1)
-                        .finish();
-                    bee_output.rent_cost(&config)
-                };
-
-                RentStructureBytes {
-                    num_data_bytes,
-                    num_key_bytes,
-                }
-            }
-            // The treasury output does not have an associated byte cost.
-            Self::Treasury(_) => RentStructureBytes {
-                num_key_bytes: 0,
-                num_data_bytes: 0,
-            },
-        }
-    }
 }
 
 impl<T: Borrow<bee::Output>> From<T> for Output {

tests/blocks.rs

@@ -9,7 +9,10 @@ mod test_rand {
     use chronicle::{
         db::collections::{BlockCollection, OutputCollection},
         types::{
-            ledger::{BlockMetadata, ConflictReason, LedgerInclusionState, LedgerOutput, MilestoneIndexTimestamp},
+            ledger::{
+                BlockMetadata, ConflictReason, LedgerInclusionState, LedgerOutput, MilestoneIndexTimestamp,
+                RentStructureBytes,
+            },
             stardust::block::{output::OutputId, payload::TransactionEssence, Block, BlockId, Payload},
         },
     };
@@ -73,6 +76,10 @@ mod test_rand {
                             milestone_index: 0.into(),
                             milestone_timestamp: 12345.into(),
                         },
+                        rent_structure: RentStructureBytes {
+                            num_key_bytes: 0,
+                            num_data_bytes: 100,
+                        },
                         output,
                     }))
                     .await

tests/claiming.rs

@@ -9,7 +9,7 @@ mod test_rand {
     use chronicle::{
         db::collections::OutputCollection,
         types::{
-            ledger::{LedgerOutput, LedgerSpent, MilestoneIndexTimestamp, SpentMetadata},
+            ledger::{LedgerOutput, LedgerSpent, MilestoneIndexTimestamp, RentStructureBytes, SpentMetadata},
             stardust::block::{
                 output::{BasicOutput, OutputAmount, OutputId},
                 payload::TransactionId,
@@ -37,6 +37,10 @@ mod test_rand {
         let unspent_outputs = (1..=5)
             .map(|i| LedgerOutput {
                 output_id: OutputId::rand(),
+                rent_structure: RentStructureBytes {
+                    num_key_bytes: 0,
+                    num_data_bytes: 100,
+                },
                 output: rand_output_with_value(i.into()),
                 block_id: BlockId::rand(),
                 booked: MilestoneIndexTimestamp {

tests/outputs.rs

@@ -9,7 +9,7 @@ mod test_rand {
     use chronicle::{
         db::collections::{OutputCollection, OutputMetadataResult, OutputWithMetadataResult},
         types::{
-            ledger::{LedgerOutput, LedgerSpent, MilestoneIndexTimestamp, SpentMetadata},
+            ledger::{LedgerOutput, LedgerSpent, MilestoneIndexTimestamp, RentStructureBytes, SpentMetadata},
             stardust::block::{output::OutputId, payload::TransactionId, BlockId, Output},
         },
     };
@@ -29,6 +29,10 @@ mod test_rand {
             .take(100)
             .map(|output| LedgerOutput {
                 output_id: OutputId::rand(),
+                rent_structure: RentStructureBytes {
+                    num_key_bytes: 0,
+                    num_data_bytes: 100,
+                },
                 output,
                 block_id: BlockId::rand(),
                 booked: MilestoneIndexTimestamp {