Add restricted and implicit address types

sdk/src/client/api/block_builder/input_selection/mod.rs

@@ -81,6 +81,7 @@ impl InputSelection {
                 AccountTransition::State,
             ))),
             Address::Nft(nft_address) => Ok(Some(Requirement::Nft(*nft_address.nft_id()))),
+            _ => todo!("What do we do here?"),
         }
     }
 

sdk/src/client/api/block_builder/input_selection/requirement/sender.rs

@@ -48,6 +48,7 @@ impl InputSelection {
                     Err(e) => Err(e),
                 }
             }
+            _ => todo!("What do we do here?"),
         }
     }
 }

sdk/src/client/secret/ledger_nano.rs

@@ -544,6 +544,7 @@ fn merge_unlocks(
                     merged_unlocks.push(Unlock::Reference(ReferenceUnlock::new(*block_index as u16)?));
                 }
                 Address::Nft(_nft) => merged_unlocks.push(Unlock::Nft(NftUnlock::new(*block_index as u16)?)),
+                _ => todo!("What do we do here?"),
             },
             None => {
                 // We can only sign ed25519 addresses and block_indexes needs to contain the account or nft

sdk/src/client/secret/mod.rs

@@ -532,6 +532,7 @@ where
                     blocks.push(Unlock::Reference(ReferenceUnlock::new(*block_index as u16)?));
                 }
                 Address::Nft(_nft) => blocks.push(Unlock::Nft(NftUnlock::new(*block_index as u16)?)),
+                _ => todo!("What do we do here?"),
             },
             None => {
                 // We can only sign ed25519 addresses and block_indexes needs to contain the account or nft

sdk/src/client/utils.rs

@@ -31,6 +31,7 @@ pub fn bech32_to_hex(bech32: impl ConvertTo<Bech32Address>) -> Result<String> {
         Address::Ed25519(ed) => ed.to_string(),
         Address::Account(account) => account.to_string(),
         Address::Nft(nft) => nft.to_string(),
+        _ => todo!("What do we do here?"),
     })
 }
 

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

@@ -5,6 +5,7 @@ use core::str::FromStr;
 
 use derive_more::{AsRef, Deref, From};
 
+use super::Restricted;
 use crate::types::block::{output::AccountId, Error};
 
 /// An account address.
@@ -37,6 +38,12 @@ impl AccountAddress {
     }
 }
 
+impl Restricted<AccountAddress> {
+    /// The [`Address`](crate::types::block::address::Address) kind of a
+    /// [`RestrictedAccountAddress`](Restricted<AccountAddress>).
+    pub const KIND: u8 = 9;
+}
+
 impl FromStr for AccountAddress {
     type Err = Error;
 
@@ -62,6 +69,7 @@ mod dto {
     use serde::{Deserialize, Serialize};
 
     use super::*;
+    use crate::types::block::address::dto::RestrictedDto;
 
     /// Describes an account address.
     #[derive(Serialize, Deserialize)]
@@ -88,4 +96,32 @@ mod dto {
     }
 
     impl_serde_typed_dto!(AccountAddress, AccountAddressDto, "account address");
+
+    impl From<&Restricted<AccountAddress>> for RestrictedDto<AccountAddressDto> {
+        fn from(value: &Restricted<AccountAddress>) -> Self {
+            Self {
+                address: AccountAddressDto {
+                    kind: Restricted::<AccountAddress>::KIND,
+                    account_id: value.address.0,
+                },
+                allowed_capabilities: value.allowed_capabilities.into_iter().map(|c| c.0).collect(),
+            }
+        }
+    }
+
+    impl From<RestrictedDto<AccountAddressDto>> for Restricted<AccountAddress> {
+        fn from(value: RestrictedDto<AccountAddressDto>) -> Self {
+            let mut res = Self::new(AccountAddress::from(value.address));
+            if let Some(allowed_capabilities) = value.allowed_capabilities.first() {
+                res = res.with_allowed_capabilities(*allowed_capabilities);
+            }
+            res
+        }
+    }
+
+    impl_serde_typed_dto!(
+        Restricted<AccountAddress>,
+        RestrictedDto<AccountAddressDto>,
+        "restricted account address"
+    );
 }

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

@@ -4,12 +4,14 @@
 use core::str::FromStr;
 
 use crypto::signatures::ed25519::PublicKey;
-use derive_more::{AsRef, Deref, From};
+use derive_more::{AsRef, Deref, Display, From, FromStr};
+use packable::Packable;
 
+use super::Restricted;
 use crate::types::block::Error;
 
 /// An Ed25519 address.
-#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash, From, AsRef, Deref, packable::Packable)]
+#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash, From, AsRef, Deref, Packable)]
 #[as_ref(forward)]
 pub struct Ed25519Address([u8; Self::LENGTH]);
 
@@ -26,6 +28,29 @@ impl Ed25519Address {
     }
 }
 
+impl Restricted<Ed25519Address> {
+    /// The [`Address`](crate::types::block::address::Address) kind of a
+    /// [`RestrictedEd25519Address`](Restricted<Ed25519Address>).
+    pub const KIND: u8 = 1;
+}
+
+/// An implicit account creation address that can be used to transition an account.
+#[derive(Copy, Clone, Debug, Display, Eq, PartialEq, Ord, PartialOrd, Hash, FromStr, AsRef, Deref, From, Packable)]
+#[as_ref(forward)]
+pub struct ImplicitAccountCreationAddress(Ed25519Address);
+impl ImplicitAccountCreationAddress {
+    /// The [`Address`](crate::types::block::address::Address) kind of an [`ImplicitAccountCreationAddress`].
+    pub const KIND: u8 = 24;
+    /// The length of an [`ImplicitAccountCreationAddress`].
+    pub const LENGTH: usize = Ed25519Address::LENGTH;
+
+    /// Creates a new [`ImplicitAccountCreationAddress`].
+    #[inline(always)]
+    pub fn new(address: [u8; Self::LENGTH]) -> Self {
+        Self(Ed25519Address::new(address))
+    }
+}
+
 impl FromStr for Ed25519Address {
     type Err = Error;
 
@@ -51,7 +76,7 @@ pub(crate) mod dto {
     use serde::{Deserialize, Serialize};
 
     use super::*;
-    use crate::utils::serde::prefix_hex_bytes;
+    use crate::{types::block::address::dto::RestrictedDto, utils::serde::prefix_hex_bytes};
 
     /// Describes an Ed25519 address.
     #[derive(Serialize, Deserialize)]
@@ -79,4 +104,63 @@ pub(crate) mod dto {
     }
 
     impl_serde_typed_dto!(Ed25519Address, Ed25519AddressDto, "ed25519 address");
+
+    impl From<&Restricted<Ed25519Address>> for RestrictedDto<Ed25519AddressDto> {
+        fn from(value: &Restricted<Ed25519Address>) -> Self {
+            Self {
+                address: Ed25519AddressDto {
+                    kind: Restricted::<Ed25519Address>::KIND,
+                    pub_key_hash: value.address.0,
+                },
+                allowed_capabilities: value.allowed_capabilities.into_iter().map(|c| c.0).collect(),
+            }
+        }
+    }
+
+    impl From<RestrictedDto<Ed25519AddressDto>> for Restricted<Ed25519Address> {
+        fn from(value: RestrictedDto<Ed25519AddressDto>) -> Self {
+            let mut res = Self::new(Ed25519Address::from(value.address));
+            if let Some(allowed_capabilities) = value.allowed_capabilities.first() {
+                res = res.with_allowed_capabilities(*allowed_capabilities);
+            }
+            res
+        }
+    }
+
+    impl_serde_typed_dto!(
+        Restricted<Ed25519Address>,
+        RestrictedDto<Ed25519AddressDto>,
+        "restricted ed25519 address"
+    );
+
+    /// Describes an Implicit Account Creation address.
+    #[derive(Serialize, Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    struct ImplicitAccountCreationAddressDto {
+        #[serde(rename = "type")]
+        kind: u8,
+        #[serde(with = "prefix_hex_bytes")]
+        pub_key_hash: [u8; Ed25519Address::LENGTH],
+    }
+
+    impl From<&ImplicitAccountCreationAddress> for ImplicitAccountCreationAddressDto {
+        fn from(value: &ImplicitAccountCreationAddress) -> Self {
+            Self {
+                kind: ImplicitAccountCreationAddress::KIND,
+                pub_key_hash: value.0.0,
+            }
+        }
+    }
+
+    impl From<ImplicitAccountCreationAddressDto> for ImplicitAccountCreationAddress {
+        fn from(value: ImplicitAccountCreationAddressDto) -> Self {
+            Self::new(value.pub_key_hash)
+        }
+    }
+
+    impl_serde_typed_dto!(
+        ImplicitAccountCreationAddress,
+        ImplicitAccountCreationAddressDto,
+        "implicit account creation address"
+    );
 }