pshenmic-dpp 1.0.3 → 1.0.5

package/package.json

@@ -1,25 +1,32 @@
 {
   "name": "pshenmic-dpp",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "main": "dist/wasm/pshenmic_dpp.js",
   "repository": {
     "type": "git",
     "url": "https://github.com/owl352/pshenmic-dpp"
   },
   "scripts": {
-    "tsc": "tsc",
     "build:bin": "./scripts/build.sh",
     "build:js": "./scripts/build-js.sh",
     "build:full": "./scripts/build.sh && ./scripts/build-js.sh",
-    "build:raw": "./scripts/build.sh && RAW=true ./scripts/build-js.sh"
+    "build:raw": "./scripts/build.sh && RAW=true ./scripts/build-js.sh",
+    "babel": "babel dist/wasm --out-dir dist/cjs/wasm",
+    "tests": "mocha ./tests/*.spec.js"
   },
   "author": "owl352",
   "license": "ISC",
   "description": "",
   "devDependencies": {
-    "babel": "^6.23.0",
-    "babel-cli": "^6.26.0",
-    "typescript": "^5.8.2"
+    "@babel/cli": "^7.27.0",
+    "@babel/core": "^7.26.10",
+    "@babel/plugin-transform-modules-commonjs": "^7.26.3",
+    "@babel/plugin-transform-runtime": "^7.26.10",
+    "@babel/preset-env": "^7.26.9",
+    "@scure/base": "^1.2.4",
+    "core-js": "^3.41.0",
+    "mocha": "^11.1.0",
+    "standard": "^17.1.2"
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

package/packages/{cbor-conversation → cbor_conversation}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pshenmic_dpp_document_search"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
@@ -15,7 +15,3 @@ pshenmic_dpp_utils = {path = "../utils"}
 base64 = "0.22.1"
 ciborium = "0.2.2"
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
-
-[profile.release]
-lto = true
-opt-level = 'z'

package/packages/data_contract/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pshenmic_dpp_data_contract"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
@@ -11,11 +11,7 @@ wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
 pshenmic_dpp_utils = {path = "../utils"}
 pshenmic_dpp_enums = {path = "../enums"}
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
-    "data-contract-json-conversion"
+    "data-contract-json-conversion",
 ]}
+js-sys = "0.3.53"
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
-#serde = { version = "1.0.219", features = ["derive"] }
-
-[profile.release]
-lto = true
-opt-level = 'z'

package/packages/data_contract/src/lib.rs

@@ -1,5 +1,6 @@
 use dpp::dashcore::hashes::serde::Serialize;
-use dpp::data_contract::accessors::v0::DataContractV0Getters;
+use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters};
+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::document_type::DocumentTypeRef;
@@ -7,12 +8,16 @@ use dpp::data_contract::errors::DataContractError;
 use dpp::data_contract::schema::DataContractSchemaMethodsV0;
 use dpp::data_contract::{DataContract, DataContractV0};
 use dpp::platform_value::string_encoding::Encoding::Base58;
+use dpp::platform_value::{Value, ValueMap};
+use dpp::prelude::IdentityNonce;
 use dpp::serialization::{
     PlatformDeserializableWithPotentialValidationFromVersionedStructure,
     PlatformSerializableWithPlatformVersion,
 };
+use dpp::version::PlatformVersion;
 use pshenmic_dpp_enums::platform::PlatformVersionWASM;
-use pshenmic_dpp_utils::{ToSerdeJSONExt, WithJsError};
+use pshenmic_dpp_utils::{ToSerdeJSONExt, WithJsError, identifier_from_js_value};
+use std::collections::BTreeMap;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -35,46 +40,137 @@ impl From<DataContractWASM> for DataContract {
 #[wasm_bindgen]
 impl DataContractWASM {
     #[wasm_bindgen(constructor)]
-    pub fn new(
+    pub fn from_js_values(
+        js_owner_id: JsValue,
+        identity_nonce: IdentityNonce,
+        js_schema: JsValue,
+        js_definitions: Option<js_sys::Object>,
+        full_validation: bool,
+        js_platform_version: JsValue,
+    ) -> Result<DataContractWASM, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        let owner_id = identifier_from_js_value(&js_owner_id)?;
+
+        let owner_id_value = Value::from(owner_id.to_string(Base58));
+
+        let schema: Value = serde_wasm_bindgen::from_value(js_schema)?;
+
+        let platform_version: PlatformVersion = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1.into(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?.into(),
+        };
+
+        let data_contract_structure_version_value = Value::from(
+            platform_version
+                .dpp
+                .contract_versions
+                .contract_structure_version
+                .to_string(),
+        );
+
+        let definitions = js_definitions
+            .map(|definitions| serde_wasm_bindgen::from_value(definitions.into()))
+            .transpose()?;
+
+        let definitions_value = Value::from(definitions);
+
+        let data_contract_id = DataContract::generate_data_contract_id_v0(owner_id, identity_nonce);
+
+        let data_contract_id_value = Value::from(data_contract_id.to_string(Base58));
+
+        let config =
+            DataContractConfig::default_for_version(&platform_version.clone()).with_js_error()?;
+
+        let config_value = config
+            .serialize(&serializer)
+            .map_err(JsValue::from)?
+            .with_serde_to_platform_value_map()?;
+
+        let mut contract_value = Value::Map(ValueMap::new());
+
+        contract_value
+            .set_value("$format_version", data_contract_structure_version_value)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        contract_value
+            .set_value("id", data_contract_id_value)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        contract_value
+            .set_value("config", Value::from(config_value))
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        contract_value
+            .set_value("version", Value::from(1u16))
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        contract_value
+            .set_value("ownerId", owner_id_value)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        contract_value
+            .set_value("schemaDefs", definitions_value)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        contract_value
+            .set_value("documentSchemas", schema)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        Ok(DataContractWASM(
+            DataContract::from_value(contract_value, full_validation, &platform_version)
+                .with_js_error()?,
+        ))
+    }
+
+    #[wasm_bindgen(js_name = "fromValue")]
+    pub fn from_value(
         js_value: JsValue,
         full_validation: bool,
-        platform_version: PlatformVersionWASM,
+        js_platform_version: JsValue,
     ) -> Result<DataContractWASM, JsValue> {
-        let value = js_value.with_serde_to_platform_value();
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
 
-        match value {
-            Ok(v) => {
-                let v0_contract =
-                    DataContractV0::from_value(v, full_validation, &platform_version.into())
-                        .with_js_error()?;
+        let value = js_value.with_serde_to_platform_value()?;
 
-                Ok(DataContractWASM(DataContract::V0(v0_contract)))
-            }
-            Err(err) => Err(err),
-        }
+        let v0_contract =
+            DataContractV0::from_value(value, full_validation, &platform_version.into())
+                .with_js_error()?;
+
+        Ok(DataContractWASM(DataContract::V0(v0_contract)))
     }
 
     #[wasm_bindgen(js_name = "fromBytes")]
     pub fn from_bytes(
         bytes: Vec<u8>,
         full_validation: bool,
-        platform_version: PlatformVersionWASM,
+        js_platform_version: JsValue,
     ) -> Result<DataContractWASM, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
         let rs_data_contract = DataContract::versioned_deserialize(
             &bytes.as_slice(),
             full_validation,
             &platform_version.into(),
         )
-        .with_js_error();
+        .with_js_error()?;
 
-        match rs_data_contract {
-            Ok(rs_data_contract) => Ok(DataContractWASM(rs_data_contract)),
-            Err(err) => Err(err),
-        }
+        Ok(DataContractWASM(rs_data_contract))
     }
 
     #[wasm_bindgen(js_name = "toBytes")]
-    pub fn to_bytes(&self, platform_version: PlatformVersionWASM) -> Result<Vec<u8>, JsValue> {
+    pub fn to_bytes(&self, js_platform_version: JsValue) -> Result<Vec<u8>, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
         let rs_data_contract: DataContract = self.0.clone();
 
         rs_data_contract
@@ -83,57 +179,148 @@ impl DataContractWASM {
     }
 
     #[wasm_bindgen(js_name = "toValue")]
-    pub fn to_value(&self, platform_version: PlatformVersionWASM) -> Result<JsValue, JsValue> {
-        let value = self
-            .0
+    pub fn to_value(&self, js_platform_version: JsValue) -> Result<JsValue, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        self.0
             .clone()
             .to_value(&platform_version.into())
-            .with_js_error();
-
-        match value {
-            Ok(v) => Ok(serde_wasm_bindgen::to_value(&v).unwrap()),
-            Err(err) => Err(err),
-        }
+            .with_js_error()?
+            .serialize(&serializer)
+            .map_err(JsValue::from)
     }
 
     #[wasm_bindgen(js_name = "getSchema")]
-    pub fn get_schema(&self) -> JsValue {
+    pub fn get_schemas(&self) -> Result<JsValue, JsValue> {
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
 
-        self.0.document_schemas().serialize(&serializer).unwrap()
+        self.0
+            .document_schemas()
+            .serialize(&serializer)
+            .map_err(JsValue::from)
     }
 
-    #[wasm_bindgen(js_name = "getDataContractVersion")]
-    pub fn get_data_contract_version(&self) -> u32 {
+    #[wasm_bindgen(js_name = "getVersion")]
+    pub fn get_version(&self) -> u32 {
         self.0.version()
     }
 
-    #[wasm_bindgen(js_name = "getDataContractIdentifier")]
-    pub fn get_data_contract_identifier(&self) -> JsValue {
-        JsValue::from_str(&*self.0.id().to_string(Base58))
+    #[wasm_bindgen(js_name = "getId")]
+    pub fn get_id(&self) -> Vec<u8> {
+        self.0.id().to_vec()
     }
 
     #[wasm_bindgen(js_name = "getOwnerId")]
-    pub fn get_owner_id(&self) -> JsValue {
-        JsValue::from_str(&*self.0.owner_id().to_string(Base58))
+    pub fn get_owner_id(&self) -> Vec<u8> {
+        self.0.owner_id().to_vec()
     }
 
     #[wasm_bindgen(js_name = "getConfig")]
-    pub fn get_config(&self) -> JsValue {
+    pub fn get_config(&self) -> Result<JsValue, JsValue> {
         self.0
             .config()
             .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
-            .unwrap()
+            .map_err(JsValue::from)
+    }
+
+    #[wasm_bindgen(js_name = "setId")]
+    pub fn set_id(&mut self, js_data_contract_id: JsValue) -> Result<(), JsValue> {
+        let data_contract_id = identifier_from_js_value(&js_data_contract_id)?;
+
+        Ok(self.0.set_id(data_contract_id))
+    }
+
+    #[wasm_bindgen(js_name = "setOwnerId")]
+    pub fn set_owner_id(&mut self, js_owner_id: JsValue) -> Result<(), JsValue> {
+        let owner_id = identifier_from_js_value(&js_owner_id)?;
+
+        Ok(self.0.set_owner_id(owner_id))
+    }
+
+    #[wasm_bindgen(js_name = "setVersion")]
+    pub fn set_version(&mut self, version: u32) {
+        self.0.set_version(version)
+    }
+
+    #[wasm_bindgen(js_name = "setConfig")]
+    pub fn set_config(
+        &mut self,
+        js_config: JsValue,
+        js_platform_version: JsValue,
+    ) -> Result<(), JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
+        let config_value: Value = serde_wasm_bindgen::from_value(js_config)?;
+
+        let config = DataContractConfig::from_value(config_value, &platform_version.into())
+            .with_js_error()?;
+
+        self.0.set_config(config);
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name = "setSchema")]
+    pub fn set_schemas(
+        &mut self,
+        js_schema: JsValue,
+        js_definitions: Option<js_sys::Object>,
+        full_validation: bool,
+        js_platform_version: JsValue,
+    ) -> Result<(), JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
+        let schema = js_schema.with_serde_to_platform_value_map()?;
+
+        let definitions: Option<BTreeMap<String, Value>> = js_definitions
+            .map(|definitions| serde_wasm_bindgen::from_value(definitions.into()))
+            .transpose()?;
+
+        self.0
+            .set_document_schemas(
+                schema,
+                definitions,
+                full_validation,
+                &mut Vec::new(),
+                &platform_version.into(),
+            )
+            .with_js_error()?;
+
+        Ok(())
     }
 
     #[wasm_bindgen(js_name = "toJson")]
-    pub fn to_json(&self, platform_version: PlatformVersionWASM) -> Result<JsValue, JsValue> {
-        let json = self.0.to_json(&platform_version.into()).with_js_error();
+    pub fn to_json(&self, js_platform_version: JsValue) -> Result<JsValue, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
+        let json = self.0.to_json(&platform_version.into()).with_js_error()?;
+
+        json.serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .map_err(JsValue::from)
+    }
+
+    #[wasm_bindgen(js_name = "generateId")]
+    pub fn generate_id(
+        js_owner_id: JsValue,
+        identity_nonce: IdentityNonce,
+    ) -> Result<Vec<u8>, JsValue> {
+        let owner_id = identifier_from_js_value(&js_owner_id)?;
 
-        match json {
-            Ok(json) => Ok(json.serialize(&serde_wasm_bindgen::Serializer::json_compatible())?),
-            Err(err) => Err(err),
-        }
+        Ok(DataContract::generate_data_contract_id_v0(owner_id, identity_nonce).to_vec())
     }
 }
 

package/packages/{document_batch → data_contract_transitions}/Cargo.toml

@@ -1,22 +1,14 @@
 [package]
-name = "pshenmic_dpp_document_batch"
-version = "0.1.0"
+name = "pshenmic_dpp_data_contract_transitions"
+version.workspace = true
 edition = "2024"
 
-[lib]
-crate-type = ["cdylib", "lib"]
-
 [dependencies]
 wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
-pshenmic_dpp_document = {path = "../document"}
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
+    "state-transition-signing"
+]}
+pshenmic_dpp_data_contract = {path = "../data_contract"}
 pshenmic_dpp_enums = {path = "../enums"}
 pshenmic_dpp_utils = {path = "../utils"}
 pshenmic_dpp_state_transition = {path = "../state_transition"}
-dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
-    "document-json-conversion",
-]}
-
-
-[profile.release]
-lto = true
-opt-level = 'z'

package/packages/data_contract_transitions/src/create/mod.rs

@@ -0,0 +1,161 @@
+use dpp::ProtocolError;
+use dpp::data_contract::serialized_version::DataContractInSerializationFormat;
+use dpp::prelude::{DataContract, IdentityNonce};
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
+use dpp::state_transition::StateTransition;
+use dpp::state_transition::data_contract_create_transition::accessors::DataContractCreateTransitionAccessorsV0;
+use dpp::state_transition::data_contract_create_transition::{
+    DataContractCreateTransition, DataContractCreateTransitionV0,
+};
+use dpp::validation::operations::ProtocolValidationOperation;
+use dpp::version::{
+    FeatureVersion, ProtocolVersion, TryFromPlatformVersioned, TryIntoPlatformVersioned,
+};
+use pshenmic_dpp_data_contract::DataContractWASM;
+use pshenmic_dpp_enums::platform::PlatformVersionWASM;
+use pshenmic_dpp_state_transition::StateTransitionWASM;
+use pshenmic_dpp_utils::WithJsError;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "DataContractCreateTransitionWASM")]
+pub struct DataContractCreateTransitionWASM(DataContractCreateTransition);
+
+#[wasm_bindgen]
+impl DataContractCreateTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        data_contract: &DataContractWASM,
+        identity_nonce: IdentityNonce,
+        js_platform_version: JsValue,
+    ) -> Result<DataContractCreateTransitionWASM, JsValue> {
+        let rs_data_contract: DataContract = data_contract.clone().into();
+
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
+        let rs_data_contract_in_serialized: Result<
+            DataContractInSerializationFormat,
+            ProtocolError,
+        > = rs_data_contract.try_into_platform_versioned(&platform_version.into());
+
+        let rs_data_contract_create_transition_v0: DataContractCreateTransitionV0 =
+            DataContractCreateTransitionV0 {
+                data_contract: rs_data_contract_in_serialized.with_js_error()?,
+                identity_nonce,
+                user_fee_increase: 0,
+                signature_public_key_id: 0,
+                signature: Default::default(),
+            };
+
+        let rs_data_contract_transition =
+            DataContractCreateTransition::V0(rs_data_contract_create_transition_v0);
+
+        Ok(DataContractCreateTransitionWASM(
+            rs_data_contract_transition,
+        ))
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<DataContractCreateTransitionWASM, JsValue> {
+        let rs_data_contract_create_transition: DataContractCreateTransition =
+            DataContractCreateTransition::deserialize_from_bytes(bytes.as_slice())
+                .with_js_error()?;
+
+        Ok(DataContractCreateTransitionWASM(
+            rs_data_contract_create_transition,
+        ))
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.serialize_to_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "getFeatureVersion")]
+    pub fn get_feature_version(&self) -> FeatureVersion {
+        self.0.feature_version()
+    }
+
+    #[wasm_bindgen(js_name = "verifyProtocolVersion")]
+    pub fn verify_protocol_version(
+        &self,
+        protocol_version: ProtocolVersion,
+    ) -> Result<bool, JsValue> {
+        self.0
+            .verify_protocol_version(protocol_version)
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "setDataContract")]
+    pub fn set_data_contract(
+        &mut self,
+        data_contract: &DataContractWASM,
+        js_platform_version: JsValue,
+    ) -> Result<(), JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
+        let data_contract_serialization_format =
+            DataContractInSerializationFormat::try_from_platform_versioned(
+                DataContract::from(data_contract.clone()),
+                &platform_version.into(),
+            )
+            .with_js_error()?;
+
+        self.0.set_data_contract(data_contract_serialization_format);
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name = "getDataContract")]
+    pub fn get_data_contract(
+        &self,
+        js_platform_version: JsValue,
+        full_validation: Option<bool>,
+    ) -> Result<DataContractWASM, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
+        let rs_data_contract_serialization_format = self.0.data_contract();
+
+        let mut validation_operations: Vec<ProtocolValidationOperation> = Vec::new();
+
+        let rs_data_contract = DataContract::try_from_platform_versioned(
+            rs_data_contract_serialization_format.clone(),
+            full_validation.unwrap_or(false),
+            &mut validation_operations,
+            &platform_version.into(),
+        )
+        .with_js_error()?;
+
+        Ok(DataContractWASM::from(rs_data_contract))
+    }
+
+    #[wasm_bindgen(js_name = "toStateTransition")]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        let rs_state_transition = StateTransition::from(self.0.clone());
+
+        StateTransitionWASM::from(rs_state_transition)
+    }
+
+    #[wasm_bindgen(js_name = "fromStateTransition")]
+    pub fn from_state_transition(
+        state_transition: &StateTransitionWASM,
+    ) -> Result<DataContractCreateTransitionWASM, JsValue> {
+        let rs_transition = StateTransition::from(state_transition.clone());
+
+        match rs_transition {
+            StateTransition::DataContractCreate(state_transition) => {
+                Ok(DataContractCreateTransitionWASM(state_transition))
+            }
+            _ => Err(JsValue::from("Incorrect transition type")),
+        }
+    }
+}

package/packages/data_contract_transitions/src/lib.rs

@@ -0,0 +1,2 @@
+mod create;
+mod update;