@dashevo/wasm-dpp 1.0.0-dev.7 → 1.0.0-dev.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "1.0.0-dev.7",
+  "version": "1.0.0-dev.8",
   "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.23.3",
     "@babel/preset-env": "^7.23.3",
     "@dashevo/dashcore-lib": "~0.21.1",
-    "@dashevo/dpns-contract": "1.0.0-dev.7",
+    "@dashevo/dpns-contract": "1.0.0-dev.8",
     "@types/bs58": "^4.0.1",
     "@types/node": "^14.6.0",
     "@yarnpkg/pnpify": "^4.0.0-rc.42",

package/src/data_contract/data_contract.rs

@@ -151,6 +151,7 @@ impl DataContractWasm {
         let document_type = self
             .inner
             .document_type_for_name(doc_type)
+            .map_err(ProtocolError::DataContractError)
             .with_js_error()?;
 
         let mut binary_paths = BTreeMap::new();
@@ -234,7 +235,11 @@ impl DataContractWasm {
 
     #[wasm_bindgen(js_name=getDocumentSchema)]
     pub fn document_schema(&mut self, name: &str) -> Result<JsValue, JsValue> {
-        let document_type = self.inner.document_type_for_name(name).with_js_error()?;
+        let document_type = self
+            .inner
+            .document_type_for_name(name)
+            .map_err(ProtocolError::DataContractError)
+            .with_js_error()?;
 
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
 

package/src/data_contract/data_contract_facade.rs

@@ -8,7 +8,6 @@ use dpp::identifier::Identifier;
 use crate::data_contract::state_transition::DataContractCreateTransitionWasm;
 use crate::data_contract::state_transition::DataContractUpdateTransitionWasm;
 use crate::data_contract::DataContractWasm;
-use crate::entropy_generator::ExternalEntropyGenerator;
 use crate::errors::protocol_error::from_protocol_error;
 use crate::utils::{
     get_bool_from_options, ToSerdeJSONExt, WithJsError, SKIP_VALIDATION_PROPERTY_NAME,

package/src/data_contract/errors/mod.rs

@@ -7,19 +7,8 @@ use wasm_bindgen::prelude::*;
 pub use data_contract_generic_error::*;
 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,
-        } => InvalidDataContractError::new(
-            errors,
-            serde_wasm_bindgen::to_value(&raw_data_contract)
-                .expect("statically known structure should be a valid JSON"),
-        )
-        .into(),
         DataContractError::InvalidDocumentTypeError(err) => {
             invalid_document_type::InvalidDocumentTypeInDataContractError::new(
                 err.document_type(),

package/src/data_contract_factory/data_contract_factory.rs

@@ -4,7 +4,6 @@ use dpp::data_contract::created_data_contract::CreatedDataContract;
 use dpp::{data_contract::DataContractFactory, platform_value, prelude::Identifier, ProtocolError};
 use wasm_bindgen::prelude::*;
 
-use crate::entropy_generator::ExternalEntropyGenerator;
 use crate::utils::{ToSerdeJSONExt, WithJsError};
 
 use crate::data_contract::{DataContractCreateTransitionWasm, DataContractWasm};

package/src/document/extended_document.rs

@@ -19,6 +19,7 @@ use wasm_bindgen::prelude::*;
 
 use crate::buffer::Buffer;
 use crate::data_contract::DataContractWasm;
+#[allow(deprecated)] // BinaryType is unsed in unused code below
 use crate::document::BinaryType;
 use crate::document::{ConversionOptions, DocumentWasm};
 use crate::errors::RustConversionError;

package/src/document/factory.rs

@@ -312,33 +312,29 @@ fn extract_documents_of_action(
     documents: &JsValue,
     action: &str,
 ) -> Result<Vec<ExtendedDocument>, anyhow::Error> {
-    let mut extracted_documents: Vec<ExtendedDocument> = vec![];
-
     let documents_with_action =
         js_sys::Reflect::get(documents, &action.to_string().into()).unwrap_or(JsValue::NULL);
 
     if documents_with_action.is_null() || documents_with_action.is_undefined() {
-        return Ok(extracted_documents);
+        return Ok(vec![]);
     }
 
     let documents_array = js_sys::Array::try_from(documents_with_action)
         .map_err(|e| anyhow!("property '{}' isn't an array: {}", action, e))?;
 
-    for js_document in documents_array.iter() {
-        let document: ExtendedDocument = js_document
-            .to_wasm::<ExtendedDocumentWasm>("ExtendedDocument")
-            .map_err(|e| {
-                anyhow!(
-                    "Element in '{}' isn't an Extended Document instance: {:#?}",
-                    action,
-                    e
-                )
-            })?
-            .clone()
-            .into();
-
-        extracted_documents.push(document)
-    }
-
-    Ok(extracted_documents)
+    documents_array
+        .iter()
+        .map(|js_document| {
+            js_document
+                .to_wasm::<ExtendedDocumentWasm>("ExtendedDocument")
+                .map_err(|e| {
+                    anyhow!(
+                        "Element in '{}' isn't an Extended Document instance: {:#?}",
+                        action,
+                        e
+                    )
+                })
+                .map(|wasm_doc| wasm_doc.clone().into())
+        })
+        .collect()
 }

package/src/document/mod.rs

@@ -84,6 +84,7 @@ impl DocumentWasm {
         let document_type = js_data_contract
             .inner()
             .document_type_for_name(document_type_name.as_str())
+            .map_err(ProtocolError::DataContractError)
             .with_js_error()?;
 
         let identifier_paths = document_type.identifier_paths().iter().map(|s| s.as_str());
@@ -298,6 +299,7 @@ impl DocumentWasm {
         let document_type = data_contract
             .inner()
             .document_type_for_name(document_type_name.as_str())
+            .map_err(ProtocolError::DataContractError)
             .with_js_error()?;
         let bytes = self
             .0
@@ -329,6 +331,7 @@ impl DocumentWasm {
         let document_type = data_contract
             .inner()
             .document_type_for_name(document_type_name.as_str())
+            .map_err(ProtocolError::DataContractError)
             .with_js_error()?;
 
         if document_type.binary_paths().contains(path) {

package/src/errors/consensus/consensus_error.rs

@@ -91,10 +91,9 @@ use crate::errors::consensus::state::document::{
     DuplicateUniqueIndexErrorWasm, InvalidDocumentRevisionErrorWasm,
 };
 use crate::errors::consensus::state::identity::{
-    IdentityAlreadyExistsErrorWasm, IdentityPublicKeyDisabledAtWindowViolationErrorWasm,
-    IdentityPublicKeyIsDisabledErrorWasm, IdentityPublicKeyIsReadOnlyErrorWasm,
-    InvalidIdentityPublicKeyIdErrorWasm, InvalidIdentityRevisionErrorWasm,
-    MaxIdentityPublicKeyLimitReachedErrorWasm,
+    IdentityAlreadyExistsErrorWasm, IdentityPublicKeyIsDisabledErrorWasm,
+    IdentityPublicKeyIsReadOnlyErrorWasm, InvalidIdentityPublicKeyIdErrorWasm,
+    InvalidIdentityRevisionErrorWasm, MaxIdentityPublicKeyLimitReachedErrorWasm,
 };
 
 use crate::errors::consensus::basic::data_contract::{
@@ -170,9 +169,6 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
         StateError::InvalidIdentityRevisionError(e) => {
             InvalidIdentityRevisionErrorWasm::from(e).into()
         }
-        StateError::IdentityPublicKeyDisabledAtWindowViolationError(e) => {
-            IdentityPublicKeyDisabledAtWindowViolationErrorWasm::from(e).into()
-        }
         StateError::IdentityPublicKeyIsReadOnlyError(e) => {
             IdentityPublicKeyIsReadOnlyErrorWasm::from(e).into()
         }

package/src/errors/consensus/state/identity/invalid_identity_contract_nonce_error.rs

@@ -26,9 +26,7 @@ impl InvalidIdentityNonceErrorWasm {
 
     #[wasm_bindgen(js_name=getCurrentIdentityContractNonce)]
     pub fn current_identity_contract_nonce(&self) -> Option<u64> {
-        self.inner
-            .current_identity_contract_nonce()
-            .map(|nonce| *nonce)
+        self.inner.current_identity_contract_nonce().copied()
     }
 
     #[wasm_bindgen(js_name=getSettingIdentityContractNonce)]

package/src/errors/consensus/state/identity/mod.rs

@@ -1,7 +1,6 @@
 mod duplicated_identity_public_key_id_state_error;
 mod duplicated_identity_public_key_state_error;
 mod identity_already_exists_error;
-mod identity_public_key_disabled_at_window_violation_error;
 mod identity_public_key_is_disabled_error;
 mod identity_public_key_is_read_only_error;
 mod invalid_identity_contract_nonce_error;
@@ -13,7 +12,6 @@ mod missing_identity_public_key_ids_error;
 pub use duplicated_identity_public_key_id_state_error::*;
 pub use duplicated_identity_public_key_state_error::*;
 pub use identity_already_exists_error::*;
-pub use identity_public_key_disabled_at_window_violation_error::*;
 pub use identity_public_key_is_disabled_error::*;
 pub use identity_public_key_is_read_only_error::*;
 pub use invalid_identity_contract_nonce_error::*;

package/src/errors/protocol_error.rs

@@ -1,4 +1,3 @@
-use crate::data_contract::errors::InvalidDataContractError;
 use wasm_bindgen::JsValue;
 
 use crate::errors::consensus::consensus_error::from_consensus_error;
@@ -8,13 +7,6 @@ pub fn from_protocol_error(protocol_error: dpp::ProtocolError) -> JsValue {
         dpp::ProtocolError::ConsensusError(consensus_error) => {
             from_consensus_error(*consensus_error)
         }
-        dpp::ProtocolError::InvalidDataContractError(err) => {
-            let raw_data_contract = err.raw_data_contract();
-            let protocol = serde_wasm_bindgen::to_value(&raw_data_contract);
-            protocol.map_or_else(JsValue::from, |raw_contract| {
-                InvalidDataContractError::new(err.errors, raw_contract).into()
-            })
-        }
         dpp::ProtocolError::Error(anyhow_error) => {
             format!("Non-protocol error: {}", anyhow_error).into()
         }

package/src/identity/identity_facade.rs

@@ -257,7 +257,6 @@ impl IdentityFacadeWasm {
     ) -> Result<IdentityUpdateTransitionWasm, JsValue> {
         let (add_public_keys, disable_public_keys) =
             super::factory_utils::parse_create_identity_update_transition_keys(public_keys)?;
-        let now = js_sys::Date::now() as u64;
 
         self.0
             .create_identity_update_transition(
@@ -265,7 +264,6 @@ impl IdentityFacadeWasm {
                 identity_nonce,
                 add_public_keys,
                 disable_public_keys,
-                Some(now),
             )
             .map(Into::into)
             .with_js_error()

package/src/identity/identity_factory.rs

@@ -243,15 +243,12 @@ impl IdentityFactoryWasm {
         let (add_public_keys, disable_public_keys) =
             super::factory_utils::parse_create_identity_update_transition_keys(public_keys)?;
 
-        let now = js_sys::Date::now() as u64;
-
         self.0
             .create_identity_update_transition(
                 identity.to_owned().into(),
                 identity_nonce,
                 add_public_keys,
                 disable_public_keys,
-                Some(now),
             )
             .map(Into::into)
             .with_js_error()

package/src/identity/identity_public_key/mod.rs

@@ -12,6 +12,7 @@ use dpp::identity::identity_public_key::hash::IdentityPublicKeyHashMethodsV0;
 use dpp::identity::{IdentityPublicKey, KeyID, TimestampMillis};
 use dpp::platform_value::{BinaryData, ReplacementType};
 use dpp::serialization::ValueConvertible;
+use dpp::ProtocolError;
 
 use dpp::version::PlatformVersion;
 mod purpose;
@@ -97,7 +98,7 @@ impl IdentityPublicKeyWasm {
         self.0.set_security_level(
             security_level
                 .try_into()
-                .map_err(|e: anyhow::Error| e.to_string())?,
+                .map_err(|e: ProtocolError| e.to_string())?,
         );
         Ok(())
     }

package/src/identity/state_transition/identity_credit_withdrawal_transition/transition.rs

@@ -46,7 +46,7 @@ impl IdentityCreditWithdrawalTransitionWasm {
         let platform_version =
             &PlatformVersion::get(platform_version).map_err(|e| JsValue::from(e.to_string()))?;
 
-        IdentityCreditWithdrawalTransition::default_versioned(&platform_version)
+        IdentityCreditWithdrawalTransition::default_versioned(platform_version)
             .map(Into::into)
             .map_err(from_dpp_err)
     }
@@ -78,7 +78,7 @@ impl IdentityCreditWithdrawalTransitionWasm {
 
     #[wasm_bindgen(js_name=getAmount)]
     pub fn get_amount(&self) -> u64 {
-        self.0.amount() as u64
+        self.0.amount()
     }
 
     #[wasm_bindgen(js_name=setAmount)]
@@ -88,12 +88,12 @@ impl IdentityCreditWithdrawalTransitionWasm {
 
     #[wasm_bindgen(js_name=getCoreFeePerByte)]
     pub fn get_core_fee_per_byte(&self) -> u32 {
-        self.0.core_fee_per_byte() as u32
+        self.0.core_fee_per_byte()
     }
 
     #[wasm_bindgen(js_name=setCoreFeePerByte)]
     pub fn set_core_fee_per_byte(&mut self, core_fee_per_byte: u32) {
-        self.0.set_core_fee_per_byte(core_fee_per_byte as u32);
+        self.0.set_core_fee_per_byte(core_fee_per_byte);
     }
 
     #[wasm_bindgen(js_name=getPooling)]
@@ -126,7 +126,7 @@ impl IdentityCreditWithdrawalTransitionWasm {
 
     #[wasm_bindgen(js_name=getNonce)]
     pub fn get_nonce(&self) -> u64 {
-        self.0.nonce() as u64
+        self.0.nonce()
     }
 
     #[wasm_bindgen(js_name=setNonce)]
@@ -385,7 +385,7 @@ impl IdentityCreditWithdrawalTransitionWasm {
     #[wasm_bindgen(js_name=setSignature)]
     pub fn set_signature(&mut self, signature: Option<Vec<u8>>) {
         self.0
-            .set_signature(BinaryData::new(signature.unwrap_or(vec![])))
+            .set_signature(BinaryData::new(signature.unwrap_or_default()))
     }
 
     #[wasm_bindgen]

package/src/identity/state_transition/identity_public_key_transitions.rs

@@ -9,6 +9,7 @@ use dpp::state_transition::public_key_in_creation::IdentityPublicKeyInCreation;
 use js_sys::Reflect::delete_property;
 pub use serde::{Deserialize, Serialize};
 
+use dpp::ProtocolError;
 use std::convert::TryInto;
 use wasm_bindgen::prelude::*;
 
@@ -19,6 +20,8 @@ use dpp::version::PlatformVersion;
 #[derive(Deserialize, Default)]
 #[serde(rename_all = "camelCase")]
 struct ToObjectOptions {
+    #[allow(dead_code)]
+    #[deprecated(note = "This function is marked as unused.")]
     pub skip_signature: Option<bool>,
 }
 
@@ -94,7 +97,7 @@ impl IdentityPublicKeyWithWitnessWasm {
         self.0.set_security_level(
             security_level
                 .try_into()
-                .map_err(|e: anyhow::Error| e.to_string())?,
+                .map_err(|e: ProtocolError| e.to_string())?,
         );
         Ok(())
     }

package/src/identity/state_transition/identity_update_transition/identity_update_transition.rs

@@ -144,23 +144,6 @@ impl IdentityUpdateTransitionWasm {
         self.0.set_public_key_ids_to_disable(keys);
     }
 
-    #[wasm_bindgen(js_name=getPublicKeysDisabledAt)]
-    pub fn get_public_keys_disabled_at(&self) -> Option<js_sys::Date> {
-        self.0
-            .public_keys_disabled_at()
-            .map(|timestamp| js_sys::Date::new(&JsValue::from_f64(timestamp as f64)))
-    }
-
-    #[wasm_bindgen(js_name=setPublicKeysDisabledAt)]
-    pub fn set_public_keys_disabled_at(&mut self, timestamp: Option<js_sys::Date>) {
-        if let Some(timestamp) = timestamp {
-            self.0
-                .set_public_keys_disabled_at(Some(timestamp.get_time() as TimestampMillis));
-        } else {
-            self.0.set_public_keys_disabled_at(None);
-        }
-    }
-
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u8 {
         self.0.state_transition_type() as u8
@@ -231,14 +214,6 @@ impl IdentityUpdateTransitionWasm {
             )?;
         }
 
-        if let Some(timestamp) = object.public_keys_disabled_at {
-            js_sys::Reflect::set(
-                &js_object,
-                &"publicKeysDisabledAt".to_owned().into(),
-                &js_sys::Date::new(&JsValue::from_f64(timestamp as f64)).into(),
-            )?;
-        }
-
         if let Some(public_keys_to_add) = object.public_keys_to_add {
             let keys_objects = public_keys_to_add
                 .into_iter()
@@ -325,14 +300,6 @@ impl IdentityUpdateTransitionWasm {
             )?;
         }
 
-        if let Some(timestamp) = object.public_keys_disabled_at {
-            js_sys::Reflect::set(
-                &js_object,
-                &"publicKeysDisabledAt".to_owned().into(),
-                &JsValue::from_f64(timestamp as f64),
-            )?;
-        }
-
         if let Some(public_keys_to_add) = object.public_keys_to_add {
             let keys_objects = public_keys_to_add
                 .into_iter()

package/src/identity/state_transition/identity_update_transition/to_object.rs

@@ -19,7 +19,6 @@ pub struct ToObject {
     pub revision: u32,
     pub signature: Option<Vec<u8>>,
     pub signature_public_key_id: KeyID,
-    pub public_keys_disabled_at: Option<u64>,
     pub public_keys_to_add: Option<Vec<IdentityPublicKeyInCreation>>,
     pub public_key_ids_to_disable: Option<Vec<KeyID>>,
     pub identity_id: Identifier,
@@ -46,8 +45,6 @@ pub fn to_object_struct(
         to_object.signature = signature;
     }
 
-    to_object.public_keys_disabled_at = transition.public_keys_disabled_at();
-
     let public_keys_to_add = transition.public_keys_to_add();
     if !public_keys_to_add.is_empty() {
         to_object.public_keys_to_add = Some(public_keys_to_add.to_owned());

package/src/lib.rs

@@ -19,7 +19,7 @@ mod identifier;
 mod identity;
 mod metadata;
 // mod state_repository;
-mod state_transition;
+pub mod state_transition;
 // mod version;
 
 mod utils;

package/test/integration/identity/IdentityFacade.spec.js

@@ -192,7 +192,6 @@ describe('IdentityFacade', () => {
         stateTransition.getPublicKeysToAdd().map((pk) => pk.toObject()),
       ).to.deep.equal(publicKeys.add.map((k) => k.toObject()));
       expect(stateTransition.getPublicKeyIdsToDisable()).to.deep.equal([]);
-      expect(stateTransition.getPublicKeysDisabledAt()).to.equal(undefined);
     });
   });
 

package/test/integration/identity/stateTransition/IdentityUpdateTransition/validation/state/validateIdentityUpdateTransitionStateFactory.spec.js

@@ -24,7 +24,6 @@ describe.skip('validateIdentityUpdateTransitionStateFactory', () => {
   let IdentityPublicKeyIsDisabledError;
   let InvalidIdentityPublicKeyIdError;
   let MissingMasterPublicKeyError;
-  let IdentityPublicKeyDisabledAtWindowViolationError;
   let MaxIdentityPublicKeyLimitReachedError;
   let StateTransitionExecutionContext;
   let IdentityUpdateTransitionStateValidator;
@@ -37,7 +36,6 @@ describe.skip('validateIdentityUpdateTransitionStateFactory', () => {
       IdentityPublicKeyIsReadOnlyError,
       IdentityPublicKeyIsDisabledError,
       InvalidIdentityPublicKeyIdError,
-      IdentityPublicKeyDisabledAtWindowViolationError,
       MaxIdentityPublicKeyLimitReachedError,
       StateTransitionExecutionContext,
       IdentityUpdateTransitionStateValidator,
@@ -68,7 +66,6 @@ describe.skip('validateIdentityUpdateTransitionStateFactory', () => {
 
     stateTransition.setRevision(identity.getRevision() + 1);
     stateTransition.setPublicKeyIdsToDisable(undefined);
-    stateTransition.setPublicKeysDisabledAt(undefined);
 
     const privateKey = '9b67f852093bc61cea0eeca38599dbfba0de28574d2ed9b99d10d33dc1bde7b2';
 
@@ -116,35 +113,8 @@ describe.skip('validateIdentityUpdateTransitionStateFactory', () => {
     expect(error.getPublicKeyIndex()).to.equal(0);
   });
 
-  it('should return invalid result if disabledAt has violated time window', async () => {
-    stateTransition.setPublicKeyIdsToDisable([1]);
-    // blockTime - 10 minutes
-    const disabledAt = new Date(blockTime - 1000 * 60 * 60 * 10);
-    stateTransition.setPublicKeysDisabledAt(disabledAt);
-
-    const timeWindowStart = new Date(blockTime);
-    timeWindowStart.setMinutes(
-      timeWindowStart.getMinutes() - 5,
-    );
-
-    const timeWindowEnd = new Date(blockTime);
-    timeWindowEnd.setMinutes(
-      timeWindowEnd.getMinutes() + 5,
-    );
-
-    const result = await validateIdentityUpdateTransitionState(stateTransition);
-
-    await expectValidationError(result, IdentityPublicKeyDisabledAtWindowViolationError);
-
-    const [error] = result.getErrors();
-    expect(error.getDisabledAt()).to.deep.equal(disabledAt);
-    expect(error.getTimeWindowStart()).to.be.instanceOf(Date);
-    expect(error.getTimeWindowEnd()).to.be.instanceOf(Date);
-  });
-
   it('should throw InvalidIdentityPublicKeyIdError if identity does not contain public key with disabling ID', async () => {
     stateTransition.setPublicKeyIdsToDisable([3]);
-    stateTransition.setPublicKeysDisabledAt(new Date());
 
     const result = await validateIdentityUpdateTransitionState(stateTransition);
 
@@ -156,7 +126,6 @@ describe.skip('validateIdentityUpdateTransitionStateFactory', () => {
 
   it('should pass when disabling public key', async function () {
     stateTransition.setPublicKeyIdsToDisable([1]);
-    stateTransition.setPublicKeysDisabledAt(new Date());
     stateTransition.setPublicKeysToAdd(undefined);
 
     const result = await validateIdentityUpdateTransitionState(stateTransition);
@@ -176,7 +145,6 @@ describe.skip('validateIdentityUpdateTransitionStateFactory', () => {
 
   it('should pass when adding public key', async function () {
     stateTransition.setPublicKeyIdsToDisable(undefined);
-    stateTransition.setPublicKeysDisabledAt(undefined);
 
     const result = await validateIdentityUpdateTransitionState(stateTransition);
 
@@ -195,7 +163,6 @@ describe.skip('validateIdentityUpdateTransitionStateFactory', () => {
 
   it('should pass when both adding and disabling public keys', async function () {
     stateTransition.setPublicKeyIdsToDisable([1]);
-    stateTransition.setPublicKeysDisabledAt(new Date());
 
     const result = await validateIdentityUpdateTransitionState(stateTransition);
 
@@ -262,7 +229,6 @@ describe.skip('validateIdentityUpdateTransitionStateFactory', () => {
 
   it('should return valid result on dry run', async function () {
     stateTransition.setPublicKeyIdsToDisable([3]);
-    stateTransition.setPublicKeysDisabledAt(new Date());
 
     // Make code that executes after dry run check to fail
     stateRepositoryMock.fetchLatestPlatformBlockTime.resolves({});

package/test/unit/identity/Identity.spec.js

@@ -80,7 +80,7 @@ describe('Identity', () => {
         type: KeyType.ECDSA_SECP256K1,
         data: Buffer.alloc(36).fill('a'),
         purpose: KeyPurpose.AUTHENTICATION,
-        securityLevel: KeySecurityLevel.MASTER,
+        securityLevel: KeySecurityLevel.HIGH,
         readOnly: false,
         disabledAt: null,
         contractBounds: null,
@@ -159,7 +159,7 @@ describe('Identity', () => {
             type: KeyType.ECDSA_SECP256K1,
             data: rawIdentity.publicKeys[0].data.toString('base64'),
             purpose: KeyPurpose.AUTHENTICATION,
-            securityLevel: KeySecurityLevel.MASTER,
+            securityLevel: KeySecurityLevel.HIGH,
             readOnly: false,
             disabledAt: null,
             contractBounds: null,

package/test/unit/identity/IdentityFactory.spec.js

@@ -250,7 +250,6 @@ describe('IdentityFactory', () => {
       expect(stateTransition.getPublicKeysToAdd().map((k) => k.toObject()))
         .to.deep.equal(addPublicKeys.map((k) => k.toObject()));
       expect(stateTransition.getPublicKeyIdsToDisable()).to.deep.equal([0]);
-      expect(stateTransition.getPublicKeysDisabledAt()).to.deep.equal(new Date());
     });
   });
 

package/test/unit/identity/IdentityPublicKey.spec.js

@@ -12,7 +12,7 @@ describe('IdentityPublicKey', () => {
       type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
       data: keyData,
       purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-      securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+      securityLevel: IdentityPublicKey.SECURITY_LEVELS.HIGH,
       readOnly: false,
       contractBounds: null,
     };
@@ -194,7 +194,7 @@ describe('IdentityPublicKey', () => {
         type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
         data: 'AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH',
         purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.HIGH,
         readOnly: false,
         disabledAt: now.getTime(),
         contractBounds: null,
@@ -215,7 +215,7 @@ describe('IdentityPublicKey', () => {
         type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
         data: Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'),
         purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.HIGH,
         readOnly: false,
         disabledAt: now.getTime(),
         contractBounds: null,

package/test/unit/identity/stateTransition/IdentityUpdateTransition/IdentityUpdateTransition.spec.js

@@ -99,23 +99,6 @@ describe('IdentityUpdateTransition', () => {
     });
   });
 
-  describe('#getPublicKeysDisabledAt', () => {
-    it('should return time to disable public keys', () => {
-      expect(stateTransition.getPublicKeysDisabledAt())
-        .to.deep.equal(rawStateTransition.publicKeysDisabledAt);
-    });
-  });
-
-  describe('#setPublicKeysDisabledAt', () => {
-    it('should set time to disable public keys', () => {
-      const now = new Date();
-
-      stateTransition.setPublicKeysDisabledAt(now);
-
-      expect(stateTransition.getPublicKeysDisabledAt()).to.deep.equal(new Date(now));
-    });
-  });
-
   describe('#toObject', () => {
     it('should return raw state transition', () => {
       rawStateTransition = stateTransition.toObject();
@@ -126,7 +109,6 @@ describe('IdentityUpdateTransition', () => {
         signature: undefined,
         identityId: rawStateTransition.identityId,
         revision: rawStateTransition.revision,
-        publicKeysDisabledAt: rawStateTransition.publicKeysDisabledAt,
         addPublicKeys: rawStateTransition.addPublicKeys,
         disablePublicKeys: rawStateTransition.disablePublicKeys,
         signaturePublicKeyId: 0,
@@ -141,7 +123,6 @@ describe('IdentityUpdateTransition', () => {
         type: StateTransitionTypes.IdentityUpdate,
         identityId: rawStateTransition.identityId,
         revision: rawStateTransition.revision,
-        publicKeysDisabledAt: rawStateTransition.publicKeysDisabledAt,
         addPublicKeys: rawStateTransition.addPublicKeys,
         disablePublicKeys: rawStateTransition.disablePublicKeys,
       });
@@ -149,7 +130,6 @@ describe('IdentityUpdateTransition', () => {
 
     it('should return raw state transition without optional properties', () => {
       stateTransition.setPublicKeyIdsToDisable(undefined);
-      stateTransition.setPublicKeysDisabledAt(undefined);
       stateTransition.setPublicKeysToAdd(undefined);
 
       rawStateTransition = stateTransition.toObject();
@@ -175,7 +155,6 @@ describe('IdentityUpdateTransition', () => {
         signature: undefined,
         identityId: stateTransition.getIdentityId().toString(),
         revision: rawStateTransition.revision,
-        publicKeysDisabledAt: rawStateTransition.publicKeysDisabledAt.getTime(),
         addPublicKeys: stateTransition.getPublicKeysToAdd().map((k) => k.toJSON()),
         disablePublicKeys: rawStateTransition.disablePublicKeys,
         signaturePublicKeyId: 0,