fix(wasm-sdk): store platform version in DataContractWasm struct

DataContractWasm now stores platform_version internally as u32, ensuring
consistent version handling across all operations. The toJSON method no
longer requires a platform_version parameter since it uses the stored
value. All constructors now require explicit platform version, following
the pattern that platform version should never use defaults.

BREAKING CHANGE: DataContractWasm.toJSON() no longer accepts a platform_version parameter

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: thephez

packages/wasm-sdk/src/dpp.rs

@@ -295,27 +295,34 @@ impl IdentityWasm {
 // }
 
 #[wasm_bindgen(js_name=DataContract)]
-pub struct DataContractWasm(DataContract);
+pub struct DataContractWasm {
+    contract: DataContract,
+    platform_version: u32,
+}
 
 impl DataContractWasm {
-    /// Create a DataContractWasm from a DataContract.
+    /// Create a DataContractWasm from a DataContract with platform version.
     ///
     /// This is the primary constructor for wrapping a data contract.
-    /// Note that serialization via `to_json()` requires providing an explicit
-    /// platform version to ensure version-specific fields (e.g., `groups` and
-    /// `tokens` for token contracts) are correctly included.
+    /// The platform version is stored and used for consistent serialization
+    /// to ensure version-specific fields (e.g., `groups` and `tokens` for
+    /// token contracts) are correctly included.
     ///
     /// # Arguments
     /// * `data_contract` - The data contract to wrap
-    pub(crate) fn from_data_contract(data_contract: DataContract) -> Self {
-        Self(data_contract)
+    /// * `platform_version` - The platform version to use for operations
+    pub(crate) fn from_data_contract(data_contract: DataContract, platform_version: u32) -> Self {
+        Self {
+            contract: data_contract,
+            platform_version,
+        }
     }
 }
 
 #[wasm_bindgen(js_class=DataContract)]
 impl DataContractWasm {
     pub fn id(&self) -> String {
-        self.0.id().to_string(Encoding::Base58)
+        self.contract.id().to_string(Encoding::Base58)
     }
 
     #[wasm_bindgen(js_name=fromJSON)]
@@ -340,18 +347,22 @@ impl DataContractWasm {
             WasmSdkError::serialization(format!("failed to create DataContract from json: {}", e))
         })?;
 
-        Ok(DataContractWasm::from_data_contract(data_contract))
+        Ok(DataContractWasm::from_data_contract(
+            data_contract,
+            platform_version.protocol_version,
+        ))
     }
 
     #[wasm_bindgen(js_name=toJSON)]
-    pub fn to_json(&self, platform_version: u32) -> Result<JsValue, WasmSdkError> {
-        let platform_version = &PlatformVersion::get(platform_version).map_err(|e| {
+    pub fn to_json(&self) -> Result<JsValue, WasmSdkError> {
+        let platform_version = &PlatformVersion::get(self.platform_version).map_err(|e| {
             WasmSdkError::invalid_argument(format!(
-                "unknown platform version {platform_version}: {e}"
+                "unknown platform version {}: {e}",
+                self.platform_version
             ))
         })?;
 
-        let json = self.0.to_json(platform_version).map_err(|e| {
+        let json = self.contract.to_json(platform_version).map_err(|e| {
             WasmSdkError::serialization(format!(
                 "failed to convert data contract convert to json: {}",
                 e

packages/wasm-sdk/src/queries/data_contract.rs

@@ -40,7 +40,10 @@ impl WasmSdk {
             .await?
             .ok_or_else(|| WasmSdkError::not_found("Data contract not found"))?;
 
-        Ok(DataContractWasm::from_data_contract(contract))
+        Ok(DataContractWasm::from_data_contract(
+            contract,
+            self.version(),
+        ))
     }
 
     #[wasm_bindgen(js_name = "getDataContractWithProofInfo")]

packages/wasm-sdk/src/verify.rs

@@ -122,7 +122,9 @@ pub async fn verify_data_contract() -> Option<DataContractWasm> {
     )
     .expect("parse proof");
 
-    response.map(DataContractWasm::from_data_contract)
+    response.map(|contract| {
+        DataContractWasm::from_data_contract(contract, PlatformVersion::latest().protocol_version)
+    })
 }
 
 #[wasm_bindgen(js_name = "verifyDocuments")]