Use owned data over refs for dto conversions

bindings/core/src/lib.rs

@@ -49,21 +49,21 @@ pub struct WalletOptions {
 }
 
 impl WalletOptions {
-    pub async fn build_manager(&self) -> iota_sdk::wallet::Result<Wallet> {
-        log::debug!("build_manager {self:?}");
+    pub async fn build(self) -> iota_sdk::wallet::Result<Wallet> {
+        log::debug!("wallet options: {self:?}");
         let mut builder = Wallet::builder();
 
         #[cfg(feature = "storage")]
         if let Some(storage_path) = &self.storage_path {
             builder = builder.with_storage_path(storage_path);
         }
 
-        if let Some(secret_manager) = &self.secret_manager {
+        if let Some(secret_manager) = self.secret_manager {
             builder = builder.with_secret_manager(SecretManager::try_from(secret_manager)?);
         }
 
-        if let Some(client_options) = &self.client_options {
-            builder = builder.with_client_options(client_options.clone());
+        if let Some(client_options) = self.client_options {
+            builder = builder.with_client_options(client_options);
         }
 
         if let Some(coin_type) = self.coin_type {

bindings/core/src/method_handler/account.rs

@@ -111,7 +111,7 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
             Response::Transactions(transactions.iter().map(TransactionDto::from).collect())
         }
         AccountMethod::MinimumRequiredStorageDeposit { output } => {
-            let output = Output::try_from_dto(&output, account.client().get_token_supply().await?)?;
+            let output = Output::try_from_dto(output, account.client().get_token_supply().await?)?;
             let rent_structure = account.client().get_rent_structure().await?;
 
             let minimum_storage_deposit = output.rent_cost(&rent_structure);
@@ -129,8 +129,8 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
         AccountMethod::PrepareBurn { burn, options } => {
             let data = account
                 .prepare_burn(
-                    Burn::try_from(&burn)?,
-                    options.as_ref().map(TransactionOptions::try_from_dto).transpose()?,
+                    Burn::try_from(burn)?,
+                    options.map(TransactionOptions::try_from_dto).transpose()?,
                 )
                 .await?;
             Response::PreparedTransaction(PreparedTransactionDataDto::from(&data))
@@ -145,15 +145,10 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
             Response::PreparedTransaction(PreparedTransactionDataDto::from(&data))
         }
         AccountMethod::PrepareCreateAliasOutput { params, options } => {
-            let params = params
-                .map(|options| CreateAliasParams::try_from(&options))
-                .transpose()?;
+            let params = params.map(CreateAliasParams::try_from).transpose()?;
 
             let data = account
-                .prepare_create_alias_output(
-                    params,
-                    options.as_ref().map(TransactionOptions::try_from_dto).transpose()?,
-                )
+                .prepare_create_alias_output(params, options.map(TransactionOptions::try_from_dto).transpose()?)
                 .await?;
             Response::PreparedTransaction(PreparedTransactionDataDto::from(&data))
         }
@@ -166,7 +161,7 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
                 .prepare_decrease_native_token_supply(
                     token_id,
                     U256::try_from(&melt_amount).map_err(|_| Error::InvalidField("melt_amount"))?,
-                    options.as_ref().map(TransactionOptions::try_from_dto).transpose()?,
+                    options.map(TransactionOptions::try_from_dto).transpose()?,
                 )
                 .await?;
             Response::PreparedTransaction(PreparedTransactionDataDto::from(&data))
@@ -189,7 +184,7 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
                 .prepare_increase_native_token_supply(
                     token_id,
                     U256::try_from(&mint_amount).map_err(|_| Error::InvalidField("mint_amount"))?,
-                    options.as_ref().map(TransactionOptions::try_from_dto).transpose()?,
+                    options.map(TransactionOptions::try_from_dto).transpose()?,
                 )
                 .await?;
             Response::PreparedMintTokenTransaction(PreparedMintTokenTransactionDto::from(&data))
@@ -207,19 +202,19 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
             let data = account
                 .prepare_mint_nfts(
                     params
-                        .iter()
+                        .into_iter()
                         .map(MintNftParams::try_from)
                         .collect::<iota_sdk::wallet::Result<Vec<MintNftParams>>>()?,
-                    options.as_ref().map(TransactionOptions::try_from_dto).transpose()?,
+                    options.map(TransactionOptions::try_from_dto).transpose()?,
                 )
                 .await?;
             Response::PreparedTransaction(PreparedTransactionDataDto::from(&data))
         }
         AccountMethod::PrepareMintNativeToken { params, options } => {
             let data = account
                 .prepare_mint_native_token(
-                    MintNativeTokenParams::try_from(&params)?,
-                    options.as_ref().map(TransactionOptions::try_from_dto).transpose()?,
+                    MintNativeTokenParams::try_from(params)?,
+                    options.map(TransactionOptions::try_from_dto).transpose()?,
                 )
                 .await?;
             Response::PreparedMintTokenTransaction(PreparedMintTokenTransactionDto::from(&data))
@@ -230,29 +225,23 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
         } => {
             let output = account
                 .prepare_output(
-                    OutputParams::try_from(options.as_ref())?,
-                    transaction_options
-                        .as_ref()
-                        .map(TransactionOptions::try_from_dto)
-                        .transpose()?,
+                    OutputParams::try_from(*options)?,
+                    transaction_options.map(TransactionOptions::try_from_dto).transpose()?,
                 )
                 .await?;
             Response::Output(OutputDto::from(&output))
         }
         AccountMethod::PrepareSendAmount { params, options } => {
             let data = account
-                .prepare_send_amount(
-                    params,
-                    options.as_ref().map(TransactionOptions::try_from_dto).transpose()?,
-                )
+                .prepare_send_amount(params, options.map(TransactionOptions::try_from_dto).transpose()?)
                 .await?;
             Response::PreparedTransaction(PreparedTransactionDataDto::from(&data))
         }
         AccountMethod::PrepareSendNativeTokens { params, options } => {
             let data = account
                 .prepare_send_native_tokens(
                     params.clone(),
-                    options.as_ref().map(TransactionOptions::try_from_dto).transpose()?,
+                    options.map(TransactionOptions::try_from_dto).transpose()?,
                 )
                 .await?;
             Response::PreparedTransaction(PreparedTransactionDataDto::from(&data))
@@ -261,7 +250,7 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
             let data = account
                 .prepare_send_nft(
                     params.clone(),
-                    options.as_ref().map(TransactionOptions::try_from_dto).transpose()?,
+                    options.map(TransactionOptions::try_from_dto).transpose()?,
                 )
                 .await?;
             Response::PreparedTransaction(PreparedTransactionDataDto::from(&data))
@@ -276,10 +265,10 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
             let data = account
                 .prepare_transaction(
                     outputs
-                        .iter()
+                        .into_iter()
                         .map(|o| Ok(Output::try_from_dto(o, token_supply)?))
                         .collect::<Result<Vec<Output>>>()?,
-                    options.as_ref().map(TransactionOptions::try_from_dto).transpose()?,
+                    options.map(TransactionOptions::try_from_dto).transpose()?,
                 )
                 .await?;
             Response::PreparedTransaction(PreparedTransactionDataDto::from(&data))
@@ -306,10 +295,7 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
         }
         AccountMethod::SendAmount { params, options } => {
             let transaction = account
-                .send_amount(
-                    params,
-                    options.as_ref().map(TransactionOptions::try_from_dto).transpose()?,
-                )
+                .send_amount(params, options.map(TransactionOptions::try_from_dto).transpose()?)
                 .await?;
             Response::SentTransaction(TransactionDto::from(&transaction))
         }
@@ -318,10 +304,10 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
             let transaction = account
                 .send(
                     outputs
-                        .iter()
+                        .into_iter()
                         .map(|o| Ok(Output::try_from_dto(o, token_supply)?))
                         .collect::<iota_sdk::wallet::Result<Vec<Output>>>()?,
-                    options.as_ref().map(TransactionOptions::try_from_dto).transpose()?,
+                    options.map(TransactionOptions::try_from_dto).transpose()?,
                 )
                 .await?;
             Response::SentTransaction(TransactionDto::from(&transaction))
@@ -339,7 +325,7 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
         } => {
             let transaction = account
                 .sign_and_submit_transaction(PreparedTransactionData::try_from_dto(
-                    &prepared_transaction_data,
+                    prepared_transaction_data,
                     &account.client().get_protocol_parameters().await?,
                 )?)
                 .await?;
@@ -350,7 +336,7 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
         } => {
             let signed_transaction_data = account
                 .sign_transaction_essence(&PreparedTransactionData::try_from_dto(
-                    &prepared_transaction_data,
+                    prepared_transaction_data,
                     &account.client().get_protocol_parameters().await?,
                 )?)
                 .await?;
@@ -360,7 +346,7 @@ pub(crate) async fn call_account_method_internal(account: &Account, method: Acco
             signed_transaction_data,
         } => {
             let signed_transaction_data = SignedTransactionData::try_from_dto(
-                &signed_transaction_data,
+                signed_transaction_data,
                 &account.client().get_protocol_parameters().await?,
             )?;
             let transaction = account.submit_and_store_transaction(signed_transaction_data).await?;

bindings/core/src/method_handler/client.rs

@@ -137,7 +137,7 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
                 },
                 native_tokens,
                 serial_number,
-                &token_scheme,
+                token_scheme,
                 unlock_conditions,
                 features,
                 immutable_features,
@@ -178,7 +178,7 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
             let mut block_builder = client.block();
 
             let secret_manager = match secret_manager {
-                Some(secret_manager) => Some((&secret_manager).try_into()?),
+                Some(secret_manager) => Some(secret_manager.try_into()?),
                 None => None,
             };
 
@@ -232,7 +232,7 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
             let mut block_builder = client.block();
 
             let secret_manager = match secret_manager {
-                Some(secret_manager) => Some((&secret_manager).try_into()?),
+                Some(secret_manager) => Some(secret_manager.try_into()?),
                 None => None,
             };
 
@@ -254,14 +254,14 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
         } => {
             let mut block_builder = client.block();
 
-            let secret_manager = (&secret_manager).try_into()?;
+            let secret_manager = secret_manager.try_into()?;
 
             block_builder = block_builder.with_secret_manager(&secret_manager);
 
             Response::SignedTransaction(PayloadDto::from(
                 &block_builder
                     .sign_transaction(PreparedTransactionData::try_from_dto_unverified(
-                        &prepared_transaction_data,
+                        prepared_transaction_data,
                     )?)
                     .await?,
             ))
@@ -271,7 +271,7 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
 
             let block = block_builder
                 .finish_block(Some(Payload::try_from_dto(
-                    &payload,
+                    payload,
                     &client.get_protocol_parameters().await?,
                 )?))
                 .await?;
@@ -297,7 +297,7 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
         ),
         ClientMethod::PostBlock { block } => Response::BlockId(
             client
-                .post_block(&Block::try_from_dto(&block, &client.get_protocol_parameters().await?)?)
+                .post_block(&Block::try_from_dto(block, &client.get_protocol_parameters().await?)?)
                 .await?,
         ),
         ClientMethod::GetBlock { block_id } => Response::Block(BlockDto::from(&client.get_block(&block_id).await?)),
@@ -404,7 +404,7 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
             secret_manager,
             generate_addresses_options,
         } => {
-            let secret_manager = (&secret_manager).try_into()?;
+            let secret_manager = secret_manager.try_into()?;
             Response::ConsolidatedFunds(
                 client
                     .consolidate_funds(&secret_manager, generate_addresses_options)

bindings/core/src/method_handler/secret_manager.rs

@@ -41,7 +41,7 @@ pub(crate) async fn call_secret_manager_method_internal(
         } => {
             let payload = &secret_manager
                 .sign_transaction(PreparedTransactionData::try_from_dto_unverified(
-                    &prepared_transaction_data,
+                    prepared_transaction_data,
                 )?)
                 .await?;
             Response::SignedTransaction(PayloadDto::from(payload))

bindings/core/src/method_handler/utils.rs

@@ -36,11 +36,11 @@ pub(crate) fn call_utils_method_internal(method: UtilsMethod) -> Result<Response
             response
         }
         UtilsMethod::BlockId { block } => {
-            let block = Block::try_from_dto_unverified(&block)?;
+            let block = Block::try_from_dto_unverified(block)?;
             Response::BlockId(block.id())
         }
         UtilsMethod::TransactionId { payload } => {
-            let payload = TransactionPayload::try_from_dto_unverified(&payload)?;
+            let payload = TransactionPayload::try_from_dto_unverified(payload)?;
             Response::TransactionId(payload.id())
         }
         UtilsMethod::ComputeAliasId { output_id } => Response::AliasId(AliasId::from(&output_id)),
@@ -51,16 +51,16 @@ pub(crate) fn call_utils_method_internal(method: UtilsMethod) -> Result<Response
             token_scheme_kind,
         } => Response::FoundryId(FoundryId::build(&alias_address, serial_number, token_scheme_kind)),
         UtilsMethod::HashTransactionEssence { essence } => Response::TransactionEssenceHash(prefix_hex::encode(
-            TransactionEssence::try_from_dto_unverified(&essence)?.hash(),
+            TransactionEssence::try_from_dto_unverified(essence)?.hash(),
         )),
         UtilsMethod::VerifyEd25519Signature {
             signature,
             message,
             address,
         } => {
-            let signature = Ed25519Signature::try_from(&signature)?;
+            let signature = Ed25519Signature::try_from(signature)?;
             let msg: Vec<u8> = prefix_hex::decode(message)?;
-            let address = Ed25519Address::try_from(&address)?;
+            let address = Ed25519Address::try_from(address)?;
             Response::Bool(signature.is_valid(&msg, &address).is_ok())
         }
         UtilsMethod::VerifyMnemonic { mut mnemonic } => {

bindings/core/tests/combined.rs

@@ -32,7 +32,7 @@ async fn create_account() -> Result<()> {
         secret_manager: Some(serde_json::from_str(secret_manager).unwrap()),
     };
 
-    let wallet = options.build_manager().await?;
+    let wallet = options.build().await?;
 
     // create an account
     let response = wallet
@@ -90,7 +90,7 @@ async fn verify_accounts() -> Result<()> {
         secret_manager: Some(serde_json::from_str(secret_manager).unwrap()),
     };
 
-    let wallet = options.build_manager().await?;
+    let wallet = options.build().await?;
 
     let mut account_details = BTreeMap::new();
     let mut handle_response = |response| match response {
@@ -198,7 +198,7 @@ async fn client_from_wallet() -> Result<()> {
         secret_manager: Some(serde_json::from_str(secret_manager).unwrap()),
     };
 
-    let wallet = options.build_manager().await?;
+    let wallet = options.build().await?;
 
     // create an account
     let response = wallet

bindings/nodejs/src/secret_manager.rs

@@ -22,7 +22,7 @@ impl SecretManagerMethodHandler {
     fn new(channel: Channel, options: String) -> Arc<Self> {
         let secret_manager_dto =
             serde_json::from_str::<SecretManagerDto>(&options).expect("error initializing secret manager");
-        let secret_manager = SecretManager::try_from(&secret_manager_dto).expect("error initializing secret manager");
+        let secret_manager = SecretManager::try_from(secret_manager_dto).expect("error initializing secret manager");
 
         Arc::new(Self {
             channel,

bindings/nodejs/src/wallet.rs

@@ -34,7 +34,7 @@ impl WalletMethodHandler {
         let wallet_options = serde_json::from_str::<WalletOptions>(&options)?;
 
         let wallet = crate::RUNTIME
-            .block_on(async move { wallet_options.build_manager().await })
+            .block_on(async move { wallet_options.build().await })
             .expect("error initializing wallet");
 
         Ok(Self { channel, wallet })

bindings/python/src/secret_manager.rs

@@ -22,7 +22,7 @@ pub struct SecretManager {
 #[pyfunction]
 pub fn create_secret_manager(options: String) -> Result<SecretManager> {
     let secret_manager_dto = serde_json::from_str::<SecretManagerDto>(&options)?;
-    let secret_manager = RustSecretManager::try_from(&secret_manager_dto)?;
+    let secret_manager = RustSecretManager::try_from(secret_manager_dto)?;
     Ok(SecretManager {
         secret_manager: Arc::new(RwLock::new(secret_manager)),
     })

bindings/python/src/wallet.rs

@@ -35,7 +35,7 @@ pub fn destroy_wallet(wallet: &Wallet) -> PyResult<()> {
 #[pyfunction]
 pub fn create_wallet(options: String) -> Result<Wallet> {
     let wallet_options = serde_json::from_str::<WalletOptions>(&options)?;
-    let wallet = crate::block_on(async { wallet_options.build_manager().await })?;
+    let wallet = crate::block_on(async { wallet_options.build().await })?;
 
     Ok(Wallet {
         wallet: Arc::new(RwLock::new(Some(wallet))),