@dashevo/wasm-dpp 0.23.0-dev.15 → 0.24.0-dev.11

package/src/data_contract/data_contract.rs

@@ -0,0 +1,290 @@
+#![allow(clippy::from_over_into)]
+
+use std::collections::BTreeMap;
+use std::convert::{TryFrom, TryInto};
+
+pub use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use wasm_bindgen::prelude::*;
+
+use dpp::data_contract::{DataContract, SCHEMA_URI};
+use dpp::util::string_encoding::Encoding;
+
+use crate::errors::{from_dpp_err, RustConversionError};
+use crate::metadata::MetadataWasm;
+use crate::{bail_js, with_js_error};
+use crate::{buffer::Buffer, identifier::IdentifierWrapper};
+
+#[wasm_bindgen(js_name=DataContract)]
+#[derive(Debug, Clone)]
+pub struct DataContractWasm(DataContract);
+
+impl std::convert::From<DataContract> for DataContractWasm {
+    fn from(v: DataContract) -> Self {
+        DataContractWasm(v)
+    }
+}
+
+impl std::convert::Into<DataContract> for DataContractWasm {
+    fn into(self) -> DataContract {
+        self.0
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct DataContractParameters {
+    #[serde(rename = "$schema")]
+    schema: String,
+    #[serde(rename = "$id")]
+    id: Vec<u8>,
+    owner_id: Vec<u8>,
+    #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
+    documents: serde_json::Value,
+    #[serde(
+        skip_serializing_if = "serde_json::Value::is_null",
+        default,
+        rename = "$defs"
+    )]
+    defs: serde_json::Value,
+    protocol_version: u32,
+    version: u32,
+}
+
+#[wasm_bindgen(js_class=DataContract)]
+impl DataContractWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<DataContractWasm, JsValue> {
+        let parameters: DataContractParameters =
+            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+
+        DataContract::from_raw_object(
+            serde_json::to_value(parameters).expect("Implements Serialize"),
+        )
+        .map_err(from_dpp_err)
+        .map(Into::into)
+    }
+
+    #[wasm_bindgen(js_name=getProtocolVersion)]
+    pub fn get_protocol_version(&self) -> u32 {
+        self.0.protocol_version
+    }
+
+    #[wasm_bindgen(js_name=getId)]
+    pub fn get_id(&self) -> IdentifierWrapper {
+        self.0.id.clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn get_owner_id(&self) -> IdentifierWrapper {
+        self.0.owner_id.clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getVersion)]
+    pub fn get_version(&self) -> u32 {
+        self.0.version
+    }
+
+    #[wasm_bindgen(js_name=setVersion)]
+    pub fn set_version(&mut self, v: u32) {
+        self.0.version = v;
+    }
+
+    #[wasm_bindgen(js_name=incrementVersion)]
+    pub fn increment_version(&mut self) {
+        self.0.increment_version()
+    }
+
+    #[wasm_bindgen(js_name=getJsonSchemaId)]
+    pub fn get_json_schema_id(&self) -> String {
+        self.0.id.to_string(Encoding::Base58)
+    }
+
+    #[wasm_bindgen(js_name=setJsonMetaSchema)]
+    pub fn set_json_meta_schema(&mut self, schema: String) {
+        self.0.schema = schema;
+    }
+
+    #[wasm_bindgen(js_name=getJsonMetaSchema)]
+    pub fn get_json_meta_schema(&self) -> String {
+        self.0.schema.clone()
+    }
+    #[wasm_bindgen(js_name=setDocuments)]
+    pub fn set_documents(&mut self, documents: JsValue) -> Result<(), JsValue> {
+        let json_value: Value = with_js_error!(serde_wasm_bindgen::from_value(documents))?;
+
+        let mut docs: BTreeMap<String, Value> = BTreeMap::new();
+        if let Value::Object(o) = json_value {
+            for (k, v) in o.into_iter() {
+                if !v.is_object() {
+                    bail_js!("is not an object")
+                }
+                docs.insert(k, v);
+            }
+            self.0.documents = docs;
+        } else {
+            bail_js!("the parameter 'documents' is not an JS object")
+        }
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getDocuments)]
+    pub fn get_documents(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        with_js_error!(self.0.documents.serialize(&serializer))
+    }
+
+    #[wasm_bindgen(js_name=isDocumentDefined)]
+    pub fn is_document_defined(&self, doc_type: String) -> bool {
+        self.0.is_document_defined(&doc_type)
+    }
+
+    #[wasm_bindgen(js_name=setDocumentSchema)]
+    pub fn set_document_schema(
+        &mut self,
+        doc_type: String,
+        schema: JsValue,
+    ) -> Result<(), JsValue> {
+        let json_schema: Value = with_js_error!(serde_wasm_bindgen::from_value(schema))?;
+        self.0.set_document_schema(doc_type, json_schema);
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getDocumentSchema)]
+    pub fn get_document_schema(&mut self, doc_type: &str) -> Result<JsValue, JsValue> {
+        let doc_schema = self.0.get_document_schema(doc_type).map_err(from_dpp_err)?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        with_js_error!(doc_schema.serialize(&serializer))
+    }
+
+    #[wasm_bindgen(js_name=getDocumentSchemaRef)]
+    pub fn get_document_schema_ref(&self, doc_type: &str) -> Result<JsValue, JsValue> {
+        with_js_error!(serde_wasm_bindgen::to_value(
+            &self
+                .0
+                .get_document_schema_ref(doc_type)
+                .map_err(from_dpp_err)?
+        ))
+    }
+
+    #[wasm_bindgen(js_name=setDefinitions)]
+    pub fn set_definitions(&mut self, definitions: JsValue) -> Result<(), JsValue> {
+        let json_value: Value = with_js_error!(serde_wasm_bindgen::from_value(definitions))?;
+        let mut definitions: BTreeMap<String, Value> = BTreeMap::new();
+        if let Value::Object(o) = json_value {
+            for (k, v) in o.into_iter() {
+                // v must be a Object
+                if !v.is_object() {
+                    bail_js!("{:?} is not an object", v);
+                }
+                definitions.insert(k, v);
+            }
+            if definitions.is_empty() {
+                bail_js!("`defitions` cannot be empty");
+            }
+            self.0.defs = Some(definitions);
+        } else {
+            bail_js!("the parameter 'definitions' is not an JS object");
+        }
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getDefinitions)]
+    pub fn get_definitions(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        with_js_error!(self.0.defs.serialize(&serializer))
+    }
+
+    #[wasm_bindgen(js_name=setEntropy)]
+    pub fn set_entropy(&mut self, e: Vec<u8>) -> Result<(), JsValue> {
+        let entropy: [u8; 32] = e.try_into().map_err(|_| {
+            RustConversionError::Error(String::from(
+                "unable to turn the data into 32 bytes array of bytes",
+            ))
+            .to_js_value()
+        })?;
+        self.0.entropy = entropy;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getEntropy)]
+    pub fn get_entropy(&mut self) -> Buffer {
+        Buffer::from_bytes(&self.0.entropy)
+    }
+
+    #[wasm_bindgen(js_name=getBinaryProperties)]
+    pub fn get_binary_properties(&self, doc_type: &str) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        with_js_error!(self
+            .0
+            .get_binary_properties(doc_type)
+            .map_err(from_dpp_err)?
+            .serialize(&serializer))
+    }
+
+    #[wasm_bindgen(js_name=getMetadata)]
+    pub fn get_metadata(&self) -> Option<MetadataWasm> {
+        self.0.metadata.clone().map(Into::into)
+    }
+
+    #[wasm_bindgen(js_name=setMetadata)]
+    pub fn set_metadata(&mut self, metadata: MetadataWasm) {
+        self.0.metadata = Some(metadata.into());
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let object = with_js_error!(self.0.serialize(&serializer))?;
+
+        js_sys::Reflect::set(
+            &object,
+            &Into::<JsValue>::into("$id".to_owned()),
+            &Into::<JsValue>::into(Buffer::from_bytes(&self.0.id.buffer)),
+        )
+        .expect("target is an object");
+        js_sys::Reflect::set(
+            &object,
+            &Into::<JsValue>::into("ownerId".to_owned()),
+            &Into::<JsValue>::into(Buffer::from_bytes(&self.0.owner_id.buffer)),
+        )
+        .expect("target is an object");
+        Ok(object)
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        with_js_error!(self.0.serialize(&serializer))
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
+        let bytes = self.0.to_buffer().map_err(from_dpp_err)?;
+        Ok(Buffer::from_bytes(&bytes))
+    }
+
+    #[wasm_bindgen(js_name=hash)]
+    pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.hash().map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=from)]
+    pub fn from(v: JsValue) -> Result<DataContractWasm, JsValue> {
+        let json_contract: Value = with_js_error!(serde_wasm_bindgen::from_value(v))?;
+        Ok(DataContract::try_from(json_contract)
+            .map_err(from_dpp_err)?
+            .into())
+    }
+}
+
+#[wasm_bindgen(js_name=DataContractDefaults)]
+pub struct DataContractDefaults;
+
+#[wasm_bindgen(js_class=DataContractDefaults)]
+impl DataContractDefaults {
+    #[wasm_bindgen(getter = SCHEMA)]
+    pub fn get_default_schema() -> String {
+        SCHEMA_URI.to_string()
+    }
+}

package/src/data_contract/errors/data_contract_already_exists.rs

@@ -0,0 +1 @@
+// TODO: Implement

package/src/data_contract/errors/invalid_data_contract.rs

@@ -0,0 +1,29 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidDataContractError)]
+#[derive(Debug)]
+pub struct InvalidDataContractError {
+    // we have to store it as JsValue as the errors of 'class' Consensus are of different types
+    errors: Vec<JsValue>,
+    raw_data_contract: JsValue,
+}
+
+#[wasm_bindgen(js_class=InvalidDataContractError)]
+impl InvalidDataContractError {
+    pub fn new(errors: Vec<JsValue>, raw_data_contract: JsValue) -> Self {
+        InvalidDataContractError {
+            errors,
+            raw_data_contract,
+        }
+    }
+
+    #[wasm_bindgen(js_name=getErrors)]
+    pub fn get_errors(&self) -> Vec<JsValue> {
+        self.errors.clone().into_iter().map(JsValue::from).collect()
+    }
+
+    #[wasm_bindgen(js_name=getRawDataContract)]
+    pub fn get_raw_data_contract(&self) -> JsValue {
+        self.raw_data_contract.clone()
+    }
+}

package/src/data_contract/errors/invalid_document_type.rs

@@ -0,0 +1,33 @@
+use thiserror::Error;
+use wasm_bindgen::prelude::*;
+
+use crate::DataContractWasm;
+
+#[wasm_bindgen]
+#[derive(Error, Debug)]
+#[error("Invalid Document Type")]
+pub struct InvalidDocumentTypeInDataContractError {
+    // we have to store it as JsValue as the errors of 'class' Consensus are of different types
+    doc_type: String,
+    data_contract: DataContractWasm,
+}
+
+#[wasm_bindgen]
+impl InvalidDocumentTypeInDataContractError {
+    #[wasm_bindgen(constructor)]
+    pub fn new(doc_type: String, data_contract: DataContractWasm) -> Self {
+        InvalidDocumentTypeInDataContractError {
+            doc_type,
+            data_contract,
+        }
+    }
+    #[wasm_bindgen(js_name = "getDocType")]
+    pub fn get_doc_type(&self) -> String {
+        self.doc_type.clone()
+    }
+
+    #[wasm_bindgen(js_name = "getDataContract")]
+    pub fn get_data_contract(&self) -> DataContractWasm {
+        self.data_contract.clone()
+    }
+}

package/src/data_contract/errors/mod.rs

@@ -0,0 +1,37 @@
+mod data_contract_already_exists;
+mod invalid_data_contract;
+mod invalid_document_type;
+
+use wasm_bindgen::prelude::*;
+
+use crate::errors::consensus_error::from_consensus_error;
+pub use data_contract_already_exists::*;
+use dpp::data_contract::errors::DataContractError;
+pub use invalid_data_contract::*;
+
+pub fn from_data_contract_to_js_error(e: DataContractError) -> JsValue {
+    match e {
+        DataContractError::InvalidDataContractError {
+            errors,
+            raw_data_contract,
+        } => {
+            let js_errors = errors.into_iter().map(from_consensus_error).collect();
+
+            InvalidDataContractError::new(
+                js_errors,
+                serde_wasm_bindgen::to_value(&raw_data_contract)
+                    .expect("statically known structure should be a valid JSON"),
+            )
+            .into()
+        }
+        DataContractError::InvalidDocumentTypeError {
+            doc_type,
+            data_contract,
+        } => invalid_document_type::InvalidDocumentTypeInDataContractError::new(
+            doc_type,
+            data_contract.into(),
+        )
+        .into(),
+        _ => todo!(),
+    }
+}

package/src/data_contract/index.rs

@@ -0,0 +1,61 @@
+use dpp::{data_contract::extra::IndexProperty, util::json_schema::Index};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=IndexProperty)]
+#[derive(Debug, Clone)]
+pub struct IndexPropertyWasm {
+    inner: IndexProperty,
+}
+
+impl From<IndexProperty> for IndexPropertyWasm {
+    fn from(v: IndexProperty) -> Self {
+        Self { inner: v }
+    }
+}
+
+#[wasm_bindgen(js_class=IndexProperty)]
+impl IndexPropertyWasm {
+    #[wasm_bindgen(js_name=getName)]
+    pub fn get_name(&self) -> String {
+        self.inner.name.clone()
+    }
+
+    #[wasm_bindgen(js_name=isAscending)]
+    pub fn is_ascending(&self) -> bool {
+        self.inner.ascending
+    }
+}
+
+#[wasm_bindgen(js_name=IndexDefinition)]
+#[derive(Debug, Clone)]
+pub struct IndexDefinitionWasm {
+    inner: Index,
+}
+
+impl From<Index> for IndexDefinitionWasm {
+    fn from(v: Index) -> Self {
+        Self { inner: v }
+    }
+}
+
+#[wasm_bindgen(js_class=IndexDefinition)]
+impl IndexDefinitionWasm {
+    #[wasm_bindgen(js_name=getName)]
+    pub fn get_name(&self) -> String {
+        self.inner.name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getProperties)]
+    pub fn get_properties(&self) -> Vec<JsValue> {
+        self.inner
+            .properties
+            .iter()
+            .map(|property| IndexPropertyWasm::from(property.clone()).into())
+            .collect::<Vec<JsValue>>()
+    }
+
+    #[wasm_bindgen(js_name=isUnique)]
+    pub fn is_unique(&self) -> bool {
+        self.inner.unique
+    }
+}

package/src/data_contract/mod.rs

@@ -0,0 +1,10 @@
+#![allow(clippy::module_inception)]
+pub use data_contract::*;
+pub use state_transition::*;
+
+mod data_contract;
+pub mod errors;
+mod state_transition;
+
+mod index;
+pub use index::*;

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

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

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

@@ -0,0 +1,138 @@
+mod apply;
+mod validation;
+
+pub use apply::*;
+pub use validation::*;
+
+use dpp::{
+    data_contract::state_transition::DataContractCreateTransition,
+    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=DataContractCreateTransition)]
+pub struct DataContractCreateTransitionWasm(DataContractCreateTransition);
+
+impl From<DataContractCreateTransition> for DataContractCreateTransitionWasm {
+    fn from(v: DataContractCreateTransition) -> Self {
+        DataContractCreateTransitionWasm(v)
+    }
+}
+
+impl Into<DataContractCreateTransition> for DataContractCreateTransitionWasm {
+    fn into(self) -> DataContractCreateTransition {
+        self.0
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DataContractCreateTransitionParameters {
+    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=DataContractCreateTransition)]
+impl DataContractCreateTransitionWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<DataContractCreateTransitionWasm, JsValue> {
+        let parameters: DataContractCreateTransitionParameters =
+            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+        DataContractCreateTransition::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.into()
+    }
+
+    #[wasm_bindgen(js_name=getEntropy)]
+    pub fn get_entropy(&self) -> Buffer {
+        Buffer::from_bytes(&self.0.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())
+    }
+}

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

@@ -0,0 +1,24 @@
+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::{
+    errors::from_dpp_err,
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    validation_result::ValidationResultWasm,
+    DataContractCreateTransitionWasm,
+};
+
+#[wasm_bindgen(js_name=validateDataContractCreateTransitionState)]
+pub async fn validate_data_contract_create_transition_state(
+    state_repository: ExternalStateRepositoryLike,
+    state_transition: DataContractCreateTransitionWasm,
+) -> Result<ValidationResultWasm, JsValue> {
+    let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+    dpp_validate_data_contract_create_transition_state(
+        &wrapped_state_repository,
+        &state_transition.into(),
+    )
+    .await
+    .map(Into::into)
+    .map_err(from_dpp_err)
+}

package/src/data_contract/state_transition/mod.rs

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