@dashevo/wasm-dpp 0.24.0-dev.11 → 0.24.0-dev.12

package/lib/dpp.ts

@@ -0,0 +1,24 @@
+import * as dpp_module from '../wasm/wasm_dpp';
+import { patchConsensusErrors } from './errors/patchConsensusErrors';
+
+patchConsensusErrors();
+
+// While we declared it above, those fields do not hold any values - let's assign them.
+// We need to suppress the compiler here, as he won't be happy about those reassignments.
+// @ts-ignore
+dpp_module.IdentityPublicKey.TYPES = dpp_module.KeyType;
+// @ts-ignore
+dpp_module.IdentityPublicKey.PURPOSES = dpp_module.KeyPurpose;
+// @ts-ignore
+dpp_module.IdentityPublicKey.SECURITY_LEVELS = dpp_module.KeySecurityLevel;
+
+export * from '../wasm/wasm_dpp';
+export * from './errors/AbstractConsensusError';
+export * from './errors/DPPError';
+
+// Declarations written prior to "export *" will overwrite exports
+export declare class IdentityPublicKey extends dpp_module.IdentityPublicKey {
+    static TYPES: typeof dpp_module.KeyType;
+    static PURPOSES: typeof dpp_module.KeyPurpose;
+    static SECURITY_LEVELS: typeof dpp_module.KeySecurityLevel;
+}

package/lib/errors/AbstractConsensusError.ts

@@ -0,0 +1,13 @@
+import { DPPError } from './DPPError'
+
+/**
+ * @abstract
+ */
+export class AbstractConsensusError extends DPPError {
+    /**
+     * @param {string} message
+     */
+    constructor(message: string) {
+        super(message);
+    }
+}

package/lib/errors/DPPError.ts

@@ -0,0 +1,15 @@
+export class DPPError extends Error {
+    name: string;
+    message: string;
+
+    constructor(message: string) {
+        super();
+
+        this.name = this.constructor.name;
+        this.message = message;
+
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}

package/lib/errors/patchConsensusErrors.ts

@@ -0,0 +1,175 @@
+import * as dpp_module from '../../wasm/wasm_dpp';
+import { extend } from "../utils/extend";
+import { AbstractConsensusError } from "./AbstractConsensusError";
+
+const {
+    ProtocolVersionParsingError,
+    UnsupportedProtocolVersionError,
+    IncompatibleProtocolVersionError,
+    SerializedObjectParsingError,
+    JsonSchemaError,
+    InvalidIdentifierError,
+    DataContractMaxDepthExceedError,
+    DuplicateIndexError,
+    InvalidCompoundIndexError,
+    InvalidDataContractIdError,
+    InvalidIndexedPropertyConstraintError,
+    InvalidIndexPropertyTypeError,
+    SystemPropertyIndexAlreadyPresentError,
+    UndefinedIndexPropertyError,
+    UniqueIndicesLimitReachedError,
+    InconsistentCompoundIndexDataError,
+    InvalidDocumentTransitionActionError,
+    InvalidDocumentTransitionIdError,
+    DataContractNotPresentError,
+    InvalidDocumentTypeError,
+    MissingDataContractIdError,
+    MissingDocumentTransitionActionError,
+    MissingDocumentTransitionTypeError,
+    MissingDocumentTypeError,
+    DuplicatedIdentityPublicKeyError,
+    DuplicatedIdentityPublicKeyIdError,
+    MissingMasterPublicKeyError,
+    IdentityAssetLockProofLockedTransactionMismatchError,
+    IdentityAssetLockTransactionIsNotFoundError,
+    IdentityAssetLockTransactionOutPointAlreadyExistsError,
+    IdentityAssetLockTransactionOutputNotFoundError,
+    InvalidAssetLockProofCoreChainHeightError,
+    InvalidAssetLockProofTransactionHeightError,
+    InvalidIdentityAssetLockTransactionError,
+    InvalidIdentityAssetLockTransactionOutputError,
+    InvalidIdentityPublicKeyDataError,
+    InvalidIdentityPublicKeySecurityLevelError,
+    InvalidStateTransitionTypeError,
+    MissingStateTransitionTypeError,
+    StateTransitionMaxSizeExceededError,
+    IdentityNotFoundError,
+    InvalidIdentityPublicKeyTypeError,
+    InvalidStateTransitionSignatureError,
+    MissingPublicKeyError,
+    BalanceIsNotEnoughError,
+    DataContractAlreadyPresentError,
+    DataTriggerConditionError,
+    DataTriggerExecutionError,
+    DataTriggerInvalidResultError,
+    DocumentAlreadyPresentError,
+    DocumentNotFoundError,
+    DocumentOwnerIdMismatchError,
+    DocumentTimestampsMismatchError,
+    DocumentTimestampWindowViolationError,
+    DuplicateUniqueIndexError,
+    InvalidDocumentRevisionError,
+    IdentityAlreadyExistsError,
+    InvalidJsonSchemaRefError,
+    JsonSchemaCompilationError,
+    DuplicateDocumentTransitionsWithIdsError,
+    DuplicateDocumentTransitionsWithIndicesError,
+    InvalidAssetLockTransactionOutputReturnSizeError,
+    InvalidInstantAssetLockProofError,
+    InvalidInstantAssetLockProofSignatureError,
+    IncompatibleRe2PatternError,
+    InvalidDataContractVersionError,
+    IncompatibleDataContractSchemaError,
+    DataContractImmutablePropertiesUpdateError,
+    DataContractUniqueIndicesChangedError,
+    DuplicateIndexNameError,
+    DataContractInvalidIndexDefinitionUpdateError,
+    DataContractHaveNewUniqueIndexError,
+    IdentityPublicKeyDisabledAtWindowViolationError,
+    IdentityPublicKeyIsReadOnlyError,
+    InvalidIdentityPublicKeyIdError,
+    InvalidIdentityRevisionError,
+    MaxIdentityPublicKeyLimitReachedError,
+    InvalidIdentityKeySignatureError,
+    InvalidSignaturePublicKeySecurityLevelError,
+    PublicKeyIsDisabledError,
+    PublicKeySecurityLevelNotMetError,
+    WrongPublicKeyPurposeError,
+    IdentityPublicKeyIsDisabledError,
+} = dpp_module;
+
+export function patchConsensusErrors() {
+    extend(ProtocolVersionParsingError, AbstractConsensusError);
+    extend(UnsupportedProtocolVersionError, AbstractConsensusError);
+    extend(IncompatibleProtocolVersionError, AbstractConsensusError);
+    extend(SerializedObjectParsingError, AbstractConsensusError);
+    extend(JsonSchemaError, AbstractConsensusError);
+    extend(InvalidIdentifierError, AbstractConsensusError);
+    extend(DataContractMaxDepthExceedError, AbstractConsensusError);
+    extend(DuplicateIndexError, AbstractConsensusError);
+    extend(InvalidCompoundIndexError, AbstractConsensusError);
+    extend(InvalidDataContractIdError, AbstractConsensusError);
+    extend(InvalidIndexedPropertyConstraintError, AbstractConsensusError);
+    extend(InvalidIndexPropertyTypeError, AbstractConsensusError);
+    extend(SystemPropertyIndexAlreadyPresentError, AbstractConsensusError);
+    extend(UndefinedIndexPropertyError, AbstractConsensusError);
+    extend(UniqueIndicesLimitReachedError, AbstractConsensusError);
+    extend(InconsistentCompoundIndexDataError, AbstractConsensusError);
+    extend(InvalidDocumentTransitionActionError, AbstractConsensusError);
+    extend(InvalidDocumentTransitionIdError, AbstractConsensusError);
+    extend(DataContractNotPresentError, AbstractConsensusError);
+    extend(InvalidDocumentTypeError, AbstractConsensusError);
+    extend(MissingDataContractIdError, AbstractConsensusError);
+    extend(MissingDocumentTransitionActionError, AbstractConsensusError);
+    extend(MissingDocumentTransitionTypeError, AbstractConsensusError);
+    extend(MissingDocumentTypeError, AbstractConsensusError);
+    extend(DuplicatedIdentityPublicKeyError, AbstractConsensusError);
+    extend(DuplicatedIdentityPublicKeyIdError, AbstractConsensusError);
+    extend(MissingMasterPublicKeyError, AbstractConsensusError);
+    extend(IdentityAssetLockProofLockedTransactionMismatchError, AbstractConsensusError);
+    extend(IdentityAssetLockTransactionIsNotFoundError, AbstractConsensusError);
+    extend(IdentityAssetLockTransactionOutPointAlreadyExistsError, AbstractConsensusError);
+    extend(IdentityAssetLockTransactionOutputNotFoundError, AbstractConsensusError);
+    extend(InvalidAssetLockProofCoreChainHeightError, AbstractConsensusError);
+    extend(InvalidAssetLockProofTransactionHeightError, AbstractConsensusError);
+    extend(InvalidIdentityAssetLockTransactionError, AbstractConsensusError);
+    extend(InvalidIdentityAssetLockTransactionOutputError, AbstractConsensusError);
+    extend(InvalidIdentityPublicKeyDataError, AbstractConsensusError);
+    extend(InvalidIdentityPublicKeySecurityLevelError, AbstractConsensusError);
+    extend(InvalidStateTransitionTypeError, AbstractConsensusError);
+    extend(MissingStateTransitionTypeError, AbstractConsensusError);
+    extend(StateTransitionMaxSizeExceededError, AbstractConsensusError);
+    extend(IdentityNotFoundError, AbstractConsensusError);
+    extend(InvalidIdentityPublicKeyTypeError, AbstractConsensusError);
+    extend(InvalidStateTransitionSignatureError, AbstractConsensusError);
+    extend(MissingPublicKeyError, AbstractConsensusError);
+    extend(BalanceIsNotEnoughError, AbstractConsensusError);
+    extend(DataContractAlreadyPresentError, AbstractConsensusError);
+    extend(DataTriggerConditionError, AbstractConsensusError);
+    extend(DataTriggerExecutionError, AbstractConsensusError);
+    extend(DataTriggerInvalidResultError, AbstractConsensusError);
+    extend(DocumentAlreadyPresentError, AbstractConsensusError);
+    extend(DocumentNotFoundError, AbstractConsensusError);
+    extend(DocumentOwnerIdMismatchError, AbstractConsensusError);
+    extend(DocumentTimestampsMismatchError, AbstractConsensusError);
+    extend(DocumentTimestampWindowViolationError, AbstractConsensusError);
+    extend(DuplicateUniqueIndexError, AbstractConsensusError);
+    extend(InvalidDocumentRevisionError, AbstractConsensusError);
+    extend(IdentityAlreadyExistsError, AbstractConsensusError);
+    extend(InvalidJsonSchemaRefError, AbstractConsensusError);
+    extend(JsonSchemaCompilationError, AbstractConsensusError);
+    extend(DuplicateDocumentTransitionsWithIdsError, AbstractConsensusError);
+    extend(DuplicateDocumentTransitionsWithIndicesError, AbstractConsensusError);
+    extend(InvalidAssetLockTransactionOutputReturnSizeError, AbstractConsensusError);
+    extend(InvalidInstantAssetLockProofError, AbstractConsensusError);
+    extend(InvalidInstantAssetLockProofSignatureError, AbstractConsensusError);
+    extend(IncompatibleRe2PatternError, AbstractConsensusError);
+    extend(InvalidDataContractVersionError, AbstractConsensusError);
+    extend(IncompatibleDataContractSchemaError, AbstractConsensusError);
+    extend(DataContractImmutablePropertiesUpdateError, AbstractConsensusError);
+    extend(DataContractUniqueIndicesChangedError, AbstractConsensusError);
+    extend(DuplicateIndexNameError, AbstractConsensusError);
+    extend(DataContractInvalidIndexDefinitionUpdateError, AbstractConsensusError);
+    extend(DataContractHaveNewUniqueIndexError, AbstractConsensusError);
+    extend(IdentityPublicKeyDisabledAtWindowViolationError, AbstractConsensusError);
+    extend(IdentityPublicKeyIsReadOnlyError, AbstractConsensusError);
+    extend(InvalidIdentityPublicKeyIdError, AbstractConsensusError);
+    extend(InvalidIdentityRevisionError, AbstractConsensusError);
+    extend(MaxIdentityPublicKeyLimitReachedError, AbstractConsensusError);
+    extend(InvalidIdentityKeySignatureError, AbstractConsensusError);
+    extend(InvalidSignaturePublicKeySecurityLevelError, AbstractConsensusError);
+    extend(PublicKeyIsDisabledError, AbstractConsensusError);
+    extend(PublicKeySecurityLevelNotMetError, AbstractConsensusError);
+    extend(WrongPublicKeyPurposeError, AbstractConsensusError);
+    extend(IdentityPublicKeyIsDisabledError, AbstractConsensusError);
+}

package/lib/{patchIdentifier.ts → identifier/patchIdentifier.ts}

@@ -1,4 +1,4 @@
-import * as dpp_module from "../wasm/wasm_dpp";
+import * as dpp_module from "../dpp";
 // import { inspect } from 'util';
 
 export default function (dppModule: typeof dpp_module) {

package/{index.ts → lib/index.ts}

@@ -1,7 +1,8 @@
-import init, * as dpp_module from './wasm/wasm_dpp';
+import init from '../wasm/wasm_dpp';
+import * as dpp_module from './dpp';
 // @ts-ignore
-import wasmBase from './wasm/wasm_dpp_bg.js';
-import patchIdentifier from "./lib/patchIdentifier";
+import wasmBase from '../wasm/wasm_dpp_bg.js';
+import patchIdentifier from "./identifier/patchIdentifier";
 
 let isInitialized = false;
 

package/lib/test/expect/expectError.js

@@ -12,12 +12,14 @@ const expectError = {
     const wasmDpp = await loadWasmDpp();
     if (!errorClass) {
       // eslint-disable-next-line no-param-reassign
-      errorClass = wasmDpp.ValidationResult;
+      errorClass = wasmDpp.AbstractConsensusError;
     }
     expect(result).to.be.an.instanceOf(wasmDpp.ValidationResult);
     expect(result.getErrors()).to.have.lengthOf(count);
 
-    result.getErrors().forEach((error) => expect(error).to.be.an.instanceOf(errorClass));
+    result.getErrors().forEach((error) => {
+      expect(error).to.be.an.instanceOf(errorClass);
+    });
   },
 
   /**

package/lib/utils/extend.ts

@@ -0,0 +1,6 @@
+export function extend(Derived: any, Base: any) {
+    Object.setPrototypeOf(
+        Derived.prototype,
+        Base.prototype,
+    );
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "0.24.0-dev.11",
+  "version": "0.24.0-dev.12",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "types": "dist/lib/index.d.ts",
   "scripts": {
     "build": "yarn exec scripts/build.sh && webpack",
     "test": "yarn run test:node && yarn run test:browsers",
@@ -35,8 +35,8 @@
   "devDependencies": {
     "@apidevtools/json-schema-ref-parser": "^8.0.0",
     "@dashevo/dashcore-lib": "~0.19.44",
-    "@dashevo/dpns-contract": "0.24.0-dev.11",
-    "@dashevo/dpp": "0.24.0-dev.11",
+    "@dashevo/dpns-contract": "0.24.0-dev.12",
+    "@dashevo/dpp": "0.24.0-dev.12",
     "@dashevo/wasm-re2": "~1.0.2",
     "@types/node": "^14.6.0",
     "ajv": "^8.6.0",
@@ -53,7 +53,7 @@
     "eslint-config-airbnb-base": "^14.2.1",
     "eslint-plugin-import": "^2.24.2",
     "events": "^3.3.0",
-    "fast-json-patch": "^3.1.0",
+    "fast-json-patch": "^3.1.1",
     "https-browserify": "^1.0.0",
     "json-schema-diff-validator": "^0.4.1",
     "karma": "^6.4.1",

package/src/data_contract/errors/invalid_data_contract.rs

@@ -10,6 +10,7 @@ pub struct InvalidDataContractError {
 
 #[wasm_bindgen(js_class=InvalidDataContractError)]
 impl InvalidDataContractError {
+    #[wasm_bindgen(constructor)]
     pub fn new(errors: Vec<JsValue>, raw_data_contract: JsValue) -> Self {
         InvalidDataContractError {
             errors,
@@ -26,4 +27,24 @@ impl InvalidDataContractError {
     pub fn get_raw_data_contract(&self) -> JsValue {
         self.raw_data_contract.clone()
     }
+
+    #[wasm_bindgen(js_name=getMessage)]
+    pub fn get_message(&self) -> String {
+        let extended_message = if let Some(error_message) = self
+            .errors
+            .first()
+            .map(|e| Into::<js_sys::Error>::into(e.clone()).message())
+        {
+            let narrowed_message = if self.errors.len() > 1 {
+                format!(" and {} more", self.errors.len() - 1)
+            } else {
+                "".to_owned()
+            };
+            format!(": \"{error_message}\"{narrowed_message}")
+        } else {
+            "".to_owned()
+        };
+
+        format!("Data contract decode error{extended_message}")
+    }
 }

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

@@ -29,9 +29,9 @@ impl From<DataContractCreateTransition> for DataContractCreateTransitionWasm {
     }
 }
 
-impl Into<DataContractCreateTransition> for DataContractCreateTransitionWasm {
-    fn into(self) -> DataContractCreateTransition {
-        self.0
+impl From<DataContractCreateTransitionWasm> for DataContractCreateTransition {
+    fn from(val: DataContractCreateTransitionWasm) -> Self {
+        val.0
     }
 }
 
@@ -69,7 +69,7 @@ impl DataContractCreateTransitionWasm {
 
     #[wasm_bindgen(js_name=getProtocolVersion)]
     pub fn get_protocol_version(&self) -> u32 {
-        self.0.protocol_version.into()
+        self.0.protocol_version
     }
 
     #[wasm_bindgen(js_name=getEntropy)]

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

@@ -1,10 +1,10 @@
 use dpp::data_contract::state_transition::data_contract_create_transition::validation::state::validate_data_contract_create_transition_state::validate_data_contract_create_transition_state as dpp_validate_data_contract_create_transition_state;
 use wasm_bindgen::prelude::*;
 
+use crate::validation::ValidationResultWasm;
 use crate::{
     errors::from_dpp_err,
     state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
-    validation_result::ValidationResultWasm,
     DataContractCreateTransitionWasm,
 };
 
@@ -19,6 +19,6 @@ pub async fn validate_data_contract_create_transition_state(
         &state_transition.into(),
     )
     .await
-    .map(Into::into)
+    .map(Into::<ValidationResultWasm>::into)
     .map_err(from_dpp_err)
 }

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

@@ -0,0 +1,44 @@
+use std::ops::Deref;
+
+use dpp::data_contract::state_transition::apply_data_contract_update_transition_factory::ApplyDataContractUpdateTransition;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    DataContractUpdateTransitionWasm,
+};
+
+#[wasm_bindgen(js_name=ApplyDataContractUpdateTransition)]
+pub struct ApplyDataContractUpdateTransitionWasm(
+    ApplyDataContractUpdateTransition<ExternalStateRepositoryLikeWrapper>,
+);
+
+impl From<ApplyDataContractUpdateTransition<ExternalStateRepositoryLikeWrapper>>
+    for ApplyDataContractUpdateTransitionWasm
+{
+    fn from(wa: ApplyDataContractUpdateTransition<ExternalStateRepositoryLikeWrapper>) -> Self {
+        ApplyDataContractUpdateTransitionWasm(wa)
+    }
+}
+
+#[wasm_bindgen(js_class=ApplyDataContractUpdateTransition)]
+impl ApplyDataContractUpdateTransitionWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+    ) -> ApplyDataContractUpdateTransitionWasm {
+        let pinned_js_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+        ApplyDataContractUpdateTransition::new(pinned_js_state_repository).into()
+    }
+
+    #[wasm_bindgen(js_name=applyDataContractUpdateTransition)]
+    pub async fn apply_data_contract_update_transition(
+        &self,
+        transition: DataContractUpdateTransitionWasm,
+    ) -> Result<(), JsError> {
+        self.0
+            .apply_data_contract_update_transition(&transition.into())
+            .await
+            .map_err(|e| e.deref().into())
+    }
+}

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

@@ -0,0 +1,147 @@
+mod apply;
+mod validation;
+
+pub use apply::*;
+pub use validation::*;
+
+use dpp::{
+    data_contract::state_transition::DataContractUpdateTransition,
+    state_transition::{
+        StateTransitionConvert, StateTransitionIdentitySigned, StateTransitionLike,
+    },
+};
+use serde::{Deserialize, Serialize};
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    buffer::Buffer,
+    errors::{from_dpp_err, RustConversionError},
+    identifier::IdentifierWrapper,
+    with_js_error, DataContractParameters, DataContractWasm, StateTransitionExecutionContextWasm,
+};
+
+#[wasm_bindgen(js_name=DataContractUpdateTransition)]
+pub struct DataContractUpdateTransitionWasm(DataContractUpdateTransition);
+
+impl From<DataContractUpdateTransition> for DataContractUpdateTransitionWasm {
+    fn from(v: DataContractUpdateTransition) -> Self {
+        DataContractUpdateTransitionWasm(v)
+    }
+}
+
+impl From<DataContractUpdateTransitionWasm> for DataContractUpdateTransition {
+    fn from(val: DataContractUpdateTransitionWasm) -> Self {
+        val.0
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DataContractUpdateTransitionParameters {
+    protocol_version: u32,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    data_contract: Option<DataContractParameters>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    entropy: Option<Vec<u8>>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    signature_public_key_id: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    signature: Option<Vec<u8>>,
+}
+
+#[wasm_bindgen(js_class=DataContractUpdateTransition)]
+impl DataContractUpdateTransitionWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<DataContractUpdateTransitionWasm, JsValue> {
+        let parameters: DataContractUpdateTransitionParameters =
+            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+        DataContractUpdateTransition::from_raw_object(
+            serde_json::to_value(parameters).expect("the struct will be a valid json"),
+        )
+        .map(Into::into)
+        .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=getDataContract)]
+    pub fn get_data_contract(&self) -> DataContractWasm {
+        self.0.data_contract.clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getProtocolVersion)]
+    pub fn get_protocol_version(&self) -> u32 {
+        self.0.protocol_version
+    }
+
+    #[wasm_bindgen(js_name=getEntropy)]
+    pub fn get_entropy(&self) -> Buffer {
+        Buffer::from_bytes(&self.0.data_contract.entropy)
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn get_owner_id(&self) -> IdentifierWrapper {
+        self.0.get_owner_id().clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u32 {
+        self.0.get_type() as u32
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self, skip_signature: Option<bool>) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        Ok(self
+            .0
+            .to_json(skip_signature.unwrap_or(false))
+            .map_err(from_dpp_err)?
+            .serialize(&serializer)
+            .expect("JSON is a valid object"))
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self, skip_signature: Option<bool>) -> Result<Buffer, JsValue> {
+        let bytes = self
+            .0
+            .to_buffer(skip_signature.unwrap_or(false))
+            .map_err(from_dpp_err)?;
+        Ok(Buffer::from_bytes(&bytes))
+    }
+
+    #[wasm_bindgen(js_name=getModifiedDataIds)]
+    pub fn get_modified_data_ids(&self) -> Vec<JsValue> {
+        self.0
+            .get_modified_data_ids()
+            .into_iter()
+            .map(|identifier| Into::<IdentifierWrapper>::into(identifier.clone()).into())
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=isDataContractStateTransition)]
+    pub fn is_data_contract_state_transition(&self) -> bool {
+        self.0.is_data_contract_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=isDocumentStateTransition)]
+    pub fn is_document_state_transition(&self) -> bool {
+        self.0.is_document_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=isIdentityStateTransition)]
+    pub fn is_identity_state_transition(&self) -> bool {
+        self.0.is_identity_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=setExecutionContext)]
+    pub fn set_execution_context(&mut self, context: &StateTransitionExecutionContextWasm) {
+        self.0.set_execution_context(context.into())
+    }
+
+    #[wasm_bindgen(js_name=hash)]
+    pub fn hash(&self, skip_signature: Option<bool>) -> Result<Buffer, JsValue> {
+        let bytes = self
+            .0
+            .hash(skip_signature.unwrap_or(false))
+            .map_err(from_dpp_err)?;
+        Ok(Buffer::from_bytes(&bytes))
+    }
+}

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

@@ -0,0 +1,46 @@
+use std::collections::BTreeMap;
+
+use dpp::data_contract::state_transition::data_contract_update_transition::validation::{
+    basic::validate_indices_are_backward_compatible as dpp_validate_indices_are_backward_compatible,
+    state::validate_data_contract_update_transition_state::validate_data_contract_update_transition_state as dpp_validate_data_contract_update_transition_state,
+};
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    errors::{from_dpp_err, protocol_error::from_protocol_error},
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    validation::ValidationResultWasm,
+    DataContractUpdateTransitionWasm,
+};
+
+#[wasm_bindgen(js_name=validateDataContractUpdateTransitionState)]
+pub async fn validate_data_contract_update_transition_state(
+    state_repository: ExternalStateRepositoryLike,
+    state_transition: DataContractUpdateTransitionWasm,
+) -> Result<ValidationResultWasm, JsValue> {
+    let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+    dpp_validate_data_contract_update_transition_state(
+        &wrapped_state_repository,
+        &state_transition.into(),
+    )
+    .await
+    .map(Into::into)
+    .map_err(from_dpp_err)
+}
+
+#[wasm_bindgen(js_name=validateIndicesAreBackwardCompatible)]
+pub fn validate_indices_are_backward_compatible(
+    old_documents_schema: JsValue,
+    new_documents_schema: JsValue,
+) -> Result<ValidationResultWasm, JsValue> {
+    let old_documents = serde_wasm_bindgen::from_value::<BTreeMap<String, serde_json::Value>>(
+        old_documents_schema,
+    )?;
+    let new_documents = serde_wasm_bindgen::from_value::<BTreeMap<String, serde_json::Value>>(
+        new_documents_schema,
+    )?;
+
+    dpp_validate_indices_are_backward_compatible(old_documents.iter(), new_documents.iter())
+        .map(Into::into)
+        .map_err(from_protocol_error)
+}

package/src/data_contract/state_transition/mod.rs

@@ -1,3 +1,5 @@
 mod data_contract_create_transition;
+mod data_contract_update_transition;
 
 pub use data_contract_create_transition::*;
+pub use data_contract_update_transition::*;