Merge branch '2.0' into rename-block-types

bindings/core/Cargo.toml

@@ -23,20 +23,20 @@ iota-crypto = { version = "0.23.0", default-features = false, features = [
     "bip44",
 ] }
 log = { version = "0.4.20", default-features = false }
-packable = { version = "0.8.3", default-features = false }
+packable = { version = "0.9.0", default-features = false }
 prefix-hex = { version = "0.7.1", default-features = false }
 primitive-types = { version = "0.12.2", default-features = false }
 serde = { version = "1.0.188", default-features = false }
 serde_json = { version = "1.0.107", default-features = false }
 thiserror = { version = "1.0.49", default-features = false }
 tokio = { version = "1.33.0", default-features = false }
-url = { version = "2.4.1", default-features = false, features = [
-    "serde",
-] }
+url = { version = "2.4.1", default-features = false, features = ["serde"] }
 zeroize = { version = "1.6.0", default-features = false }
 
 [dev-dependencies]
-pretty_assertions = { version = "1.4.0", default-features = false, features = [ "alloc" ] }
+pretty_assertions = { version = "1.4.0", default-features = false, features = [
+    "alloc",
+] }
 
 [features]
 events = ["iota-sdk/events"]

bindings/core/src/method_handler/client.rs

@@ -196,7 +196,7 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
             client
                 .post_block(&Block::try_from_dto_with_params(
                     block,
-                    client.get_protocol_parameters().await?,
+                    &client.get_protocol_parameters().await?,
                 )?)
                 .await?,
         ),

bindings/core/src/method_handler/wallet.rs

@@ -367,7 +367,7 @@ pub(crate) async fn call_wallet_method_internal(wallet: &Wallet, method: WalletM
                 .sign_and_submit_transaction(
                     PreparedTransactionData::try_from_dto_with_params(
                         prepared_transaction_data,
-                        wallet.client().get_protocol_parameters().await?,
+                        &wallet.client().get_protocol_parameters().await?,
                     )?,
                     None,
                 )
@@ -387,7 +387,7 @@ pub(crate) async fn call_wallet_method_internal(wallet: &Wallet, method: WalletM
         } => {
             let signed_transaction_data = SignedTransactionData::try_from_dto_with_params(
                 signed_transaction_data,
-                wallet.client().get_protocol_parameters().await?,
+                &wallet.client().get_protocol_parameters().await?,
             )?;
             let transaction = wallet
                 .submit_and_store_transaction(signed_transaction_data, None)

sdk/Cargo.toml

@@ -45,7 +45,7 @@ iota-crypto = { version = "0.23.0", default-features = false, features = [
     "secp256k1",
 ] }
 iterator-sorted = { version = "0.1.0", default-features = false }
-packable = { version = "0.8.3", default-features = false, features = [
+packable = { version = "0.9.0", default-features = false, features = [
     "primitive-types",
 ] }
 paste = { version = "1.0.14", default-features = false }

sdk/examples/wallet/offline_signing/3_send_transaction.rs

@@ -56,7 +56,7 @@ async fn read_signed_transaction_from_file(client: &Client) -> Result<SignedTran
 
     Ok(SignedTransactionData::try_from_dto_with_params(
         dto,
-        client.get_protocol_parameters().await?,
+        &client.get_protocol_parameters().await?,
     )?)
 }
 

sdk/src/client/api/types.rs

@@ -17,9 +17,10 @@ use crate::{
                 },
                 SignedTransactionPayload,
             },
+            protocol::ProtocolParameters,
             Error,
         },
-        TryFromDto, ValidationParams,
+        TryFromDto,
     },
     utils::serde::bip44::option_bip44,
 };
@@ -57,13 +58,15 @@ impl From<&PreparedTransactionData> for PreparedTransactionDataDto {
     }
 }
 
-impl TryFromDto for PreparedTransactionData {
-    type Dto = PreparedTransactionDataDto;
+impl TryFromDto<PreparedTransactionDataDto> for PreparedTransactionData {
     type Error = Error;
 
-    fn try_from_dto_with_params_inner(dto: Self::Dto, params: &ValidationParams<'_>) -> Result<Self, Self::Error> {
+    fn try_from_dto_with_params_inner(
+        dto: PreparedTransactionDataDto,
+        params: Option<&ProtocolParameters>,
+    ) -> Result<Self, Self::Error> {
         Ok(Self {
-            transaction: Transaction::try_from_dto_with_params(dto.transaction, params)
+            transaction: Transaction::try_from_dto_with_params_inner(dto.transaction, params)
                 .map_err(|_| Error::InvalidField("transaction"))?,
             inputs_data: dto
                 .inputs_data
@@ -109,13 +112,15 @@ impl From<&SignedTransactionData> for SignedTransactionDataDto {
     }
 }
 
-impl TryFromDto for SignedTransactionData {
-    type Dto = SignedTransactionDataDto;
+impl TryFromDto<SignedTransactionDataDto> for SignedTransactionData {
     type Error = Error;
 
-    fn try_from_dto_with_params_inner(dto: Self::Dto, params: &ValidationParams<'_>) -> Result<Self, Self::Error> {
+    fn try_from_dto_with_params_inner(
+        dto: SignedTransactionDataDto,
+        params: Option<&ProtocolParameters>,
+    ) -> Result<Self, Self::Error> {
         Ok(Self {
-            payload: SignedTransactionPayload::try_from_dto_with_params(dto.payload, params)
+            payload: SignedTransactionPayload::try_from_dto_with_params_inner(dto.payload, params)
                 .map_err(|_| Error::InvalidField("transaction_payload"))?,
             inputs_data: dto
                 .inputs_data

sdk/src/types/block/address/multi.rs

@@ -6,14 +6,7 @@ use core::{fmt, ops::RangeInclusive};
 
 use derive_more::{AsRef, Deref, Display, From};
 use iterator_sorted::is_unique_sorted;
-use packable::{
-    bounded::BoundedU8,
-    error::{UnpackError, UnpackErrorExt},
-    packer::Packer,
-    prefix::BoxedSlicePrefix,
-    unpacker::Unpacker,
-    Packable,
-};
+use packable::{bounded::BoundedU8, prefix::BoxedSlicePrefix, Packable};
 
 use crate::types::block::{address::Address, output::StorageScore, Error};
 
@@ -77,12 +70,17 @@ fn verify_weight<const VERIFY: bool>(weight: &u8, _visitor: &()) -> Result<(), E
 /// An address that consists of addresses with weights and a threshold value.
 /// The Multi Address can be unlocked if the cumulative weight of all unlocked addresses is equal to or exceeds the
 /// threshold.
-#[derive(Clone, Debug, Deref, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Debug, Deref, Eq, PartialEq, Ord, PartialOrd, Hash, Packable)]
+#[packable(unpack_error = Error)]
+#[packable(verify_with = verify_multi_address)]
 pub struct MultiAddress {
     /// The weighted unlocked addresses.
     #[deref]
+    #[packable(verify_with = verify_addresses)]
+    #[packable(unpack_error_with = |e| e.unwrap_item_err_or_else(|p| Error::InvalidWeightedAddressCount(p.into())))]
     addresses: BoxedSlicePrefix<WeightedAddress, WeightedAddressCount>,
     /// The threshold that needs to be reached by the unlocked addresses in order to unlock the multi address.
+    #[packable(verify_with = verify_threshold)]
     threshold: u16,
 }
 
@@ -103,9 +101,11 @@ impl MultiAddress {
         let addresses = BoxedSlicePrefix::<WeightedAddress, WeightedAddressCount>::try_from(addresses)
             .map_err(Error::InvalidWeightedAddressCount)?;
 
-        verify_cumulative_weight::<true>(&addresses, &threshold, &())?;
+        let multi_address = Self { addresses, threshold };
 
-        Ok(Self { addresses, threshold })
+        verify_multi_address::<true>(&multi_address, &())?;
+
+        Ok(multi_address)
     }
 
     /// Returns the addresses of a [`MultiAddress`].
@@ -121,38 +121,6 @@ impl MultiAddress {
     }
 }
 
-impl Packable for MultiAddress {
-    type UnpackError = Error;
-    type UnpackVisitor = ();
-
-    #[inline]
-    fn pack<P: Packer>(&self, packer: &mut P) -> Result<(), P::Error> {
-        self.addresses.pack(packer)?;
-        self.threshold.pack(packer)?;
-
-        Ok(())
-    }
-
-    #[inline]
-    fn unpack<U: Unpacker, const VERIFY: bool>(
-        unpacker: &mut U,
-        visitor: &Self::UnpackVisitor,
-    ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
-        let addresses =
-            BoxedSlicePrefix::<WeightedAddress, WeightedAddressCount>::unpack::<_, VERIFY>(unpacker, visitor)
-                .map_packable_err(|e| e.unwrap_item_err_or_else(|e| Error::InvalidWeightedAddressCount(e.into())))?;
-
-        verify_addresses::<VERIFY>(&addresses, &()).map_err(UnpackError::Packable)?;
-
-        let threshold = u16::unpack::<_, VERIFY>(unpacker, visitor).coerce()?;
-
-        verify_threshold::<VERIFY>(&threshold, &()).map_err(UnpackError::Packable)?;
-        verify_cumulative_weight::<VERIFY>(&addresses, &threshold, &()).map_err(UnpackError::Packable)?;
-
-        Ok(Self { addresses, threshold })
-    }
-}
-
 fn verify_addresses<const VERIFY: bool>(addresses: &[WeightedAddress], _visitor: &()) -> Result<(), Error> {
     if VERIFY && !is_unique_sorted(addresses.iter().map(WeightedAddress::address)) {
         return Err(Error::WeightedAddressesNotUniqueSorted);
@@ -169,18 +137,14 @@ fn verify_threshold<const VERIFY: bool>(threshold: &u16, _visitor: &()) -> Resul
     }
 }
 
-fn verify_cumulative_weight<const VERIFY: bool>(
-    addresses: &[WeightedAddress],
-    threshold: &u16,
-    _visitor: &(),
-) -> Result<(), Error> {
+fn verify_multi_address<const VERIFY: bool>(address: &MultiAddress, _visitor: &()) -> Result<(), Error> {
     if VERIFY {
-        let cumulative_weight = addresses.iter().map(|address| address.weight as u16).sum::<u16>();
+        let cumulative_weight = address.iter().map(|address| address.weight as u16).sum::<u16>();
 
-        if cumulative_weight < *threshold {
+        if cumulative_weight < address.threshold {
             return Err(Error::InvalidMultiAddressCumulativeWeight {
                 cumulative_weight,
-                threshold: *threshold,
+                threshold: address.threshold,
             });
         }
     }

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

@@ -1,12 +1,7 @@
 // Copyright 2023 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-use packable::{
-    error::{UnpackError, UnpackErrorExt},
-    packer::Packer,
-    unpacker::Unpacker,
-    Packable,
-};
+use packable::Packable;
 
 use crate::types::block::{
     core::{parent::verify_parents_sets, BlockBody, Parents},
@@ -107,7 +102,10 @@ impl From<BasicBlockBody> for BasicBlockBodyBuilder {
     }
 }
 
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq, Packable)]
+#[packable(unpack_error = Error)]
+#[packable(unpack_visitor = ProtocolParameters)]
+#[packable(verify_with = verify_basic_block_body)]
 pub struct BasicBlockBody {
     /// Blocks that are strongly directly approved.
     strong_parents: StrongParents,
@@ -156,45 +154,19 @@ impl BasicBlockBody {
     }
 }
 
-impl Packable for BasicBlockBody {
-    type UnpackError = Error;
-    type UnpackVisitor = ProtocolParameters;
-
-    fn pack<P: Packer>(&self, packer: &mut P) -> Result<(), P::Error> {
-        self.strong_parents.pack(packer)?;
-        self.weak_parents.pack(packer)?;
-        self.shallow_like_parents.pack(packer)?;
-        self.payload.pack(packer)?;
-        self.max_burned_mana.pack(packer)?;
-
-        Ok(())
+fn verify_basic_block_body<const VERIFY: bool>(
+    basic_block_body: &BasicBlockBody,
+    _: &ProtocolParameters,
+) -> Result<(), Error> {
+    if VERIFY {
+        verify_parents_sets(
+            &basic_block_body.strong_parents,
+            &basic_block_body.weak_parents,
+            &basic_block_body.shallow_like_parents,
+        )?;
     }
 
-    fn unpack<U: Unpacker, const VERIFY: bool>(
-        unpacker: &mut U,
-        visitor: &Self::UnpackVisitor,
-    ) -> Result<Self, UnpackError<Self::UnpackError, U::Error>> {
-        let strong_parents = StrongParents::unpack::<_, VERIFY>(unpacker, &())?;
-        let weak_parents = WeakParents::unpack::<_, VERIFY>(unpacker, &())?;
-        let shallow_like_parents = ShallowLikeParents::unpack::<_, VERIFY>(unpacker, &())?;
-
-        if VERIFY {
-            verify_parents_sets(&strong_parents, &weak_parents, &shallow_like_parents)
-                .map_err(UnpackError::Packable)?;
-        }
-
-        let payload = OptionalPayload::unpack::<_, VERIFY>(unpacker, visitor)?;
-
-        let max_burned_mana = u64::unpack::<_, VERIFY>(unpacker, &()).coerce()?;
-
-        Ok(Self {
-            strong_parents,
-            weak_parents,
-            shallow_like_parents,
-            payload,
-            max_burned_mana,
-        })
-    }
+    Ok(())
 }
 
 #[cfg(feature = "serde")]
@@ -206,7 +178,7 @@ pub(crate) mod dto {
     use super::*;
     use crate::types::{
         block::{payload::dto::PayloadDto, BlockId, Error},
-        TryFromDto, ValidationParams,
+        TryFromDto,
     };
 
     #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
@@ -236,11 +208,13 @@ pub(crate) mod dto {
         }
     }
 
-    impl TryFromDto for BasicBlockBody {
-        type Dto = BasicBlockBodyDto;
+    impl TryFromDto<BasicBlockBodyDto> for BasicBlockBody {
         type Error = Error;
 
-        fn try_from_dto_with_params_inner(dto: Self::Dto, params: &ValidationParams<'_>) -> Result<Self, Self::Error> {
+        fn try_from_dto_with_params_inner(
+            dto: BasicBlockBodyDto,
+            params: Option<&ProtocolParameters>,
+        ) -> Result<Self, Self::Error> {
             BasicBlockBodyBuilder::new(StrongParents::from_set(dto.strong_parents)?, dto.max_burned_mana)
                 .with_weak_parents(WeakParents::from_set(dto.weak_parents)?)
                 .with_shallow_like_parents(ShallowLikeParents::from_set(dto.shallow_like_parents)?)