Add restricted and implicit address types

bindings/core/src/method_handler/account.rs

@@ -17,7 +17,7 @@ use crate::{method::AccountMethod, Response, Result};
 pub(crate) async fn call_account_method_internal(account: &Account, method: AccountMethod) -> Result<Response> {
     let response = match method {
         AccountMethod::Addresses => {
-            let addresses = account.addresses().await?;
+            let addresses = account.addresses().await;
             Response::Addresses(addresses)
         }
         AccountMethod::AddressesWithUnspentOutputs => {

bindings/core/src/method_handler/utils.rs

@@ -30,7 +30,7 @@ pub(crate) fn call_utils_method_internal(method: UtilsMethod) -> Result<Response
         UtilsMethod::HexPublicKeyToBech32Address { hex, bech32_hrp } => {
             Response::Bech32Address(hex_public_key_to_bech32_address(&hex, bech32_hrp)?)
         }
-        UtilsMethod::ParseBech32Address { address } => Response::ParsedBech32Address(Address::from(address.inner())),
+        UtilsMethod::ParseBech32Address { address } => Response::ParsedBech32Address(address.into_inner()),
         UtilsMethod::IsAddressValid { address } => Response::Bool(Address::is_valid_bech32(&address)),
         UtilsMethod::GenerateMnemonic => Response::GeneratedMnemonic(Client::generate_mnemonic()?.to_string()),
         UtilsMethod::MnemonicToHexSeed { mnemonic } => {

bindings/core/tests/utils.rs

@@ -14,7 +14,9 @@ async fn utils() -> Result<()> {
 
     let bech32_address =
         Bech32Address::try_from_str("rms1qpllaj0pyveqfkwxmnngz2c488hfdtmfrj3wfkgxtk4gtyrax0jaxzt70zy")?;
-    let method = UtilsMethod::Bech32ToHex { bech32: bech32_address };
+    let method = UtilsMethod::Bech32ToHex {
+        bech32: bech32_address.clone(),
+    };
 
     let response = call_utils_method(method);
     match response {

cli/src/command/account.rs

@@ -284,7 +284,7 @@ impl FromStr for TransactionSelector {
 
 /// `addresses` command
 pub async fn addresses_command(account: &Account) -> Result<(), Error> {
-    let addresses = account.addresses().await?;
+    let addresses = account.addresses().await;
 
     if addresses.is_empty() {
         println_log_info!("No addresses found");
@@ -547,8 +547,8 @@ pub async fn faucet_command(
     let address = if let Some(address) = address {
         address
     } else {
-        match account.addresses().await?.last() {
-            Some(address) => *address.address(),
+        match account.addresses().await.into_iter().rev().next() {
+            Some(address) => address.into_bech32(),
             None => return Err(Error::NoAddressForFaucet),
         }
     };

sdk/examples/client/02_address_balance.rs

@@ -31,19 +31,20 @@ async fn main() -> Result<()> {
     let secret_manager = SecretManager::try_from_mnemonic(std::env::var("MNEMONIC").unwrap())?;
 
     // Generate the first address
-    let addresses = secret_manager
+    let first_address = secret_manager
         .generate_ed25519_addresses(
             GetAddressesOptions::from_client(&client)
                 .await?
                 .with_account_index(0)
                 .with_range(0..1),
         )
-        .await?;
+        .await?[0]
+        .clone();
 
     // Get output ids of outputs that can be controlled by this address without further unlock constraints
     let output_ids_response = client
         .basic_output_ids([
-            QueryParameter::Address(addresses[0]),
+            QueryParameter::Address(first_address.clone()),
             QueryParameter::HasExpiration(false),
             QueryParameter::HasTimelock(false),
             QueryParameter::HasStorageDepositReturn(false),
@@ -65,7 +66,7 @@ async fn main() -> Result<()> {
 
     println!(
         "Outputs controlled by {} have: {:?}i and native tokens:\n{:#?}",
-        addresses[0],
+        first_address,
         total_amount,
         total_native_tokens.finish_vec()?
     );

sdk/examples/client/node_api_indexer/02_get_account_outputs.rs

@@ -42,7 +42,7 @@ async fn main() -> Result<()> {
     // Get output IDs of account outputs that can be controlled by this address.
     let output_ids_response = client
         .account_output_ids([
-            QueryParameter::Governor(address),
+            QueryParameter::Governor(address.clone()),
             QueryParameter::StateController(address),
         ])
         .await?;

sdk/examples/client/output/build_account_output.rs

@@ -45,11 +45,11 @@ async fn main() -> Result<()> {
     // Account id needs to be null the first time
     let account_output = AccountOutputBuilder::new_with_minimum_storage_deposit(rent_structure, AccountId::null())
         .with_state_metadata(metadata)
-        .add_feature(SenderFeature::new(address))
+        .add_feature(SenderFeature::new(address.clone()))
         .add_feature(MetadataFeature::new(metadata)?)
-        .add_immutable_feature(IssuerFeature::new(address))
+        .add_immutable_feature(IssuerFeature::new(address.clone()))
         .add_immutable_feature(MetadataFeature::new(metadata)?)
-        .add_unlock_condition(StateControllerAddressUnlockCondition::new(address))
+        .add_unlock_condition(StateControllerAddressUnlockCondition::new(address.clone()))
         .add_unlock_condition(GovernorAddressUnlockCondition::new(address))
         .finish_output(token_supply)?;
 

sdk/examples/client/output/build_basic_output.rs

@@ -43,8 +43,8 @@ async fn main() -> Result<()> {
         .unwrap_or("rms1qpllaj0pyveqfkwxmnngz2c488hfdtmfrj3wfkgxtk4gtyrax0jaxzt70zy".to_string());
     let address = Address::try_from_bech32(address)?;
 
-    let basic_output_builder =
-        BasicOutputBuilder::new_with_amount(1_000_000).add_unlock_condition(AddressUnlockCondition::new(address));
+    let basic_output_builder = BasicOutputBuilder::new_with_amount(1_000_000)
+        .add_unlock_condition(AddressUnlockCondition::new(address.clone()));
 
     let outputs = [
         // most simple output
@@ -58,15 +58,15 @@ async fn main() -> Result<()> {
         basic_output_builder
             .clone()
             .add_unlock_condition(StorageDepositReturnUnlockCondition::new(
-                address,
+                address.clone(),
                 1_000_000,
                 token_supply,
             )?)
             .finish_output(token_supply)?,
         // with expiration
         basic_output_builder
             .clone()
-            .add_unlock_condition(ExpirationUnlockCondition::new(address, 1)?)
+            .add_unlock_condition(ExpirationUnlockCondition::new(address.clone(), 1)?)
             .finish_output(token_supply)?,
         // with timelock
         basic_output_builder

sdk/examples/client/output/build_nft_output.rs

@@ -57,8 +57,8 @@ async fn main() -> Result<()> {
 
     // NftId needs to be null the first time
     let nft_output = NftOutputBuilder::new_with_minimum_storage_deposit(rent_structure, NftId::null())
-        .add_unlock_condition(AddressUnlockCondition::new(address))
-        .add_feature(SenderFeature::new(address))
+        .add_unlock_condition(AddressUnlockCondition::new(address.clone()))
+        .add_feature(SenderFeature::new(address.clone()))
         .add_feature(MetadataFeature::new(MUTABLE_METADATA)?)
         .add_feature(TagFeature::new(TAG)?)
         .add_immutable_feature(IssuerFeature::new(address))

sdk/examples/how_tos/accounts_and_addresses/check_balance.rs

@@ -31,7 +31,7 @@ async fn main() -> Result<()> {
     println!("ADDRESSES:");
     let explorer_url = std::env::var("EXPLORER_URL").ok();
     let prepended = explorer_url.map(|url| format!("{url}/addr/")).unwrap_or_default();
-    for address in account.addresses().await? {
+    for address in account.addresses().await {
         println!(" - {prepended}{}", address.address());
     }
 

sdk/examples/how_tos/accounts_and_addresses/consolidate_outputs.rs

@@ -49,7 +49,7 @@ async fn main() -> Result<()> {
         println!("OUTPUT #{i}");
         println!(
             "- address: {:?}\n- amount: {:?}\n- native tokens: {:?}",
-            output_data.address.to_bech32_unchecked("rms"),
+            output_data.address.clone().to_bech32_unchecked("rms"),
             output_data.output.amount(),
             output_data.output.native_tokens()
         )
@@ -85,7 +85,7 @@ async fn main() -> Result<()> {
         println!("OUTPUT #{i}");
         println!(
             "- address: {:?}\n- amount: {:?}\n- native tokens: {:?}",
-            output_data.address.to_bech32_unchecked("rms"),
+            output_data.address.clone().to_bech32_unchecked("rms"),
             output_data.output.amount(),
             output_data.output.native_tokens()
         )

sdk/examples/how_tos/accounts_and_addresses/create_address.rs

@@ -36,7 +36,7 @@ async fn main() -> Result<()> {
     let address_url = explorer_url.map(|url| format!("{url}/addr/")).unwrap_or_default();
 
     println!("Current addresses:");
-    for address in account.addresses().await? {
+    for address in account.addresses().await {
         println!(" - {address_url}{}", address.address());
     }
 
@@ -45,7 +45,7 @@ async fn main() -> Result<()> {
         .generate_ed25519_addresses(NUM_ADDRESSES_TO_GENERATE, None)
         .await?;
     println!("Generated {} new addresses:", new_addresses.len());
-    let account_addresses = account.addresses().await?;
+    let account_addresses = account.addresses().await;
     for new_address in new_addresses.iter() {
         assert!(account_addresses.contains(new_address));
         println!(" - {address_url}{}", new_address.address());

sdk/examples/how_tos/accounts_and_addresses/list_addresses.rs

@@ -21,7 +21,7 @@ async fn main() -> Result<()> {
         .await?;
     let account = wallet.get_account("Alice").await?;
 
-    for address in account.addresses().await? {
+    for address in account.addresses().await {
         println!("{}", address.address());
     }
 

sdk/examples/how_tos/nft_collection/01_mint_collection_nft.rs

@@ -62,7 +62,7 @@ async fn main() -> Result<()> {
             MintNftParams::new()
                 .with_immutable_metadata(get_immutable_metadata(index).to_bytes())
                 // The NFT address from the NFT we minted in mint_issuer_nft example
-                .with_issuer(issuer)
+                .with_issuer(issuer.clone())
         })
         .collect::<Vec<_>>();
 

sdk/examples/how_tos/nfts/mint_nft.rs

@@ -48,7 +48,7 @@ async fn main() -> Result<()> {
     account.sync(None).await?;
 
     // We send from the first address in the account.
-    let sender_address = *account.addresses().await?[0].address();
+    let sender_address = account.first_address_bech32().await;
 
     // Set the stronghold password
     wallet
@@ -66,10 +66,10 @@ async fn main() -> Result<()> {
 
     let nft_params = [MintNftParams::new()
         .try_with_address(NFT1_OWNER_ADDRESS)?
-        .try_with_sender(sender_address)?
+        .try_with_sender(sender_address.clone())?
         .with_metadata(NFT1_METADATA.as_bytes().to_vec())
         .with_tag(NFT1_TAG.as_bytes().to_vec())
-        .try_with_issuer(sender_address)?
+        .try_with_issuer(sender_address.clone())?
         .with_immutable_metadata(metadata.to_bytes())];
 
     let transaction = account.mint_nfts(nft_params, None).await?;
@@ -91,8 +91,8 @@ async fn main() -> Result<()> {
     let outputs = [
         // address of the owner of the NFT
         NftOutputBuilder::new_with_amount(NFT2_AMOUNT, NftId::null())
-            .add_unlock_condition(AddressUnlockCondition::new(sender_address))
-            .add_feature(SenderFeature::new(sender_address))
+            .add_unlock_condition(AddressUnlockCondition::new(sender_address.clone()))
+            .add_feature(SenderFeature::new(sender_address.clone()))
             .add_immutable_feature(IssuerFeature::new(sender_address))
             .finish_output(token_supply)?,
     ];

sdk/examples/how_tos/outputs/features.rs

@@ -37,13 +37,13 @@ async fn main() -> Result<()> {
     let address = Address::try_from_bech32("rms1qpllaj0pyveqfkwxmnngz2c488hfdtmfrj3wfkgxtk4gtyrax0jaxzt70zy")?;
 
     let nft_output_builder = NftOutputBuilder::new_with_minimum_storage_deposit(rent_structure, NftId::null())
-        .add_unlock_condition(AddressUnlockCondition::new(address));
+        .add_unlock_condition(AddressUnlockCondition::new(address.clone()));
 
     let outputs = [
         // with sender feature
         nft_output_builder
             .clone()
-            .add_feature(SenderFeature::new(address))
+            .add_feature(SenderFeature::new(address.clone()))
             .finish_output(token_supply)?,
         // with issuer feature
         nft_output_builder

sdk/examples/how_tos/outputs/unlock_conditions.rs

@@ -43,7 +43,7 @@ async fn main() -> Result<()> {
     let token_scheme = TokenScheme::Simple(SimpleTokenScheme::new(50, 0, 100)?);
 
     let basic_output_builder = BasicOutputBuilder::new_with_minimum_storage_deposit(rent_structure)
-        .add_unlock_condition(AddressUnlockCondition::new(address));
+        .add_unlock_condition(AddressUnlockCondition::new(address.clone()));
     let account_output_builder =
         AccountOutputBuilder::new_with_minimum_storage_deposit(rent_structure, AccountId::null());
     let foundry_output_builder =
@@ -56,7 +56,7 @@ async fn main() -> Result<()> {
         basic_output_builder
             .clone()
             .add_unlock_condition(StorageDepositReturnUnlockCondition::new(
-                address,
+                address.clone(),
                 1000000,
                 token_supply,
             )?)
@@ -68,11 +68,11 @@ async fn main() -> Result<()> {
             .finish_output(token_supply)?,
         // with expiration unlock condition
         basic_output_builder
-            .add_unlock_condition(ExpirationUnlockCondition::new(address, 1)?)
+            .add_unlock_condition(ExpirationUnlockCondition::new(address.clone(), 1)?)
             .finish_output(token_supply)?,
         // with governor and state controller unlock condition
         account_output_builder
-            .add_unlock_condition(GovernorAddressUnlockCondition::new(address))
+            .add_unlock_condition(GovernorAddressUnlockCondition::new(address.clone()))
             .add_unlock_condition(StateControllerAddressUnlockCondition::new(address))
             .finish_output(token_supply)?,
         // with immutable account unlock condition

sdk/examples/how_tos/simple_transaction/request_funds.rs

@@ -27,7 +27,7 @@ async fn main() -> Result<()> {
     let balance = account.sync(None).await?;
     println!("Account synced");
 
-    let addresses = account.addresses().await?;
+    let addresses = account.addresses().await;
 
     let funds_before = balance.base_coin().available();
     println!("Current available funds: {funds_before}");

sdk/examples/wallet/17_check_unlock_conditions.rs

@@ -35,15 +35,15 @@ async fn main() -> Result<()> {
 
     let account_addresses = account
         .addresses()
-        .await?
+        .await
         .into_iter()
-        .map(|a| *a.address())
+        .map(|a| a.into_bech32())
         .collect::<Vec<Bech32Address>>();
 
     println!("ADDRESSES:\n{:#?}", account_addresses);
 
     let output = BasicOutputBuilder::new_with_amount(AMOUNT)
-        .add_unlock_condition(AddressUnlockCondition::new(*account_addresses[0].as_ref()))
+        .add_unlock_condition(AddressUnlockCondition::new(account_addresses[0].as_ref().clone()))
         .finish_output(account.client().get_token_supply().await?)?;
 
     let controlled_by_account = if let [UnlockCondition::Address(address_unlock_condition)] = output

sdk/examples/wallet/accounts.rs

@@ -88,7 +88,7 @@ async fn main() -> Result<()> {
 
     println!("New available funds: {}", balance.base_coin().available());
 
-    let addresses = account2.addresses().await?;
+    let addresses = account2.addresses().await;
     println!("Number of addresses in {alias2}'s account: {}", addresses.len());
     println!("{alias2}'s base coin balance:\n{:#?}", balance.base_coin());
 

sdk/examples/wallet/background_syncing.rs

@@ -35,7 +35,7 @@ async fn main() -> Result<()> {
 
     // Get or create new account
     let account = wallet.get_or_create_account("Alice").await?;
-    let addresses = account.addresses().await?;
+    let addresses = account.addresses().await;
 
     // Manually sync to ensure we have the correct funds to start with
     let balance = account.sync(None).await?;

sdk/examples/wallet/getting_started.rs

@@ -49,7 +49,7 @@ async fn main() -> Result<()> {
         .finish()
         .await?;
 
-    let first_address = &account.addresses().await?[0];
+    let first_address = &account.addresses().await[0];
     println!("{}", first_address.address());
 
     Ok(())

sdk/examples/wallet/offline_signing/0_generate_addresses.rs

@@ -63,7 +63,7 @@ async fn main() -> Result<()> {
 async fn write_addresses_to_file(account: &Account) -> Result<()> {
     use tokio::io::AsyncWriteExt;
 
-    let addresses = account.addresses().await?;
+    let addresses = account.addresses().await;
     let json = serde_json::to_string_pretty(&addresses)?;
     let mut file = tokio::io::BufWriter::new(tokio::fs::File::create(ADDRESSES_FILE_PATH).await?);
     println!("example.addresses.json:\n{json}");

sdk/examples/wallet/spammer.rs

@@ -47,7 +47,7 @@ async fn main() -> Result<()> {
         .await?;
     let account = wallet.get_or_create_account(ACCOUNT_ALIAS).await?;
 
-    let recv_address = *account.addresses().await?[0].address();
+    let recv_address = account.first_address_bech32().await;
     println!("Recv address: {}", recv_address);
 
     // Ensure there are enough available funds for spamming.
@@ -71,7 +71,7 @@ async fn main() -> Result<()> {
         println!("Creating unspent outputs...");
 
         let transaction = account
-            .send_with_params(vec![SendParams::new(SEND_AMOUNT, recv_address)?; 127], None)
+            .send_with_params(vec![SendParams::new(SEND_AMOUNT, recv_address.clone())?; 127], None)
             .await?;
         wait_for_inclusion(&transaction.transaction_id, &account).await?;
 
@@ -87,6 +87,7 @@ async fn main() -> Result<()> {
 
         for n in 0..num_simultaneous_txs {
             let account_clone = account.clone();
+            let recv_address = recv_address.clone();
 
             tasks.spawn(async move {
                 println!("Thread {n}: sending {SEND_AMOUNT} coins to own address");