@dashevo/wasm-dpp 4.0.0 → 4.1.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "4.0.0",
+  "version": "4.1.0-beta.2",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -44,7 +44,7 @@
     "@babel/core": "^7.26.10",
     "@babel/preset-env": "^7.26.9",
     "@dashevo/dashcore-lib": "~0.22.0",
-    "@dashevo/dpns-contract": "4.0.0",
+    "@dashevo/dpns-contract": "4.1.0-beta.2",
     "@types/bs58": "^4.0.1",
     "@types/node": "^20.10.0",
     "@yarnpkg/pnpify": "^4.0.0-rc.42",

package/src/data_contract/data_contract.rs

@@ -13,7 +13,6 @@ use dpp::platform_value::{platform_value, Value};
 use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters};
 use dpp::data_contract::accessors::v1::DataContractV1Getters;
 use dpp::data_contract::config::DataContractConfig;
-use dpp::data_contract::conversion::json::DataContractJsonConversionMethodsV0;
 use dpp::data_contract::conversion::value::v0::DataContractValueConversionMethodsV0;
 use dpp::data_contract::created_data_contract::CreatedDataContract;
 use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters;
@@ -102,13 +101,11 @@ impl DataContractWasm {
 
         let platform_version = PlatformVersion::first();
 
-        DataContract::from_value(
-            raw_parameters.with_serde_to_platform_value()?,
-            !skip_validation,
-            platform_version,
-        )
-        .with_js_error()
-        .map(Into::into)
+        let value = raw_parameters.with_serde_to_platform_value()?;
+        let full_validation = !skip_validation;
+        DataContract::from_value(value, full_validation, platform_version)
+            .with_js_error()
+            .map(Into::into)
     }
 
     #[wasm_bindgen(js_name=getId)]
@@ -326,9 +323,9 @@ impl DataContractWasm {
 
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self) -> Result<JsValue, JsValue> {
-        let platform_version = PlatformVersion::first();
-
-        let value = self.inner.to_value(platform_version).with_js_error()?;
+        let value = dpp::platform_value::to_value(&self.inner)
+            .map_err(ProtocolError::ValueError)
+            .with_js_error()?;
 
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
 
@@ -370,9 +367,9 @@ impl DataContractWasm {
 
     #[wasm_bindgen(js_name=toJSON)]
     pub fn to_json(&self) -> Result<JsValue, JsValue> {
-        let platform_version = PlatformVersion::first();
-
-        let json = self.inner.to_json(platform_version).with_js_error()?;
+        let json = serde_json::to_value(&self.inner)
+            .map_err(|e| ProtocolError::EncodingError(e.to_string()))
+            .with_js_error()?;
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         with_js_error!(json.serialize(&serializer))
     }

package/src/data_contract/state_transition/data_contract_create_transition/mod.rs

@@ -15,7 +15,9 @@ use dpp::state_transition::{
     StateTransitionIdentitySigned, StateTransitionOwned, StateTransitionSingleSigned,
 };
 
-use dpp::state_transition::{StateTransition, StateTransitionValueConvert};
+use dpp::serialization::ValueConvertible;
+use dpp::state_transition::StateTransition;
+use dpp::state_transition::StateTransitionFieldTypes;
 use dpp::version::PlatformVersion;
 use dpp::{state_transition::StateTransitionLike, ProtocolError};
 use serde::Serialize;
@@ -47,14 +49,32 @@ impl From<DataContractCreateTransitionWasm> for DataContractCreateTransition {
 impl DataContractCreateTransitionWasm {
     #[wasm_bindgen(constructor)]
     pub fn new(value: JsValue) -> Result<DataContractCreateTransitionWasm, JsValue> {
-        let platform_value = PlatformVersion::first();
-
-        DataContractCreateTransition::from_object(
-            value.with_serde_to_platform_value()?,
-            platform_value,
-        )
-        .map(Into::into)
-        .with_js_error()
+        use dpp::platform_value::Value;
+        let mut raw = value.with_serde_to_platform_value()?;
+        // Canonical `ValueConvertible::from_object` is a strict serde
+        // deserialization: it dispatches on the enum's `$formatVersion` tag and
+        // requires every field. Legacy JS clients construct a transition from
+        // its essential inputs (data contract + identity nonce) and sign it
+        // afterwards, so default the format tag plus the protocol-managed and
+        // signature fields they omit — preserving the lenient construction the
+        // pre-canonical path provided.
+        if let Value::Map(ref mut entries) = raw {
+            let mut ensure = |key: &str, default: Value| {
+                if !entries
+                    .iter()
+                    .any(|(k, _)| matches!(k, Value::Text(s) if s == key))
+                {
+                    entries.push((Value::Text(key.to_string()), default));
+                }
+            };
+            ensure("$formatVersion", Value::Text("0".to_string()));
+            ensure("userFeeIncrease", Value::U16(0));
+            ensure("signaturePublicKeyId", Value::U32(0));
+            ensure("signature", Value::Bytes(vec![]));
+        }
+        DataContractCreateTransition::from_object(raw)
+            .map(Into::into)
+            .with_js_error()
     }
 
     #[wasm_bindgen(js_name=getDataContract)]
@@ -187,10 +207,17 @@ impl DataContractCreateTransitionWasm {
 
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self, skip_signature: Option<bool>) -> Result<JsValue, JsValue> {
-        let serde_object = self
-            .0
-            .to_cleaned_object(skip_signature.unwrap_or(false))
-            .map_err(from_protocol_error)?;
+        let mut serde_object = self.0.to_object().map_err(from_protocol_error)?;
+
+        if skip_signature.unwrap_or(false) {
+            for path in
+                <DataContractCreateTransition as StateTransitionFieldTypes>::signature_property_paths()
+            {
+                serde_object
+                    .remove_values_matching_path(path)
+                    .map_err(|e| from_protocol_error(dpp::ProtocolError::ValueError(e)))?;
+            }
+        }
 
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
 

package/src/data_contract/state_transition/data_contract_update_transition/mod.rs

@@ -3,11 +3,13 @@
 // pub use validation::*;
 
 use dpp::consensus::ConsensusError;
+use dpp::serialization::ValueConvertible;
 use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
 use dpp::state_transition::data_contract_update_transition::accessors::DataContractUpdateTransitionAccessorsV0;
 use dpp::state_transition::data_contract_update_transition::DataContractUpdateTransition;
+use dpp::state_transition::StateTransition;
+use dpp::state_transition::StateTransitionFieldTypes;
 use dpp::state_transition::StateTransitionHasUserFeeIncrease;
-use dpp::state_transition::{StateTransition, StateTransitionValueConvert};
 use dpp::state_transition::{
     StateTransitionIdentitySigned, StateTransitionOwned, StateTransitionSingleSigned,
 };
@@ -48,14 +50,32 @@ impl From<DataContractUpdateTransitionWasm> for DataContractUpdateTransition {
 impl DataContractUpdateTransitionWasm {
     #[wasm_bindgen(constructor)]
     pub fn new(raw_parameters: JsValue) -> Result<DataContractUpdateTransitionWasm, JsValue> {
-        let platform_version = PlatformVersion::first();
-
-        DataContractUpdateTransition::from_object(
-            raw_parameters.with_serde_to_platform_value()?,
-            platform_version,
-        )
-        .map(Into::into)
-        .with_js_error()
+        use dpp::platform_value::Value;
+        let mut raw = raw_parameters.with_serde_to_platform_value()?;
+        // Canonical `ValueConvertible::from_object` is a strict serde
+        // deserialization: it dispatches on the enum's `$formatVersion` tag and
+        // requires every field. Legacy JS clients construct a transition from
+        // its essential inputs (data contract + identity contract nonce) and
+        // sign it afterwards, so default the format tag plus the
+        // protocol-managed and signature fields they omit — preserving the
+        // lenient construction the pre-canonical path provided.
+        if let Value::Map(ref mut entries) = raw {
+            let mut ensure = |key: &str, default: Value| {
+                if !entries
+                    .iter()
+                    .any(|(k, _)| matches!(k, Value::Text(s) if s == key))
+                {
+                    entries.push((Value::Text(key.to_string()), default));
+                }
+            };
+            ensure("$formatVersion", Value::Text("0".to_string()));
+            ensure("userFeeIncrease", Value::U16(0));
+            ensure("signaturePublicKeyId", Value::U32(0));
+            ensure("signature", Value::Bytes(vec![]));
+        }
+        DataContractUpdateTransition::from_object(raw)
+            .map(Into::into)
+            .with_js_error()
     }
 
     #[wasm_bindgen(js_name=getDataContract)]
@@ -191,10 +211,17 @@ impl DataContractUpdateTransitionWasm {
 
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self, skip_signature: Option<bool>) -> Result<JsValue, JsValue> {
-        let serde_object = self
-            .0
-            .to_cleaned_object(skip_signature.unwrap_or(false))
-            .map_err(from_protocol_error)?;
+        let mut serde_object = self.0.to_object().map_err(from_protocol_error)?;
+
+        if skip_signature.unwrap_or(false) {
+            for path in
+                <DataContractUpdateTransition as StateTransitionFieldTypes>::signature_property_paths()
+            {
+                serde_object
+                    .remove_values_matching_path(path)
+                    .map_err(|e| from_protocol_error(ProtocolError::ValueError(e)))?;
+            }
+        }
 
         serde_object
             .serialize(&serde_wasm_bindgen::Serializer::json_compatible())

package/src/document/extended_document.rs

@@ -1,13 +1,9 @@
-use dpp::document::{
-    DocumentV0Getters, DocumentV0Setters, ExtendedDocument, EXTENDED_DOCUMENT_IDENTIFIER_FIELDS,
-};
+use dpp::document::{DocumentV0Getters, DocumentV0Setters, ExtendedDocument};
 use serde_json::Value as JsonValue;
 
 use dpp::platform_value::{Bytes32, Value};
 use dpp::prelude::{Identifier, Revision, TimestampMillis};
 
-use dpp::util::json_value::JsonValueExt;
-
 use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters;
 use dpp::document::serialization_traits::ExtendedDocumentPlatformConversionMethodsV0;
 use dpp::platform_value::converter::serde_json::BTreeValueJsonConverter;
@@ -21,14 +17,12 @@ use crate::buffer::Buffer;
 use crate::data_contract::DataContractWasm;
 #[allow(deprecated)] // BinaryType is unused in unused code below
 use crate::document::BinaryType;
-use crate::document::{ConversionOptions, DocumentWasm};
+use crate::document::DocumentWasm;
 use crate::errors::RustConversionError;
 use crate::identifier::{identifier_from_js_value, IdentifierWrapper};
-use crate::lodash::lodash_set;
 use crate::metadata::MetadataWasm;
 use crate::utils::{with_serde_to_platform_value, IntoWasm, ToSerdeJSONExt, WithJsError};
 use crate::validation::ValidationResultWasm;
-use crate::with_js_error;
 
 #[wasm_bindgen(js_name=ExtendedDocument)]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -187,6 +181,21 @@ impl ExtendedDocumentWasm {
         Ok(js_value)
     }
 
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        // Canonical object shape: every `$`-prefixed system field (id, ownerId,
+        // type, dataContractId, revision, timestamps/block-heights, creatorId)
+        // plus the flattened document properties, with identifiers and binary
+        // data rendered as `Uint8Array`. Serializing the non-human-readable
+        // `to_map_value()` turns every identifier/bytes node — including nested
+        // document properties — into a `Uint8Array` in one pass, so there is no
+        // need to walk the document type's identifier/binary paths.
+        let map = self.0.to_map_value().with_js_error()?;
+        let serializer =
+            serde_wasm_bindgen::Serializer::json_compatible().serialize_bytes_as_arrays(false);
+        Ok(map.serialize(&serializer)?)
+    }
+
     #[wasm_bindgen(js_name=set)]
     pub fn set(&mut self, path: String, js_value_to_set: JsValue) -> Result<(), JsValue> {
         let value: Value = js_value_to_set.with_serde_to_platform_value()?;
@@ -273,58 +282,6 @@ impl ExtendedDocumentWasm {
         Ok(())
     }
 
-    #[wasm_bindgen(js_name=toObject)]
-    pub fn to_object(&self, options: &JsValue) -> Result<JsValue, JsValue> {
-        let options: ConversionOptions = if !options.is_undefined() && options.is_object() {
-            let raw_options = options.with_serde_to_json_value()?;
-            serde_json::from_value(raw_options).with_js_error()?
-        } else {
-            Default::default()
-        };
-        let mut value = self.0.to_json_object_for_validation().with_js_error()?;
-
-        let document_type = self.0.document_type().with_js_error()?;
-
-        let identifier_paths = document_type.identifier_paths();
-        let binary_paths = document_type.binary_paths();
-
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        let js_value = value.serialize(&serializer)?;
-
-        for path in identifier_paths
-            .iter()
-            .map(|s| s.as_str())
-            .chain(EXTENDED_DOCUMENT_IDENTIFIER_FIELDS)
-        {
-            if let Ok(bytes) = value.remove_value_at_path_into::<Vec<u8>>(path) {
-                let buffer = Buffer::from_bytes_owned(bytes);
-                if !options.skip_identifiers_conversion {
-                    lodash_set(&js_value, path, buffer.into());
-                } else {
-                    let id = IdentifierWrapper::new(buffer.into());
-                    lodash_set(&js_value, path, id.into());
-                }
-            }
-        }
-
-        for path in binary_paths {
-            if let Ok(bytes) = value.remove_value_at_path_into::<Vec<u8>>(path) {
-                let buffer = Buffer::from_bytes(&bytes);
-                lodash_set(&js_value, path, buffer.into());
-            }
-        }
-
-        Ok(js_value)
-    }
-
-    #[wasm_bindgen(js_name=toJSON)]
-    pub fn to_json(&self) -> Result<JsValue, JsValue> {
-        let value = self.0.to_json(PlatformVersion::first()).with_js_error()?;
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-
-        with_js_error!(value.serialize(&serializer))
-    }
-
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
         let bytes: Vec<u8> = self

package/src/document/mod.rs

@@ -11,7 +11,9 @@ use crate::data_contract::DataContractWasm;
 use crate::identifier::IdentifierWrapper;
 
 use crate::utils::WithJsError;
-use crate::utils::{with_serde_to_json_value, ToSerdeJSONExt};
+use crate::utils::{
+    json_value_to_platform_value_lenient, with_serde_to_json_value, ToSerdeJSONExt,
+};
 
 use dpp::document::document_methods::DocumentMethodsV0;
 use dpp::document::DocumentV0Getters;
@@ -39,7 +41,6 @@ use dpp::{platform_value, ProtocolError};
 
 use dpp::data_contract::accessors::v0::DataContractV0Getters;
 use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters;
-use dpp::document::serialization_traits::DocumentPlatformValueMethodsV0;
 use dpp::version::PlatformVersion;
 use serde_json::Value as JsonValue;
 
@@ -71,7 +72,8 @@ impl DocumentWasm {
         js_data_contract: &DataContractWasm,
         js_document_type_name: JsValue,
     ) -> Result<DocumentWasm, JsValue> {
-        let mut raw_document: Value = with_serde_to_json_value(&js_raw_document)?.into();
+        let mut raw_document: Value =
+            json_value_to_platform_value_lenient(with_serde_to_json_value(&js_raw_document)?);
 
         let document_type_name = js_document_type_name
             .as_string()
@@ -99,8 +101,23 @@ impl DocumentWasm {
             .with_js_error()?;
         // The binary paths are not being converted, because they always should be a `Buffer`. `Buffer` is always an Array
 
-        let document = Document::from_platform_value(raw_document, PlatformVersion::first())
-            .with_js_error()?;
+        // Phase D step 8 slice B replaced legacy `Document::from_platform_value`
+        // with canonical `ValueConvertible::from_object`, which requires a
+        // `$formatVersion` tag. Insert it for un-tagged JS-supplied input
+        // before delegating.
+        if let Value::Map(ref mut entries) = raw_document {
+            let has_tag = entries
+                .iter()
+                .any(|(k, _)| matches!(k, Value::Text(s) if s == "$formatVersion"));
+            if !has_tag {
+                entries.push((
+                    Value::Text("$formatVersion".to_string()),
+                    Value::Text("0".to_string()),
+                ));
+            }
+        }
+        use dpp::serialization::ValueConvertible;
+        let document = Document::from_object(raw_document).with_js_error()?;
 
         Ok(document.into())
     }

package/src/identity/state_transition/asset_lock_proof/chain/chain_asset_lock_proof.rs

@@ -1,6 +1,7 @@
 use dpp::dashcore::consensus::Encodable;
 use dpp::dashcore::OutPoint;
 use dpp::identity::state_transition::asset_lock_proof::AssetLockProofType;
+use dpp::serialization::ValueConvertible;
 use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
 use wasm_bindgen::prelude::*;
@@ -117,7 +118,9 @@ impl ChainAssetLockProofWasm {
 
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self) -> Result<JsValue, JsValue> {
-        let asset_lock_value = self.0.to_cleaned_object().with_js_error()?;
+        // `to_cleaned_object` was a pure delegation to `to_object` in rs-dpp;
+        // the canonical `ValueConvertible::to_object` produces the same Value.
+        let asset_lock_value = self.0.to_object().with_js_error()?;
 
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         let js_object = with_js_error!(asset_lock_value.serialize(&serializer))?;

package/src/identity/state_transition/asset_lock_proof/instant/instant_asset_lock_proof.rs

@@ -5,6 +5,7 @@ use dpp::dashcore::{
 
 use dpp::dashcore::consensus::Encodable;
 use dpp::identity::state_transition::asset_lock_proof::AssetLockProofType;
+use dpp::serialization::ValueConvertible;
 use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
 use wasm_bindgen::prelude::*;
@@ -117,7 +118,10 @@ impl InstantAssetLockProofWasm {
 
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self) -> Result<JsValue, JsValue> {
-        let asset_lock_value = self.0.to_cleaned_object().with_js_error()?;
+        // `to_cleaned_object` was a pure delegation to `to_object` in
+        // rs-dpp; the canonical `ValueConvertible::to_object` produces the
+        // same Value (no `disabledAt` field on InstantAssetLockProof to clean).
+        let asset_lock_value = self.0.to_object().with_js_error()?;
 
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         let js_object = with_js_error!(asset_lock_value.serialize(&serializer))?;

package/src/utils.rs

@@ -105,7 +105,57 @@ pub fn with_serde_to_json_value(data: &JsValue) -> Result<JsonValue, JsValue> {
 }
 
 pub fn with_serde_to_platform_value(data: &JsValue) -> Result<Value, JsValue> {
-    Ok(with_serde_to_json_value(data)?.into())
+    Ok(json_value_to_platform_value_lenient(
+        with_serde_to_json_value(data)?,
+    ))
+}
+
+/// Converts a `serde_json::Value` into a `platform_value::Value`, restoring the
+/// legacy "array of u8 → `Value::Bytes`" coercion that `From<JsonValue> for Value`
+/// used to perform before the Critical-2 faithful-conversion change in
+/// rs-platform-value.
+///
+/// The JS boundary of this (deprecated) crate stringifies JS `Buffer`s into plain
+/// number arrays via [`stringify`], then relied on that coercion to reconstruct
+/// binary document fields (`byteArrayField`, identifiers, …) as `Value::Bytes`.
+/// rs-platform-value is now intentionally faithful (array → `Value::Array`), so we
+/// re-apply the heuristic here — scoped to the legacy crate's JS input only —
+/// rather than reintroduce the footgun globally.
+pub(crate) fn json_value_to_platform_value_lenient(value: JsonValue) -> Value {
+    match value {
+        JsonValue::Array(array) => {
+            let u8_max = u8::MAX as u64;
+            // Matches the pre-Critical-2 heuristic exactly: length >= 10 and every
+            // element a u64 that fits in a byte ⇒ treat as a byte array.
+            if array.len() >= 10
+                && array
+                    .iter()
+                    .all(|v| v.as_u64().map(|int| int <= u8_max).unwrap_or(false))
+            {
+                Value::Bytes(
+                    array
+                        .into_iter()
+                        .map(|v| v.as_u64().expect("checked above") as u8)
+                        .collect(),
+                )
+            } else {
+                Value::Array(
+                    array
+                        .into_iter()
+                        .map(json_value_to_platform_value_lenient)
+                        .collect(),
+                )
+            }
+        }
+        JsonValue::Object(map) => Value::Map(
+            map.into_iter()
+                .map(|(k, v)| (k.into(), json_value_to_platform_value_lenient(v)))
+                .collect(),
+        ),
+        // Null / Bool / Number / String are unaffected by the heuristic and convert
+        // identically through the canonical impl.
+        other => other.into(),
+    }
 }
 
 pub fn with_serde_into<D>(data: &JsValue) -> Result<D, JsValue>

package/test/integration/document/Document.spec.js

@@ -32,66 +32,6 @@ describe('ExtendedDocument', () => {
     document.setMetadata(metadataFixture);
   });
 
-  describe.skip('#toJSON', () => {
-    it('should return json document - Rust', () => {
-      const result = document.toJSON();
-
-      expect(result).to.deep.equal({
-        $protocolVersion: document.getProtocolVersion(),
-        $dataContractId: dataContract.getId().toString(),
-        $id: document.getId().toString(),
-        $ownerId: document.getOwnerId().toString(),
-        $revision: 1,
-        $type: 'withByteArrays',
-        byteArrayField: document.get('byteArrayField').toString('base64'),
-        identifierField: document.get('identifierField').toString(),
-      });
-    });
-  });
-
-  describe('#toObject', () => {
-    it('should return raw document - Rust', () => {
-      const result = document.toObject();
-
-      expect(result).to.deep.equal({
-        $createdAt: null, // TODO: it should be omitted
-        $createdAtBlockHeight: null,
-        $createdAtCoreBlockHeight: null,
-        $creatorId: null,
-        $updatedAt: null,
-        $updatedAtBlockHeight: null,
-        $updatedAtCoreBlockHeight: null,
-        $transferredAt: null,
-        $transferredAtBlockHeight: null,
-        $transferredAtCoreBlockHeight: null,
-        $dataContractId: dataContract.getId().toBuffer(),
-        $id: document.getId().toBuffer(),
-        $ownerId: document.getOwnerId().toBuffer(),
-        $revision: 1,
-        $type: 'withByteArrays',
-        byteArrayField: document.get('byteArrayField'),
-        identifierField: document.get('identifierField').toBuffer(),
-      });
-    });
-
-    it('should return raw document with Identifiers - Rust', () => {
-      const result = document.toObject({ skipIdentifiersConversion: true });
-
-      expect(result.$dataContractId).to.be.an.instanceOf(Identifier);
-      expect(result.$id).to.be.an.instanceOf(Identifier);
-      expect(result.$ownerId).to.be.an.instanceOf(Identifier);
-      expect(result.identifierField).to.be.an.instanceOf(Identifier);
-
-      expect(result.$dataContractId.toBuffer()).to.deep.equal(dataContract.getId().toBuffer());
-      expect(result.$id.toBuffer()).to.deep.equal(document.getId().toBuffer());
-      expect(result.$ownerId.toBuffer()).to.deep.equal(document.getOwnerId().toBuffer());
-      expect(result.identifierField.toBuffer()).to.deep.equal(document.get('identifierField').toBuffer());
-      expect(BigInt(result.$revision)).to.deep.equal(document.getRevision());
-      expect(result.$type).to.deep.equal(document.getType());
-      expect(result.byteArrayField).to.deep.equal(document.get('byteArrayField'));
-    });
-  });
-
   describe('#setMetadata', () => {
     it('should set metadata - Rust', () => {
       const otherMetadata = new Metadata(BigInt(43), 1, BigInt(100), 2);

package/test/unit/dataContract/DataContract.spec.js

@@ -218,7 +218,7 @@ describe('DataContract', () => {
       const result = dataContract.toJSON();
 
       expect(result).to.deep.equal({
-        $formatVersion: '0',
+        $formatVersion: '1',
         config: {
           $formatVersion: '0',
           canBeDeleted: false,
@@ -235,6 +235,16 @@ describe('DataContract', () => {
         ownerId: bs58.encode(ownerId),
         schemaDefs: null,
         documentSchemas,
+        createdAt: null,
+        updatedAt: null,
+        createdAtBlockHeight: null,
+        updatedAtBlockHeight: null,
+        createdAtEpoch: null,
+        updatedAtEpoch: null,
+        description: null,
+        keywords: [],
+        groups: {},
+        tokens: {},
       });
     });
 
@@ -248,7 +258,7 @@ describe('DataContract', () => {
       const result = dataContract.toJSON();
 
       expect(result).to.deep.equal({
-        $formatVersion: '0',
+        $formatVersion: '1',
         config: {
           $formatVersion: '0',
           canBeDeleted: false,
@@ -265,6 +275,16 @@ describe('DataContract', () => {
         ownerId: bs58.encode(ownerId),
         documentSchemas,
         schemaDefs: $defs,
+        createdAt: null,
+        updatedAt: null,
+        createdAtBlockHeight: null,
+        updatedAtBlockHeight: null,
+        createdAtEpoch: null,
+        updatedAtEpoch: null,
+        description: null,
+        keywords: [],
+        groups: {},
+        tokens: {},
       });
     });
   });

package/test/unit/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition.spec.js

@@ -72,7 +72,7 @@ describe('DataContractCreateTransition', () => {
     it('should return serialized State Transition', () => {
       const result = stateTransition.toBuffer();
       expect(result).to.be.instanceOf(Buffer);
-      expect(result).to.have.lengthOf(2359);
+      expect(result).to.have.lengthOf(2370);
     });
 
     it('should be able to restore contract config from bytes', () => {

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition.spec.js

@@ -20,7 +20,8 @@ describe('DataContractUpdateTransition', () => {
     stateTransition = new DataContractUpdateTransition({
       protocolVersion: 1,
       dataContract: dataContract.toObject(),
-      identityContractNonce: 1,
+      // Canonical serde wire name for the identity-contract-nonce field.
+      '$identity-contract-nonce': 1,
     });
   });
 
@@ -65,7 +66,7 @@ describe('DataContractUpdateTransition', () => {
     it('should return serialized State Transition', () => {
       const result = stateTransition.toBuffer();
       expect(result).to.be.instanceOf(Buffer);
-      expect(result).to.have.lengthOf(2359);
+      expect(result).to.have.lengthOf(2370);
     });
 
     it('should be able to restore contract config from bytes', () => {

package/test/unit/document/Document.spec.js

@@ -397,28 +397,6 @@ describe('Document', () => {
     });
   });
 
-  describe('#toJSON', () => {
-    it('should return Document as plain JS object', () => {
-      const jsonDocument = {
-        ...rawDocument,
-        $dataContractId: document.getDataContractId().toString(),
-        $dataContract: document.getDataContract().toJSON(),
-        $id: document.getId().toString(),
-        $ownerId: document.getOwnerId().toString(),
-      };
-
-      expect(document.toJSON()).to.deep.equal(jsonDocument);
-    });
-  });
-
-  describe('#toObject', () => {
-    it('should return Document as object', () => {
-      const result = document.toObject();
-
-      expect(rawDocumentWithBuffers).to.deep.equal(result);
-    });
-  });
-
   describe('#toBuffer', () => {
     it('should return serialized Document', () => {
       const buffer = document.toBuffer();