Update packable dependency to 0.3.0 (#1346)

* remove uses of `UnpackErrorExt::infallible`

* avoid calling `Message::packed_len`

bee-api/bee-rest-api/Cargo.toml

@@ -34,7 +34,7 @@ iota-crypto = { version = "0.9.1", default-features = false, features = [ "blake
 log = { version = "0.4.14", default-features = false, optional = true }
 multiaddr = { version = "0.13.0", default-features = false }
 num_cpus = { version = "1.13.0", default-features = false, optional = true }
-packable = { version = "0.2.1", default-features = false }
+packable = { version = "0.3.0", default-features = false }
 prefix-hex = { version = "0.2.0", default-features = false }
 primitive-types = { version = "0.10.1", default-features = false, features = [ "serde" ] }
 serde = { version = "1.0.130", default-features = false, features = [ "derive" ] }

bee-ledger/Cargo.toml

@@ -29,7 +29,7 @@ futures = { version = "0.3.17", default-features = false, optional = true }
 hashbrown = { version = "0.12.0", default-features = false, optional = true }
 iota-crypto = { version = "0.9.1", default-features = false, features = [ "blake2b" ], optional = true }
 log = { version = "0.4.14", default-features = false, optional = true }
-packable = { version = "0.2.1", default-features = false, features = [ "serde", "io" ] }
+packable = { version = "0.3.0", default-features = false, features = [ "serde", "io" ] }
 prefix-hex = { version = "0.2.0", default-features = false, optional = true }
 ref-cast = { version = "1.0.6", default-features = false, optional = true }
 reqwest = { version = "0.11.5", default-features = false, features = [ "default-tls", "stream" ], optional = true }

bee-ledger/src/types/snapshot/header.rs

@@ -70,7 +70,7 @@ impl Packable for SnapshotHeader {
     fn unpack<U: Unpacker, const VERIFY: bool>(
         unpacker: &mut U,
     ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
-        let version = u8::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let version = u8::unpack::<_, VERIFY>(unpacker).coerce()?;
 
         if VERIFY && SNAPSHOT_VERSION != version {
             return Err(UnpackError::Packable(Error::UnsupportedVersion(
@@ -80,10 +80,10 @@ impl Packable for SnapshotHeader {
         }
 
         let kind = SnapshotKind::unpack::<_, VERIFY>(unpacker)?;
-        let timestamp = u64::unpack::<_, VERIFY>(unpacker).infallible()?;
-        let network_id = u64::unpack::<_, VERIFY>(unpacker).infallible()?;
-        let sep_index = MilestoneIndex::unpack::<_, VERIFY>(unpacker).infallible()?;
-        let ledger_index = MilestoneIndex::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let timestamp = u64::unpack::<_, VERIFY>(unpacker).coerce()?;
+        let network_id = u64::unpack::<_, VERIFY>(unpacker).coerce()?;
+        let sep_index = MilestoneIndex::unpack::<_, VERIFY>(unpacker).coerce()?;
+        let ledger_index = MilestoneIndex::unpack::<_, VERIFY>(unpacker).coerce()?;
 
         Ok(Self {
             kind,

bee-ledger/src/types/snapshot/milestone_diff.rs

@@ -90,7 +90,7 @@ impl Packable for MilestoneDiff {
     fn unpack<U: Unpacker, const VERIFY: bool>(
         unpacker: &mut U,
     ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
-        let milestone_len = u32::unpack::<_, VERIFY>(unpacker).infallible()? as usize;
+        let milestone_len = u32::unpack::<_, VERIFY>(unpacker).coerce()? as usize;
         let payload = Payload::unpack::<_, VERIFY>(unpacker).coerce()?;
         let milestone = match payload {
             Payload::Milestone(milestone) => milestone,
@@ -107,8 +107,8 @@ impl Packable for MilestoneDiff {
         }
 
         let consumed_treasury = if milestone.essence().receipt().is_some() {
-            let milestone_id = MilestoneId::unpack::<_, VERIFY>(unpacker).infallible()?;
-            let amount = u64::unpack::<_, VERIFY>(unpacker).infallible()?;
+            let milestone_id = MilestoneId::unpack::<_, VERIFY>(unpacker).coerce()?;
+            let amount = u64::unpack::<_, VERIFY>(unpacker).coerce()?;
 
             Some((
                 TreasuryOutput::new(amount).map_err(UnpackError::from_packable)?,
@@ -118,7 +118,7 @@ impl Packable for MilestoneDiff {
             None
         };
 
-        let created_count = u64::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let created_count = u64::unpack::<_, VERIFY>(unpacker).coerce()?;
         let mut created_outputs = HashMap::with_capacity(created_count as usize);
 
         for _ in 0..created_count {
@@ -128,13 +128,13 @@ impl Packable for MilestoneDiff {
             created_outputs.insert(output_id, created_output);
         }
 
-        let consumed_count = u64::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let consumed_count = u64::unpack::<_, VERIFY>(unpacker).coerce()?;
         let mut consumed_outputs = HashMap::with_capacity(consumed_count as usize);
 
         for _ in 0..consumed_count {
             let output_id = OutputId::unpack::<_, VERIFY>(unpacker).coerce()?;
             let created_output = CreatedOutput::unpack::<_, VERIFY>(unpacker).coerce()?;
-            let target = TransactionId::unpack::<_, VERIFY>(unpacker).infallible()?;
+            let target = TransactionId::unpack::<_, VERIFY>(unpacker).coerce()?;
 
             consumed_outputs.insert(
                 output_id,

bee-message/Cargo.toml

@@ -30,7 +30,7 @@ hashbrown = { version = "0.12.0", default-features = false, features = [ "ahash"
 hex = { version = "0.4.3", default-features = false, features = [ "alloc" ] }
 iota-crypto = { version = "0.9.1", default-features = false, features = [ "ed25519", "blake2b" ] }
 iterator-sorted = { version = "0.1.0", default-features = false }
-packable = { version = "0.2.1", default-features = false, features = [ "serde", "primitive-types" ] }
+packable = { version = "0.3.0", default-features = false, features = [ "serde", "primitive-types" ] }
 prefix-hex = { version = "0.2.0", default-features = false, features = [ "primitive-types1" ] }
 primitive-types = { version = "0.10.1", default-features = false, features = [ "serde" ] }
 serde = { version = "1.0.130", default-features = false, optional = true }

bee-message/fuzz/Cargo.toml

@@ -12,7 +12,7 @@ cargo-fuzz = true
 bee-message = { path = "..", default-features = false }
 
 libfuzzer-sys = { version = "0.4.2", default-features = false }
-packable = { version = "0.2.1", default-features = false }
+packable = { version = "0.3.0", default-features = false }
 
 # Prevent this from interfering with workspaces
 [workspace]

bee-message/src/message.rs

@@ -8,7 +8,7 @@ use crypto::hashes::{blake2b::Blake2b256, Digest};
 use packable::{
     error::{UnpackError, UnpackErrorExt},
     packer::Packer,
-    unpacker::Unpacker,
+    unpacker::{CounterUnpacker, Unpacker},
     Packable, PackableExt,
 };
 
@@ -165,7 +165,9 @@ impl Packable for Message {
     fn unpack<U: Unpacker, const VERIFY: bool>(
         unpacker: &mut U,
     ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
-        let protocol_version = u8::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let mut unpacker = CounterUnpacker::new(unpacker);
+
+        let protocol_version = u8::unpack::<_, VERIFY>(&mut unpacker).coerce()?;
 
         if VERIFY && protocol_version != PROTOCOL_VERSION {
             return Err(UnpackError::Packable(Error::ProtocolVersionMismatch {
@@ -174,17 +176,17 @@ impl Packable for Message {
             }));
         }
 
-        let parents = Parents::unpack::<_, VERIFY>(unpacker)?;
-        let payload = OptionalPayload::unpack::<_, VERIFY>(unpacker)?;
+        let parents = Parents::unpack::<_, VERIFY>(&mut unpacker)?;
+        let payload = OptionalPayload::unpack::<_, VERIFY>(&mut unpacker)?;
 
         if VERIFY {
             verify_payload(payload.deref().as_ref()).map_err(UnpackError::Packable)?;
         }
 
-        let nonce = u64::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let nonce = u64::unpack::<_, VERIFY>(&mut unpacker).coerce()?;
 
         // When parsing the message is complete, there should not be any trailing bytes left that were not parsed.
-        if VERIFY && u8::unpack::<_, VERIFY>(unpacker).is_ok() {
+        if VERIFY && u8::unpack::<_, VERIFY>(&mut unpacker).is_ok() {
             return Err(UnpackError::Packable(Error::RemainingBytesAfterMessage));
         }
 
@@ -195,9 +197,8 @@ impl Packable for Message {
             nonce,
         };
 
-        let message_len = message.packed_len();
+        let message_len = unpacker.counter();
 
-        // FIXME: compute this in a more efficient way.
         if VERIFY && message_len > Message::LENGTH_MAX {
             return Err(UnpackError::Packable(Error::InvalidMessageLength(message_len)));
         }

bee-message/src/output/alias.rs

@@ -555,12 +555,12 @@ impl Packable for AliasOutput {
     ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
         let amount = OutputAmount::unpack::<_, VERIFY>(unpacker).map_packable_err(Error::InvalidOutputAmount)?;
         let native_tokens = NativeTokens::unpack::<_, VERIFY>(unpacker)?;
-        let alias_id = AliasId::unpack::<_, VERIFY>(unpacker).infallible()?;
-        let state_index = u32::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let alias_id = AliasId::unpack::<_, VERIFY>(unpacker).coerce()?;
+        let state_index = u32::unpack::<_, VERIFY>(unpacker).coerce()?;
         let state_metadata = BoxedSlicePrefix::<u8, StateMetadataLength>::unpack::<_, VERIFY>(unpacker)
             .map_packable_err(|err| Error::InvalidStateMetadataLength(err.into_prefix_err().into()))?;
 
-        let foundry_counter = u32::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let foundry_counter = u32::unpack::<_, VERIFY>(unpacker).coerce()?;
 
         if VERIFY {
             verify_index_counter(&alias_id, state_index, foundry_counter).map_err(UnpackError::Packable)?;

bee-message/src/output/foundry.rs

@@ -568,8 +568,8 @@ impl Packable for FoundryOutput {
     ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
         let amount = OutputAmount::unpack::<_, VERIFY>(unpacker).map_packable_err(Error::InvalidOutputAmount)?;
         let native_tokens = NativeTokens::unpack::<_, VERIFY>(unpacker)?;
-        let serial_number = u32::unpack::<_, VERIFY>(unpacker).infallible()?;
-        let token_tag = TokenTag::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let serial_number = u32::unpack::<_, VERIFY>(unpacker).coerce()?;
+        let token_tag = TokenTag::unpack::<_, VERIFY>(unpacker).coerce()?;
         let token_scheme = TokenScheme::unpack::<_, VERIFY>(unpacker)?;
 
         let unlock_conditions = UnlockConditions::unpack::<_, VERIFY>(unpacker)?;

bee-message/src/output/nft.rs

@@ -401,7 +401,7 @@ impl Packable for NftOutput {
     ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
         let amount = OutputAmount::unpack::<_, VERIFY>(unpacker).map_packable_err(Error::InvalidOutputAmount)?;
         let native_tokens = NativeTokens::unpack::<_, VERIFY>(unpacker)?;
-        let nft_id = NftId::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let nft_id = NftId::unpack::<_, VERIFY>(unpacker).coerce()?;
         let unlock_conditions = UnlockConditions::unpack::<_, VERIFY>(unpacker)?;
 
         if VERIFY {

bee-message/src/output/token_scheme/simple.rs

@@ -78,9 +78,9 @@ impl Packable for SimpleTokenScheme {
     fn unpack<U: Unpacker, const VERIFY: bool>(
         unpacker: &mut U,
     ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
-        let minted_tokens = U256::unpack::<_, VERIFY>(unpacker).infallible()?;
-        let melted_tokens = U256::unpack::<_, VERIFY>(unpacker).infallible()?;
-        let maximum_supply = U256::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let minted_tokens = U256::unpack::<_, VERIFY>(unpacker).coerce()?;
+        let melted_tokens = U256::unpack::<_, VERIFY>(unpacker).coerce()?;
+        let maximum_supply = U256::unpack::<_, VERIFY>(unpacker).coerce()?;
 
         if VERIFY {
             verify_supply(&minted_tokens, &melted_tokens, &maximum_supply).map_err(UnpackError::Packable)?;

bee-message/src/output/unlock_condition/expiration.rs

@@ -95,8 +95,8 @@ impl Packable for ExpirationUnlockCondition {
         unpacker: &mut U,
     ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
         let return_address = Address::unpack::<_, VERIFY>(unpacker)?;
-        let milestone_index = MilestoneIndex::unpack::<_, VERIFY>(unpacker).infallible()?;
-        let timestamp = u32::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let milestone_index = MilestoneIndex::unpack::<_, VERIFY>(unpacker).coerce()?;
+        let timestamp = u32::unpack::<_, VERIFY>(unpacker).coerce()?;
 
         if VERIFY {
             verify_milestone_index_timestamp(milestone_index, timestamp).map_err(UnpackError::Packable)?;

bee-message/src/output/unlock_condition/timelock.rs

@@ -62,8 +62,8 @@ impl Packable for TimelockUnlockCondition {
     fn unpack<U: Unpacker, const VERIFY: bool>(
         unpacker: &mut U,
     ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
-        let milestone_index = MilestoneIndex::unpack::<_, VERIFY>(unpacker).infallible()?;
-        let timestamp = u32::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let milestone_index = MilestoneIndex::unpack::<_, VERIFY>(unpacker).coerce()?;
+        let timestamp = u32::unpack::<_, VERIFY>(unpacker).coerce()?;
 
         if VERIFY {
             verify_milestone_index_timestamp(milestone_index, timestamp).map_err(UnpackError::Packable)?;

bee-message/src/payload/milestone/essence.rs

@@ -139,14 +139,14 @@ impl Packable for MilestoneEssence {
     fn unpack<U: Unpacker, const VERIFY: bool>(
         unpacker: &mut U,
     ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
-        let index = MilestoneIndex::unpack::<_, VERIFY>(unpacker).infallible()?;
-        let timestamp = u64::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let index = MilestoneIndex::unpack::<_, VERIFY>(unpacker).coerce()?;
+        let timestamp = u64::unpack::<_, VERIFY>(unpacker).coerce()?;
         let parents = Parents::unpack::<_, VERIFY>(unpacker)?;
 
-        let merkle_proof = <[u8; MilestoneEssence::MERKLE_PROOF_LENGTH]>::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let merkle_proof = <[u8; MilestoneEssence::MERKLE_PROOF_LENGTH]>::unpack::<_, VERIFY>(unpacker).coerce()?;
 
-        let next_pow_score = u32::unpack::<_, VERIFY>(unpacker).infallible()?;
-        let next_pow_score_milestone_index = u32::unpack::<_, VERIFY>(unpacker).infallible()?;
+        let next_pow_score = u32::unpack::<_, VERIFY>(unpacker).coerce()?;
+        let next_pow_score_milestone_index = u32::unpack::<_, VERIFY>(unpacker).coerce()?;
 
         if VERIFY {
             verify_pow_scores(index, next_pow_score, next_pow_score_milestone_index).map_err(UnpackError::Packable)?;

bee-message/src/payload/mod.rs

@@ -135,7 +135,7 @@ impl Packable for OptionalPayload {
     fn unpack<U: Unpacker, const VERIFY: bool>(
         unpacker: &mut U,
     ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
-        let len = u32::unpack::<_, VERIFY>(unpacker).infallible()? as usize;
+        let len = u32::unpack::<_, VERIFY>(unpacker).coerce()? as usize;
 
         if len > 0 {
             unpacker.ensure_bytes(len)?;

bee-message/src/payload/receipt/tail_transaction_hash.rs

@@ -70,7 +70,7 @@ impl Packable for TailTransactionHash {
     fn unpack<U: Unpacker, const VERIFY: bool>(
         unpacker: &mut U,
     ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
-        Self::new(<[u8; TailTransactionHash::LENGTH]>::unpack::<_, VERIFY>(unpacker).infallible()?)
+        Self::new(<[u8; TailTransactionHash::LENGTH]>::unpack::<_, VERIFY>(unpacker).coerce()?)
             .map_err(UnpackError::Packable)
     }
 }

bee-message/src/semantic.rs

@@ -1,7 +1,7 @@
 // Copyright 2022 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-use core::fmt;
+use core::{convert::Infallible, fmt};
 
 use hashbrown::{HashMap, HashSet};
 use primitive_types::U256;
@@ -30,6 +30,12 @@ impl fmt::Display for ConflictError {
     }
 }
 
+impl From<Infallible> for ConflictError {
+    fn from(err: Infallible) -> Self {
+        match err {}
+    }
+}
+
 #[cfg(feature = "std")]
 impl std::error::Error for ConflictError {}
 

bee-node/bee-node/Cargo.toml

@@ -40,7 +40,7 @@ hex = { version = "0.4.3", default-features = false }
 iota-crypto = { version = "0.9.1", default-features = false, features = [ "ed25519", "random", "blake2b" ] }
 log = { version = "0.4.14", default-features = false }
 multiaddr = { version = "0.13.0", default-features = false }
-packable = { version = "0.2.1", default-features = false, features = [ "io" ] }
+packable = { version = "0.3.0", default-features = false, features = [ "io" ] }
 pkcs8 = { version = "0.8.0", default-features = false, features = [ "alloc", "pem", "std" ] }
 rand = { version = "0.8.4", default-features = false }
 rpassword = { version = "5.0.1", default-features = false }

bee-protocol/Cargo.toml

@@ -35,7 +35,7 @@ fxhash = { version = "0.2.1", default-features = false, optional = true }
 hex = { version = "0.4.3", default-features = false, optional = true }
 log = { version = "0.4.14", default-features = false, optional = true }
 num_cpus = { version = "1.13.0", default-features = false, optional = true }
-packable = { version = "0.2.1", default-features = false }
+packable = { version = "0.3.0", default-features = false }
 parking_lot = { version = "0.12.0", default-features = false, optional = true }
 rand = { version = "0.8.5", default-features = false, optional = true }
 ref-cast = { version = "1.0.6", default-features = false, optional = true }

bee-storage/bee-storage-rocksdb/Cargo.toml

@@ -23,7 +23,7 @@ bee-storage = { version = "0.9.0", path = "../bee-storage", default-features = f
 bee-tangle = { version = "0.3.0", path = "../../bee-tangle", default-features = false }
 
 num_cpus = { version = "1.13.0", default-features = false }
-packable = { version = "0.2.1", default-features = false, features = [ "serde" ] }
+packable = { version = "0.3.0", default-features = false, features = [ "serde" ] }
 rocksdb = { version = "0.18.0", default-features = false }
 serde = { version = "1.0.130", default-features = false, features = [ "derive" ] }
 thiserror = { version = "1.0.30", default-features = false }

bee-storage/bee-storage-sled/Cargo.toml

@@ -23,7 +23,7 @@ bee-storage = { version = "0.9.0", path = "../bee-storage", default-features = f
 bee-tangle = { version = "0.3.0", path = "../../bee-tangle", default-features = false }
 
 num_cpus = { version = "1.13.0", default-features = false }
-packable = { version = "0.2.1", default-features = false, features = [ "serde" ] }
+packable = { version = "0.3.0", default-features = false, features = [ "serde" ] }
 serde = { version = "1.0.130", default-features = false, features = [ "derive" ] }
 sled = { version = "0.34.7", default-features = false, features = [ "compression" ]}
 thiserror = "1.0.30"

bee-storage/bee-storage-test/Cargo.toml

@@ -23,4 +23,4 @@ bee-storage = { version = "0.9.0", path = "../bee-storage", default-features = f
 bee-tangle = { version = "0.3.0", path = "../../bee-tangle", default-features = false }
 bee-test = { version = "0.1.0", path = "../../bee-test", default-features = false }
 
-packable = { version = "0.2.1", default-features = false, features = [ "serde" ] }
+packable = { version = "0.3.0", default-features = false, features = [ "serde" ] }

bee-storage/bee-storage/Cargo.toml

@@ -17,6 +17,6 @@ all-features = true
 rustdoc-args = [ "--cfg", "doc_cfg" ]
 
 [dependencies]
-packable = { version = "0.2.1", default-features = false, features = [ "serde" ] }
+packable = { version = "0.3.0", default-features = false, features = [ "serde" ] }
 serde = { version = "1.0.130", features = [ "derive" ], default-features = false }
 thiserror = { version = "1.0.30", default-features = false }

bee-storage/bee-storage/src/system/health.rs

@@ -3,6 +3,8 @@
 
 //! Defines a type to represent different health states in which the storage backend can be.
 
+use core::convert::Infallible;
+
 /// Errors related to storage health statuses.
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
@@ -14,6 +16,12 @@ pub enum Error {
     UnknownHealth(u8),
 }
 
+impl From<Infallible> for Error {
+    fn from(err: Infallible) -> Self {
+        match err {}
+    }
+}
+
 /// Represents different health states for a `StorageBackend`.
 #[repr(u8)]
 #[derive(Debug, Copy, Clone, Eq, PartialEq, packable::Packable)]