refactor(wasm-dpp2,wasm-sdk): reorder operations to eliminate options.clone()

Reorder constructor operations to extract complex types first (borrowing &options),
then call serde_wasm_bindgen::from_value(options.into()) last (consuming options).
This eliminates unnecessary .clone() calls on options objects since try_from_options
borrows while serde consumes.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: shumkov

packages/wasm-dpp2/src/asset_lock_proof/proof.rs

@@ -7,9 +7,9 @@ use crate::identifier::IdentifierWasm;
 use crate::impl_try_from_js_value;
 use crate::impl_try_from_options;
 use crate::impl_wasm_type_info;
-use crate::utils::{IntoWasm, get_class_type, try_from_options, try_to_object};
+use crate::utils::{IntoWasm, get_class_type, try_from_options};
 use dpp::prelude::AssetLockProof;
-use js_sys::{Object, Reflect};
+use js_sys::Reflect;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(typescript_custom_section)]
@@ -184,26 +184,24 @@ impl AssetLockProofWasm {
         };
 
         // Add type field: 0 = Instant, 1 = Chain
-        let object = Object::from(inner_object);
         let proof_type: u8 = match &self.0 {
             AssetLockProof::Instant(_) => 0,
             AssetLockProof::Chain(_) => 1,
         };
         Reflect::set(
-            &object,
+            &inner_object,
             &JsValue::from_str("type"),
             &JsValue::from(proof_type),
         )
         .map_err(|e| WasmDppError::serialization(format!("{:?}", e)))?;
 
-        Ok(JsValue::from(object).into())
+        Ok(inner_object.into())
     }
 
     #[wasm_bindgen(js_name = "fromObject")]
     pub fn from_object(object: AssetLockProofObjectJs) -> WasmDppResult<AssetLockProofWasm> {
         let js_value: JsValue = object.into();
-        let object = try_to_object(js_value.clone(), "object")?;
-        let proof_type: AssetLockProofTypeWasm = try_from_options(&object, "type")?;
+        let proof_type: AssetLockProofTypeWasm = try_from_options(&js_value, "type")?;
 
         match proof_type {
             AssetLockProofTypeWasm::Instant => {
@@ -228,26 +226,24 @@ impl AssetLockProofWasm {
         };
 
         // Add type field: 0 = Instant, 1 = Chain
-        let object = Object::from(inner_json);
         let proof_type: u8 = match &self.0 {
             AssetLockProof::Instant(_) => 0,
             AssetLockProof::Chain(_) => 1,
         };
         Reflect::set(
-            &object,
+            &inner_json,
             &JsValue::from_str("type"),
             &JsValue::from(proof_type),
         )
         .map_err(|e| WasmDppError::serialization(format!("{:?}", e)))?;
 
-        Ok(JsValue::from(object).into())
+        Ok(inner_json.into())
     }
 
     #[wasm_bindgen(js_name = "fromJSON")]
     pub fn from_json(object: AssetLockProofJSONJs) -> WasmDppResult<AssetLockProofWasm> {
         let js_value: JsValue = object.into();
-        let object = try_to_object(js_value.clone(), "json")?;
-        let proof_type: AssetLockProofTypeWasm = try_from_options(&object, "type")?;
+        let proof_type: AssetLockProofTypeWasm = try_from_options(&js_value, "type")?;
 
         match proof_type {
             AssetLockProofTypeWasm::Instant => {

packages/wasm-dpp2/src/data_contract/document/model.rs

@@ -7,7 +7,7 @@ use crate::impl_wasm_type_info;
 use crate::serialization;
 use crate::utils::{
     ToSerdeJSONExt, try_from_options_optional_with, try_from_options_with, try_to_fixed_bytes,
-    try_to_object, try_to_string,
+    try_to_string,
 };
 use crate::version::{PlatformVersionLikeJs, PlatformVersionWasm};
 use dpp::document::serialization_traits::{
@@ -190,31 +190,28 @@ struct DocumentOptionsInput {
 impl DocumentWasm {
     #[wasm_bindgen(constructor)]
     pub fn constructor(options: DocumentOptionsJs) -> WasmDppResult<DocumentWasm> {
-        let options_value: JsValue = options.into();
-        let options_obj = try_to_object(options_value.clone(), "options")?;
-
-        // Deserialize fields via serde (includes IdentifierWasm)
-        let input: DocumentOptionsInput = serde_wasm_bindgen::from_value(options_value)
-            .map_err(|e| WasmDppError::invalid_argument(e.to_string()))?;
-
-        let data_contract_id: Identifier = input.data_contract_id.into();
-        let owner_id: Identifier = input.owner_id.into();
-        let revision = input.revision.unwrap_or(1);
-
-        // Extract complex types that don't have Deserialize
-        let document_type_name = try_from_options_with(&options_obj, "documentTypeName", |v| {
+        // Extract complex types first (borrows &options)
+        let document_type_name = try_from_options_with(&options, "documentTypeName", |v| {
             try_to_string(v, "documentTypeName")
         })?;
 
-        let properties = try_from_options_with(&options_obj, "properties", |v| {
+        let properties = try_from_options_with(&options, "properties", |v| {
             v.with_serde_to_platform_value_map()
         })?;
 
         let entropy: Option<[u8; 32]> =
-            try_from_options_optional_with(&options_obj, "entropy", |v| {
+            try_from_options_optional_with(&options, "entropy", |v| {
                 try_to_fixed_bytes::<32>(v.clone(), "entropy")
             })?;
 
+        // Deserialize simple fields via serde last (consumes options)
+        let input: DocumentOptionsInput = serde_wasm_bindgen::from_value(options.into())
+            .map_err(|e| WasmDppError::invalid_argument(e.to_string()))?;
+
+        let data_contract_id: Identifier = input.data_contract_id.into();
+        let owner_id: Identifier = input.owner_id.into();
+        let revision = input.revision.unwrap_or(1);
+
         let entropy: [u8; 32] = entropy.map_or_else(
             || {
                 entropy_generator::DefaultEntropyGenerator

packages/wasm-dpp2/src/data_contract/model.rs

@@ -170,39 +170,36 @@ pub fn tokens_configuration_from_js_value(
 impl DataContractWasm {
     #[wasm_bindgen(constructor)]
     pub fn constructor(options: DataContractOptionsJs) -> WasmDppResult<DataContractWasm> {
-        let options: JsValue = options.into();
-        let object = try_to_object(options.clone(), "options")?;
-
         // Extract ownerId (required)
-        let owner_id: IdentifierWasm = try_from_options(&object, "ownerId")?;
+        let owner_id: IdentifierWasm = try_from_options(&options, "ownerId")?;
 
         // Extract schemas (required)
-        let schema: Value = try_from_options_with(&object, "schemas", |v| {
+        let schema: Value = try_from_options_with(&options, "schemas", |v| {
             serialization::platform_value_from_object(v)
         })?;
 
         // Extract definitions (optional)
         let definitions: Option<Value> = try_from_options_optional_with(
-            &object,
+            &options,
             "definitions",
             serialization::platform_value_from_object,
         )?;
 
         // Extract tokens (optional)
         let tokens: BTreeMap<TokenContractPosition, TokenConfiguration> =
-            try_from_options_optional_with(&object, "tokens", |v| {
+            try_from_options_optional_with(&options, "tokens", |v| {
                 tokens_configuration_from_js_value(v)
             })?
             .unwrap_or_default();
 
         // Extract platformVersion (optional)
         let platform_version: PlatformVersion =
-            try_from_options_optional::<PlatformVersionWasm>(&object, "platformVersion")?
+            try_from_options_optional::<PlatformVersionWasm>(&options, "platformVersion")?
                 .map(Into::into)
                 .unwrap_or_else(|| PlatformVersionWasm::default().into());
 
         // Extract simple fields via serde
-        let opts: DataContractOptions = serde_wasm_bindgen::from_value(options)
+        let opts: DataContractOptions = serde_wasm_bindgen::from_value(options.into())
             .map_err(|e| WasmDppError::invalid_argument(e.to_string()))?;
 
         let data_contract_structure_version_value = Value::from(

packages/wasm-dpp2/src/epoch/finalized_epoch_info.rs

@@ -2,9 +2,7 @@ use crate::error::{WasmDppError, WasmDppResult};
 use crate::identifier::IdentifierWasm;
 use crate::impl_from_for_extern_type;
 use crate::impl_wasm_type_info;
-use crate::utils::{
-    JsMapExt, try_from_options_with, try_to_map, try_to_object, try_to_u32, try_to_u64,
-};
+use crate::utils::{JsMapExt, try_from_options_with, try_to_map, try_to_u32, try_to_u64};
 use dpp::block::finalized_epoch_info::FinalizedEpochInfo;
 use dpp::block::finalized_epoch_info::v0::FinalizedEpochInfoV0;
 use dpp::block::finalized_epoch_info::v0::getters::FinalizedEpochInfoGettersV0;
@@ -161,51 +159,49 @@ impl FinalizedEpochInfoWasm {
     pub fn constructor(
         options: FinalizedEpochInfoOptionsJs,
     ) -> WasmDppResult<FinalizedEpochInfoWasm> {
-        let options_obj = try_to_object(options.into(), "options")?;
-
-        let first_block_time = try_from_options_with(&options_obj, "firstBlockTime", |v| {
+        let first_block_time = try_from_options_with(&options, "firstBlockTime", |v| {
             try_to_u64(v, "firstBlockTime")
         })?;
 
-        let first_block_height = try_from_options_with(&options_obj, "firstBlockHeight", |v| {
+        let first_block_height = try_from_options_with(&options, "firstBlockHeight", |v| {
             try_to_u64(v, "firstBlockHeight")
         })?;
 
         let total_blocks_in_epoch =
-            try_from_options_with(&options_obj, "totalBlocksInEpoch", |v| {
+            try_from_options_with(&options, "totalBlocksInEpoch", |v| {
                 try_to_u64(v, "totalBlocksInEpoch")
             })?;
 
         let first_core_block_height =
-            try_from_options_with(&options_obj, "firstCoreBlockHeight", |v| {
+            try_from_options_with(&options, "firstCoreBlockHeight", |v| {
                 try_to_u32(v, "firstCoreBlockHeight")
             })?;
 
         let next_epoch_start_core_block_height =
-            try_from_options_with(&options_obj, "nextEpochStartCoreBlockHeight", |v| {
+            try_from_options_with(&options, "nextEpochStartCoreBlockHeight", |v| {
                 try_to_u32(v, "nextEpochStartCoreBlockHeight")
             })?;
 
         let total_processing_fees =
-            try_from_options_with(&options_obj, "totalProcessingFees", |v| {
+            try_from_options_with(&options, "totalProcessingFees", |v| {
                 try_to_u64(v, "totalProcessingFees")
             })?;
 
         let total_distributed_storage_fees =
-            try_from_options_with(&options_obj, "totalDistributedStorageFees", |v| {
+            try_from_options_with(&options, "totalDistributedStorageFees", |v| {
                 try_to_u64(v, "totalDistributedStorageFees")
             })?;
 
         let total_created_storage_fees =
-            try_from_options_with(&options_obj, "totalCreatedStorageFees", |v| {
+            try_from_options_with(&options, "totalCreatedStorageFees", |v| {
                 try_to_u64(v, "totalCreatedStorageFees")
             })?;
 
-        let core_block_rewards = try_from_options_with(&options_obj, "coreBlockRewards", |v| {
+        let core_block_rewards = try_from_options_with(&options, "coreBlockRewards", |v| {
             try_to_u64(v, "coreBlockRewards")
         })?;
 
-        let block_proposers = try_from_options_with(&options_obj, "blockProposers", |v| {
+        let block_proposers = try_from_options_with(&options, "blockProposers", |v| {
             if !v.is_instance_of::<Map>() {
                 return Err(WasmDppError::invalid_argument(
                     "'blockProposers' must be a Map",
@@ -215,11 +211,11 @@ impl FinalizedEpochInfoWasm {
         })?;
 
         let fee_multiplier_permille =
-            try_from_options_with(&options_obj, "feeMultiplierPermille", |v| {
+            try_from_options_with(&options, "feeMultiplierPermille", |v| {
                 try_to_u64(v, "feeMultiplierPermille")
             })?;
 
-        let protocol_version = try_from_options_with(&options_obj, "protocolVersion", |v| {
+        let protocol_version = try_from_options_with(&options, "protocolVersion", |v| {
             try_to_u32(v, "protocolVersion")
         })?;
 
@@ -386,7 +382,7 @@ impl FinalizedEpochInfoWasm {
         #[wasm_bindgen(js_name = "blockProposers")] block_proposers: BlockProposersMapJs,
     ) -> WasmDppResult<()> {
         let block_proposers_map =
-            block_proposers_from_map(&try_to_map(block_proposers.into(), "blockProposers")?)?;
+            block_proposers_from_map(&try_to_map(block_proposers, "blockProposers")?)?;
         self.v0_mut().block_proposers = block_proposers_map;
         Ok(())
     }

packages/wasm-dpp2/src/identity/partial_identity.rs

@@ -76,24 +76,22 @@ impl From<PartialIdentity> for PartialIdentityWasm {
 impl PartialIdentityWasm {
     #[wasm_bindgen(constructor)]
     pub fn constructor(options: PartialIdentityOptionsJs) -> WasmDppResult<Self> {
-        let options_obj = try_to_object(options.into(), "options")?;
+        let id: IdentifierWasm = try_from_options(&options, "id")?;
 
-        let id: IdentifierWasm = try_from_options(&options_obj, "id")?;
-
-        let loaded_public_keys = try_from_options_with(&options_obj, "loadedPublicKeys", |v| {
+        let loaded_public_keys = try_from_options_with(&options, "loadedPublicKeys", |v| {
             value_to_loaded_public_keys(v)
         })?;
 
         let balance: Option<Credits> =
-            try_from_options_optional_with(&options_obj, "balance", |v| try_to_u64(v, "balance"))?;
+            try_from_options_optional_with(&options, "balance", |v| try_to_u64(v, "balance"))?;
 
         let revision: Option<Revision> =
-            try_from_options_optional_with(&options_obj, "revision", |v| {
+            try_from_options_optional_with(&options, "revision", |v| {
                 try_to_u64(v, "revision")
             })?;
 
         let not_found_public_keys: Option<Array> =
-            try_from_options_optional_with(&options_obj, "notFoundPublicKeys", |v| {
+            try_from_options_optional_with(&options, "notFoundPublicKeys", |v| {
                 try_to_array(v, "notFoundPublicKeys")
             })?;
         let not_found_keys: BTreeSet<KeyID> = option_array_to_not_found(not_found_public_keys)?;
@@ -211,29 +209,29 @@ impl PartialIdentityWasm {
 
     #[wasm_bindgen(js_name = "fromObject")]
     pub fn from_object(obj: PartialIdentityObjectJs) -> WasmDppResult<PartialIdentityWasm> {
-        let options_obj = try_to_object(obj, "obj")?;
+        let obj: JsValue = obj.into();
 
         // id - can be Uint8Array or Identifier
-        let id: IdentifierWasm = try_from_options(&options_obj, "id")?;
+        let id: IdentifierWasm = try_from_options(&obj, "id")?;
 
         // loadedPublicKeys - values are plain objects
-        let loaded_public_keys = try_from_options_with(&options_obj, "loadedPublicKeys", |v| {
+        let loaded_public_keys = try_from_options_with(&obj, "loadedPublicKeys", |v| {
             value_to_loaded_public_keys_from_object(v)
         })?;
 
         // balance - can be BigInt, number, or undefined
         let balance: Option<Credits> =
-            try_from_options_optional_with(&options_obj, "balance", |v| try_to_u64(v, "balance"))?;
+            try_from_options_optional_with(&obj, "balance", |v| try_to_u64(v, "balance"))?;
 
         // revision - can be BigInt, number, or undefined
         let revision: Option<Revision> =
-            try_from_options_optional_with(&options_obj, "revision", |v| {
+            try_from_options_optional_with(&obj, "revision", |v| {
                 try_to_u64(v, "revision")
             })?;
 
         // notFoundPublicKeys
         let not_found_public_keys: Option<Array> =
-            try_from_options_optional_with(&options_obj, "notFoundPublicKeys", |v| {
+            try_from_options_optional_with(&obj, "notFoundPublicKeys", |v| {
                 try_to_array(v, "notFoundPublicKeys")
             })?;
         let not_found_keys: BTreeSet<KeyID> = option_array_to_not_found(not_found_public_keys)?;
@@ -249,29 +247,29 @@ impl PartialIdentityWasm {
 
     #[wasm_bindgen(js_name = "fromJSON")]
     pub fn from_json(json: PartialIdentityJSONJs) -> WasmDppResult<PartialIdentityWasm> {
-        let options_obj = try_to_object(json, "json")?;
+        let json: JsValue = json.into();
 
         // id - base58 string
-        let id: IdentifierWasm = try_from_options(&options_obj, "id")?;
+        let id: IdentifierWasm = try_from_options(&json, "id")?;
 
         // loadedPublicKeys - values are JSON objects
-        let loaded_public_keys = try_from_options_with(&options_obj, "loadedPublicKeys", |v| {
+        let loaded_public_keys = try_from_options_with(&json, "loadedPublicKeys", |v| {
             value_to_loaded_public_keys_from_json(v)
         })?;
 
         // balance - can be BigInt, number, or string (JSON doesn't support BigInt natively)
         let balance: Option<Credits> =
-            try_from_options_optional_with(&options_obj, "balance", |v| try_to_u64(v, "balance"))?;
+            try_from_options_optional_with(&json, "balance", |v| try_to_u64(v, "balance"))?;
 
         // revision - can be BigInt, number, or string (JSON doesn't support BigInt natively)
         let revision: Option<Revision> =
-            try_from_options_optional_with(&options_obj, "revision", |v| {
+            try_from_options_optional_with(&json, "revision", |v| {
                 try_to_u64(v, "revision")
             })?;
 
         // notFoundPublicKeys
         let not_found_public_keys: Option<Array> =
-            try_from_options_optional_with(&options_obj, "notFoundPublicKeys", |v| {
+            try_from_options_optional_with(&json, "notFoundPublicKeys", |v| {
                 try_to_array(v, "notFoundPublicKeys")
             })?;
         let not_found_keys: BTreeSet<KeyID> = option_array_to_not_found(not_found_public_keys)?;

packages/wasm-dpp2/src/identity/public_key.rs

@@ -156,8 +156,6 @@ impl From<IdentityPublicKeyWasm> for IdentityPublicKey {
 impl IdentityPublicKeyWasm {
     #[wasm_bindgen(constructor)]
     pub fn constructor(options: IdentityPublicKeyOptionsJs) -> WasmDppResult<Self> {
-        let options: JsValue = options.into();
-
         // Extract purpose (required, complex type)
         let purpose: PurposeWasm = try_from_options(&options, "purpose")?;
 
@@ -173,7 +171,7 @@ impl IdentityPublicKeyWasm {
                 .map(Into::into);
 
         // Extract simple fields via serde
-        let opts: IdentityPublicKeyOptions = serde_wasm_bindgen::from_value(options)
+        let opts: IdentityPublicKeyOptions = serde_wasm_bindgen::from_value(options.into())
             .map_err(|e| WasmDppError::invalid_argument(e.to_string()))?;
 
         Ok(IdentityPublicKeyWasm(IdentityPublicKey::from(