feat(model): use arrays to store bytes when possible

src/db/model/stardust/block/address/alias.rs

@@ -0,0 +1,33 @@
+// Copyright 2022 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use std::str::FromStr;
+
+use bee_block_stardust::address as bee;
+use serde::{Deserialize, Serialize};
+
+use crate::{db, db::model::stardust::block::AliasId};
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct AliasAddress(pub AliasId);
+
+impl From<bee::AliasAddress> for AliasAddress {
+    fn from(value: bee::AliasAddress) -> Self {
+        Self((*value).into())
+    }
+}
+
+impl From<AliasAddress> for bee::AliasAddress {
+    fn from(value: AliasAddress) -> Self {
+        bee::AliasAddress::new(value.0.into())
+    }
+}
+
+impl FromStr for AliasAddress {
+    type Err = db::error::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(bee::AliasAddress::from_str(s)?.into())
+    }
+}

src/db/model/stardust/block/address/ed25519.rs

@@ -0,0 +1,37 @@
+// Copyright 2022 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use std::str::FromStr;
+
+use bee_block_stardust::address as bee;
+use serde::{Deserialize, Serialize};
+
+use crate::{db, db::model::util::bytify};
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct Ed25519Address(#[serde(with = "bytify")] pub [u8; Self::LENGTH]);
+
+impl Ed25519Address {
+    const LENGTH: usize = bee::Ed25519Address::LENGTH;
+}
+
+impl From<bee::Ed25519Address> for Ed25519Address {
+    fn from(value: bee::Ed25519Address) -> Self {
+        Self(*value)
+    }
+}
+
+impl From<Ed25519Address> for bee::Ed25519Address {
+    fn from(value: Ed25519Address) -> Self {
+        bee::Ed25519Address::new(value.0)
+    }
+}
+
+impl FromStr for Ed25519Address {
+    type Err = db::error::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(bee::Ed25519Address::from_str(s)?.into())
+    }
+}

src/db/model/stardust/block/address.rs → src/db/model/stardust/block/address/mod.rs

@@ -6,64 +6,39 @@ use std::str::FromStr;
 use bee_block_stardust::address as bee;
 use serde::{Deserialize, Serialize};
 
-use super::{AliasId, NftId};
-use crate::db;
+mod alias;
+mod ed25519;
+mod nft;
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(transparent)]
-pub struct Ed25519Address(#[serde(with = "serde_bytes")] pub Box<[u8]>);
-
-impl From<bee::Ed25519Address> for Ed25519Address {
-    fn from(value: bee::Ed25519Address) -> Self {
-        Self(value.to_vec().into_boxed_slice())
-    }
-}
-
-impl TryFrom<Ed25519Address> for bee::Ed25519Address {
-    type Error = db::error::Error;
-
-    fn try_from(value: Ed25519Address) -> Result<Self, Self::Error> {
-        Ok(bee::Ed25519Address::new(value.0.as_ref().try_into()?))
-    }
-}
-
-impl FromStr for Ed25519Address {
-    type Err = db::error::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(bee::Ed25519Address::from_str(s)?.into())
-    }
-}
+pub use self::{alias::AliasAddress, ed25519::Ed25519Address, nft::NftAddress};
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Address {
     #[serde(rename = "ed25519")]
     Ed25519(Ed25519Address),
     #[serde(rename = "alias")]
-    Alias(AliasId),
+    Alias(AliasAddress),
     #[serde(rename = "nft")]
-    Nft(NftId),
+    Nft(NftAddress),
 }
 
 impl From<bee::Address> for Address {
     fn from(value: bee::Address) -> Self {
         match value {
-            bee::Address::Ed25519(a) => Self::Ed25519(Ed25519Address::from(a)),
-            bee::Address::Alias(a) => Self::Alias((*a.alias_id()).into()),
-            bee::Address::Nft(a) => Self::Nft((*a.nft_id()).into()),
+            bee::Address::Ed25519(a) => Self::Ed25519(a.into()),
+            bee::Address::Alias(a) => Self::Alias(a.into()),
+            bee::Address::Nft(a) => Self::Nft(a.into()),
         }
     }
 }
 
-impl TryFrom<Address> for bee::Address {
-    type Error = crate::db::error::Error;
-
-    fn try_from(value: Address) -> Result<Self, Self::Error> {
-        Ok(match value {
-            Address::Ed25519(a) => Self::Ed25519(a.try_into()?),
-            Address::Alias(a) => Self::Alias(bee::AliasAddress::new(a.try_into()?)),
-            Address::Nft(a) => Self::Nft(bee::NftAddress::new(a.try_into()?)),
-        })
+impl From<Address> for bee::Address {
+    fn from(value: Address) -> Self {
+        match value {
+            Address::Ed25519(a) => Self::Ed25519(a.into()),
+            Address::Alias(a) => Self::Alias(a.into()),
+            Address::Nft(a) => Self::Nft(a.into()),
+        }
     }
 }
 

src/db/model/stardust/block/address/nft.rs

@@ -0,0 +1,33 @@
+// Copyright 2022 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use std::str::FromStr;
+
+use bee_block_stardust::address as bee;
+use serde::{Deserialize, Serialize};
+
+use crate::{db, db::model::stardust::block::NftId};
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct NftAddress(pub NftId);
+
+impl From<bee::NftAddress> for NftAddress {
+    fn from(value: bee::NftAddress) -> Self {
+        Self((*value).into())
+    }
+}
+
+impl From<NftAddress> for bee::NftAddress {
+    fn from(value: NftAddress) -> Self {
+        bee::NftAddress::new(value.0.into())
+    }
+}
+
+impl FromStr for NftAddress {
+    type Err = db::error::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(bee::NftAddress::from_str(s)?.into())
+    }
+}

src/db/model/stardust/block/block_id.rs

@@ -6,29 +6,29 @@ use std::str::FromStr;
 use bee_block_stardust as bee;
 use serde::{Deserialize, Serialize};
 
-use crate::db;
+use crate::{db, db::model::util::bytify};
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Hash, Ord, PartialOrd, Eq)]
 #[serde(transparent)]
-pub struct BlockId(#[serde(with = "serde_bytes")] pub Box<[u8]>);
+pub struct BlockId(#[serde(with = "bytify")] pub [u8; Self::LENGTH]);
 
 impl BlockId {
+    const LENGTH: usize = bee::BlockId::LENGTH;
+
     pub fn to_hex(&self) -> String {
         prefix_hex::encode(self.0.as_ref())
     }
 }
 
 impl From<bee::BlockId> for BlockId {
     fn from(value: bee::BlockId) -> Self {
-        Self(value.to_vec().into_boxed_slice())
+        Self(*value)
     }
 }
 
-impl TryFrom<BlockId> for bee::BlockId {
-    type Error = db::error::Error;
-
-    fn try_from(value: BlockId) -> Result<Self, Self::Error> {
-        Ok(bee::BlockId::new(value.0.as_ref().try_into()?))
+impl From<BlockId> for bee::BlockId {
+    fn from(value: BlockId) -> Self {
+        bee::BlockId::new(value.0)
     }
 }
 

src/db/model/stardust/block/block_inner.rs

@@ -35,10 +35,7 @@ impl TryFrom<Block> for bee::Block {
 
     fn try_from(value: Block) -> Result<Self, Self::Error> {
         let mut builder = bee::BlockBuilder::<u64>::new(bee::parent::Parents::new(
-            Vec::from(value.parents)
-                .into_iter()
-                .map(|p| p.try_into())
-                .collect::<Result<Vec<_>, _>>()?,
+            Vec::from(value.parents).into_iter().map(Into::into).collect::<Vec<_>>(),
         )?)
         .with_nonce_provider(value.nonce, 0.0);
         if let Some(payload) = value.payload {

src/db/model/stardust/block/input.rs

@@ -32,8 +32,8 @@ impl TryFrom<Input> for bee::Input {
 
     fn try_from(value: Input) -> Result<Self, Self::Error> {
         Ok(match value {
-            Input::Utxo(i) => bee::Input::Utxo(bee::UtxoInput::new(i.transaction_id.try_into()?, i.index)?),
-            Input::Treasury { milestone_id } => bee::Input::Treasury(bee::TreasuryInput::new(milestone_id.try_into()?)),
+            Input::Utxo(i) => bee::Input::Utxo(bee::UtxoInput::new(i.transaction_id.into(), i.index)?),
+            Input::Treasury { milestone_id } => bee::Input::Treasury(bee::TreasuryInput::new(milestone_id.into())),
         })
     }
 }

src/db/model/stardust/block/output/alias.rs

@@ -7,29 +7,29 @@ use bee_block_stardust::output as bee;
 use serde::{Deserialize, Serialize};
 
 use super::{feature::Feature, native_token::NativeToken, unlock_condition::UnlockCondition, OutputAmount};
-use crate::db;
+use crate::{db, db::model::util::bytify};
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(transparent)]
-pub struct AliasId(#[serde(with = "serde_bytes")] pub Box<[u8]>);
+pub struct AliasId(#[serde(with = "bytify")] pub [u8; Self::LENGTH]);
 
 impl AliasId {
+    const LENGTH: usize = bee::AliasId::LENGTH;
+
     pub fn from_output_id_str(s: &str) -> Result<Self, db::error::Error> {
         Ok(bee::AliasId::from(bee::OutputId::from_str(s)?).into())
     }
 }
 
 impl From<bee::AliasId> for AliasId {
     fn from(value: bee::AliasId) -> Self {
-        Self(value.to_vec().into_boxed_slice())
+        Self(*value)
     }
 }
 
-impl TryFrom<AliasId> for bee::AliasId {
-    type Error = db::error::Error;
-
-    fn try_from(value: AliasId) -> Result<Self, Self::Error> {
-        Ok(bee::AliasId::new(value.0.as_ref().try_into()?))
+impl From<AliasId> for bee::AliasId {
+    fn from(value: AliasId) -> Self {
+        bee::AliasId::new(value.0)
     }
 }
 
@@ -76,7 +76,7 @@ impl TryFrom<AliasOutput> for bee::AliasOutput {
     type Error = db::error::Error;
 
     fn try_from(value: AliasOutput) -> Result<Self, Self::Error> {
-        Ok(Self::build_with_amount(value.amount, value.alias_id.try_into()?)?
+        Ok(Self::build_with_amount(value.amount, value.alias_id.into())?
             .with_native_tokens(
                 Vec::from(value.native_tokens)
                     .into_iter()

src/db/model/stardust/block/output/feature.rs

@@ -49,8 +49,8 @@ impl TryFrom<Feature> for bee::Feature {
 
     fn try_from(value: Feature) -> Result<Self, Self::Error> {
         Ok(match value {
-            Feature::Sender { address } => bee::Feature::Sender(bee::SenderFeature::new(address.try_into()?)),
-            Feature::Issuer { address } => bee::Feature::Issuer(bee::IssuerFeature::new(address.try_into()?)),
+            Feature::Sender { address } => bee::Feature::Sender(bee::SenderFeature::new(address.into())),
+            Feature::Issuer { address } => bee::Feature::Issuer(bee::IssuerFeature::new(address.into())),
             Feature::Metadata { data } => bee::Feature::Metadata(bee::MetadataFeature::new(data.into())?),
             Feature::Tag { data } => bee::Feature::Tag(bee::TagFeature::new(data.into())?),
         })

src/db/model/stardust/block/output/mod.rs

@@ -51,7 +51,7 @@ impl TryFrom<OutputId> for bee::OutputId {
     type Error = crate::db::error::Error;
 
     fn try_from(value: OutputId) -> Result<Self, Self::Error> {
-        Ok(bee::OutputId::new(value.transaction_id.try_into()?, value.index)?)
+        Ok(bee::OutputId::new(value.transaction_id.into(), value.index)?)
     }
 }
 

src/db/model/stardust/block/output/native_token.rs

@@ -7,39 +7,43 @@ use bee_block_stardust::output as bee;
 use primitive_types::U256;
 use serde::{Deserialize, Serialize};
 
+use crate::db::model::util::bytify;
+
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(transparent)]
-pub struct TokenAmount(#[serde(with = "serde_bytes")] pub Box<[u8]>);
+pub struct TokenAmount(#[serde(with = "bytify")] pub [u8; size_of::<U256>()]);
 
 impl From<&U256> for TokenAmount {
     fn from(value: &U256) -> Self {
-        let mut amount = vec![0; size_of::<U256>()];
+        let mut amount = [0; size_of::<U256>()];
         value.to_little_endian(&mut amount);
-        Self(amount.into_boxed_slice())
+        Self(amount)
     }
 }
 
 impl From<TokenAmount> for U256 {
     fn from(value: TokenAmount) -> Self {
-        U256::from_little_endian(value.0.as_ref())
+        U256::from_little_endian(&value.0)
     }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(transparent)]
-pub struct TokenId(#[serde(with = "serde_bytes")] pub Box<[u8]>);
+pub struct TokenId(#[serde(with = "bytify")] pub [u8; Self::LENGTH]);
+
+impl TokenId {
+    const LENGTH: usize = bee::TokenId::LENGTH;
+}
 
 impl From<bee::TokenId> for TokenId {
     fn from(value: bee::TokenId) -> Self {
-        Self(value.to_vec().into_boxed_slice())
+        Self(*value)
     }
 }
 
-impl TryFrom<TokenId> for bee::TokenId {
-    type Error = crate::db::error::Error;
-
-    fn try_from(value: TokenId) -> Result<Self, Self::Error> {
-        Ok(bee::TokenId::new(value.0.as_ref().try_into()?))
+impl From<TokenId> for bee::TokenId {
+    fn from(value: TokenId) -> Self {
+        bee::TokenId::new(value.0)
     }
 }
 
@@ -101,7 +105,7 @@ pub struct NativeToken {
 impl From<&bee::NativeToken> for NativeToken {
     fn from(value: &bee::NativeToken) -> Self {
         Self {
-            token_id: TokenId(value.token_id().to_vec().into_boxed_slice()),
+            token_id: TokenId(**value.token_id()),
             amount: value.amount().into(),
         }
     }
@@ -111,7 +115,7 @@ impl TryFrom<NativeToken> for bee::NativeToken {
     type Error = crate::db::error::Error;
 
     fn try_from(value: NativeToken) -> Result<Self, Self::Error> {
-        Ok(Self::new(value.token_id.try_into()?, value.amount.into())?)
+        Ok(Self::new(value.token_id.into(), value.amount.into())?)
     }
 }