@dashevo/wasm-dpp 1.8.0 → 2.0.0-dev.1

package/src/errors/consensus/consensus_error.rs

@@ -61,10 +61,13 @@ use dpp::consensus::state::data_trigger::DataTriggerError::{
   DataTriggerConditionError, DataTriggerExecutionError, DataTriggerInvalidResultError,
 };
 use wasm_bindgen::{JsError, JsValue};
-use dpp::consensus::basic::data_contract::{ContestedUniqueIndexOnMutableDocumentTypeError, ContestedUniqueIndexWithUniqueIndexError, InvalidDocumentTypeRequiredSecurityLevelError, UnknownDocumentCreationRestrictionModeError, UnknownSecurityLevelError, UnknownStorageKeyRequirementsError, UnknownTradeModeError, UnknownTransferableTypeError};
+use dpp::consensus::basic::data_contract::{ContestedUniqueIndexOnMutableDocumentTypeError, ContestedUniqueIndexWithUniqueIndexError, DataContractTokenConfigurationUpdateError, GroupExceedsMaxMembersError, GroupMemberHasPowerOfZeroError, GroupMemberHasPowerOverLimitError, GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError, GroupPositionDoesNotExistError, GroupTotalPowerLessThanRequiredError, InvalidDocumentTypeRequiredSecurityLevelError, InvalidTokenBaseSupplyError, InvalidTokenDistributionFunctionDivideByZeroError, InvalidTokenDistributionFunctionIncoherenceError, InvalidTokenDistributionFunctionInvalidParameterError, InvalidTokenDistributionFunctionInvalidParameterTupleError, NonContiguousContractGroupPositionsError, NonContiguousContractTokenPositionsError, UnknownDocumentCreationRestrictionModeError, UnknownSecurityLevelError, UnknownStorageKeyRequirementsError, UnknownTradeModeError, UnknownTransferableTypeError};
 use dpp::consensus::basic::document::{ContestedDocumentsTemporarilyNotAllowedError, DocumentCreationNotAllowedError, DocumentFieldMaxSizeExceededError, MaxDocumentsTransitionsExceededError, MissingPositionsInDocumentTypePropertiesError};
+use dpp::consensus::basic::group::GroupActionNotAllowedOnTransitionError;
 use dpp::consensus::basic::identity::{DataContractBoundsNotPresentError, DisablingKeyIdAlsoBeingAddedInSameTransitionError, InvalidIdentityCreditWithdrawalTransitionAmountError, InvalidIdentityUpdateTransitionDisableKeysError, InvalidIdentityUpdateTransitionEmptyError, TooManyMasterPublicKeyError, WithdrawalOutputScriptNotAllowedWhenSigningWithOwnerKeyError};
 use dpp::consensus::basic::overflow_error::OverflowError;
+use dpp::consensus::basic::token::{ChoosingTokenMintRecipientNotAllowedError, ContractHasNoTokensError, DestinationIdentityForTokenMintingNotSetError, InvalidActionIdError, InvalidTokenAmountError, InvalidTokenConfigUpdateNoChangeError, InvalidTokenIdError, InvalidTokenNoteTooBigError, InvalidTokenPositionError, MissingDefaultLocalizationError, TokenTransferToOurselfError};
+use dpp::consensus::state::data_contract::data_contract_update_action_not_allowed_error::DataContractUpdateActionNotAllowedError;
 use dpp::consensus::state::data_contract::document_type_update_error::DocumentTypeUpdateError;
 use dpp::consensus::state::document::document_contest_currently_locked_error::DocumentContestCurrentlyLockedError;
 use dpp::consensus::state::document::document_contest_document_with_same_id_already_present_error::DocumentContestDocumentWithSameIdAlreadyPresentError;
@@ -73,12 +76,15 @@ use dpp::consensus::state::document::document_contest_not_joinable_error::Docume
 use dpp::consensus::state::document::document_contest_not_paid_for_error::DocumentContestNotPaidForError;
 use dpp::consensus::state::document::document_incorrect_purchase_price_error::DocumentIncorrectPurchasePriceError;
 use dpp::consensus::state::document::document_not_for_sale_error::DocumentNotForSaleError;
+use dpp::consensus::state::group::{GroupActionAlreadyCompletedError, GroupActionAlreadySignedByIdentityError, GroupActionDoesNotExistError, IdentityNotMemberOfGroupError};
 use dpp::consensus::state::identity::identity_public_key_already_exists_for_unique_contract_bounds_error::IdentityPublicKeyAlreadyExistsForUniqueContractBoundsError;
 use dpp::consensus::state::identity::master_public_key_update_error::MasterPublicKeyUpdateError;
 use dpp::consensus::state::identity::missing_transfer_key_error::MissingTransferKeyError;
 use dpp::consensus::state::identity::no_transfer_key_for_core_withdrawal_available_error::NoTransferKeyForCoreWithdrawalAvailableError;
+use dpp::consensus::state::identity::RecipientIdentityDoesNotExistError;
 use dpp::consensus::state::prefunded_specialized_balances::prefunded_specialized_balance_insufficient_error::PrefundedSpecializedBalanceInsufficientError;
 use dpp::consensus::state::prefunded_specialized_balances::prefunded_specialized_balance_not_found_error::PrefundedSpecializedBalanceNotFoundError;
+use dpp::consensus::state::token::{IdentityDoesNotHaveEnoughTokenBalanceError, IdentityTokenAccountNotFrozenError, IdentityTokenAccountFrozenError, TokenIsPausedError, IdentityTokenAccountAlreadyFrozenError, UnauthorizedTokenActionError, TokenSettingMaxSupplyToLessThanCurrentSupplyError, TokenMintPastMaxSupplyError, NewTokensDestinationIdentityDoesNotExistError, NewAuthorizedActionTakerIdentityDoesNotExistError, NewAuthorizedActionTakerGroupDoesNotExistError, NewAuthorizedActionTakerMainGroupNotSetError, InvalidGroupPositionError, TokenAlreadyPausedError, TokenNotPausedError, InvalidTokenClaimPropertyMismatch, InvalidTokenClaimNoCurrentRewards, InvalidTokenClaimWrongClaimant};
 use dpp::consensus::state::voting::masternode_incorrect_voter_identity_id_error::MasternodeIncorrectVoterIdentityIdError;
 use dpp::consensus::state::voting::masternode_incorrect_voting_address_error::MasternodeIncorrectVotingAddressError;
 use dpp::consensus::state::voting::masternode_not_found_error::MasternodeNotFoundError;
@@ -308,6 +314,76 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
         StateError::DocumentContestNotPaidForError(e) => {
             generic_consensus_error!(DocumentContestNotPaidForError, e).into()
         }
+        StateError::RecipientIdentityDoesNotExistError(e) => {
+            generic_consensus_error!(RecipientIdentityDoesNotExistError, e).into()
+        }
+        StateError::IdentityDoesNotHaveEnoughTokenBalanceError(e) => {
+            generic_consensus_error!(IdentityDoesNotHaveEnoughTokenBalanceError, e).into()
+        }
+        StateError::UnauthorizedTokenActionError(e) => {
+            generic_consensus_error!(UnauthorizedTokenActionError, e).into()
+        }
+        StateError::IdentityTokenAccountFrozenError(e) => {
+            generic_consensus_error!(IdentityTokenAccountFrozenError, e).into()
+        }
+        StateError::TokenIsPausedError(e) => generic_consensus_error!(TokenIsPausedError, e).into(),
+        StateError::IdentityTokenAccountAlreadyFrozenError(e) => {
+            generic_consensus_error!(IdentityTokenAccountAlreadyFrozenError, e).into()
+        }
+        StateError::TokenAlreadyPausedError(e) => {
+            generic_consensus_error!(TokenAlreadyPausedError, e).into()
+        }
+        StateError::TokenNotPausedError(e) => {
+            generic_consensus_error!(TokenNotPausedError, e).into()
+        }
+        StateError::IdentityNotMemberOfGroupError(e) => {
+            generic_consensus_error!(IdentityNotMemberOfGroupError, e).into()
+        }
+        StateError::GroupActionDoesNotExistError(e) => {
+            generic_consensus_error!(GroupActionDoesNotExistError, e).into()
+        }
+        StateError::GroupActionAlreadyCompletedError(e) => {
+            generic_consensus_error!(GroupActionAlreadyCompletedError, e).into()
+        }
+        StateError::GroupActionAlreadySignedByIdentityError(e) => {
+            generic_consensus_error!(GroupActionAlreadySignedByIdentityError, e).into()
+        }
+        StateError::IdentityTokenAccountNotFrozenError(e) => {
+            generic_consensus_error!(IdentityTokenAccountNotFrozenError, e).into()
+        }
+        StateError::DataContractUpdateActionNotAllowedError(e) => {
+            generic_consensus_error!(DataContractUpdateActionNotAllowedError, e).into()
+        }
+        StateError::TokenSettingMaxSupplyToLessThanCurrentSupplyError(e) => {
+            generic_consensus_error!(TokenSettingMaxSupplyToLessThanCurrentSupplyError, e).into()
+        }
+        StateError::TokenMintPastMaxSupplyError(e) => {
+            generic_consensus_error!(TokenMintPastMaxSupplyError, e).into()
+        }
+        StateError::NewTokensDestinationIdentityDoesNotExistError(e) => {
+            generic_consensus_error!(NewTokensDestinationIdentityDoesNotExistError, e).into()
+        }
+        StateError::NewAuthorizedActionTakerIdentityDoesNotExistError(e) => {
+            generic_consensus_error!(NewAuthorizedActionTakerIdentityDoesNotExistError, e).into()
+        }
+        StateError::NewAuthorizedActionTakerGroupDoesNotExistError(e) => {
+            generic_consensus_error!(NewAuthorizedActionTakerGroupDoesNotExistError, e).into()
+        }
+        StateError::NewAuthorizedActionTakerMainGroupNotSetError(e) => {
+            generic_consensus_error!(NewAuthorizedActionTakerMainGroupNotSetError, e).into()
+        }
+        StateError::InvalidGroupPositionError(e) => {
+            generic_consensus_error!(InvalidGroupPositionError, e).into()
+        }
+        StateError::InvalidTokenClaimPropertyMismatch(e) => {
+            generic_consensus_error!(InvalidTokenClaimPropertyMismatch, e).into()
+        }
+        StateError::InvalidTokenClaimNoCurrentRewards(e) => {
+            generic_consensus_error!(InvalidTokenClaimNoCurrentRewards, e).into()
+        }
+        StateError::InvalidTokenClaimWrongClaimant(e) => {
+            generic_consensus_error!(InvalidTokenClaimWrongClaimant, e).into()
+        }
     }
 }
 
@@ -571,6 +647,96 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
             )
             .into()
         }
+        BasicError::DataContractTokenConfigurationUpdateError(e) => {
+            generic_consensus_error!(DataContractTokenConfigurationUpdateError, e).into()
+        }
+        BasicError::InvalidTokenIdError(e) => {
+            generic_consensus_error!(InvalidTokenIdError, e).into()
+        }
+
+        BasicError::InvalidTokenPositionError(e) => {
+            generic_consensus_error!(InvalidTokenPositionError, e).into()
+        }
+
+        BasicError::ContractHasNoTokensError(e) => {
+            generic_consensus_error!(ContractHasNoTokensError, e).into()
+        }
+
+        BasicError::InvalidActionIdError(e) => {
+            generic_consensus_error!(InvalidActionIdError, e).into()
+        }
+        BasicError::NonContiguousContractTokenPositionsError(e) => {
+            generic_consensus_error!(NonContiguousContractTokenPositionsError, e).into()
+        }
+        BasicError::NonContiguousContractGroupPositionsError(e) => {
+            generic_consensus_error!(NonContiguousContractGroupPositionsError, e).into()
+        }
+        BasicError::InvalidTokenBaseSupplyError(e) => {
+            generic_consensus_error!(InvalidTokenBaseSupplyError, e).into()
+        }
+        BasicError::TokenTransferToOurselfError(e) => {
+            generic_consensus_error!(TokenTransferToOurselfError, e).into()
+        }
+        BasicError::DestinationIdentityForTokenMintingNotSetError(e) => {
+            generic_consensus_error!(DestinationIdentityForTokenMintingNotSetError, e).into()
+        }
+        BasicError::ChoosingTokenMintRecipientNotAllowedError(e) => {
+            generic_consensus_error!(ChoosingTokenMintRecipientNotAllowedError, e).into()
+        }
+        BasicError::GroupActionNotAllowedOnTransitionError(e) => {
+            generic_consensus_error!(GroupActionNotAllowedOnTransitionError, e).into()
+        }
+        BasicError::GroupPositionDoesNotExistError(e) => {
+            generic_consensus_error!(GroupPositionDoesNotExistError, e).into()
+        }
+        BasicError::GroupExceedsMaxMembersError(e) => {
+            generic_consensus_error!(GroupExceedsMaxMembersError, e).into()
+        }
+        BasicError::GroupMemberHasPowerOfZeroError(e) => {
+            generic_consensus_error!(GroupMemberHasPowerOfZeroError, e).into()
+        }
+        BasicError::GroupMemberHasPowerOverLimitError(e) => {
+            generic_consensus_error!(GroupMemberHasPowerOverLimitError, e).into()
+        }
+        BasicError::GroupTotalPowerLessThanRequiredError(e) => {
+            generic_consensus_error!(GroupTotalPowerLessThanRequiredError, e).into()
+        }
+        BasicError::GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError(e) => {
+            generic_consensus_error!(
+                GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError,
+                e
+            )
+            .into()
+        }
+        BasicError::InvalidTokenAmountError(e) => {
+            generic_consensus_error!(InvalidTokenAmountError, e).into()
+        }
+        BasicError::InvalidTokenConfigUpdateNoChangeError(e) => {
+            generic_consensus_error!(InvalidTokenConfigUpdateNoChangeError, e).into()
+        }
+        BasicError::InvalidTokenDistributionFunctionDivideByZeroError(e) => {
+            generic_consensus_error!(InvalidTokenDistributionFunctionDivideByZeroError, e).into()
+        }
+        BasicError::InvalidTokenDistributionFunctionInvalidParameterError(e) => {
+            generic_consensus_error!(InvalidTokenDistributionFunctionInvalidParameterError, e)
+                .into()
+        }
+        BasicError::InvalidTokenDistributionFunctionInvalidParameterTupleError(e) => {
+            generic_consensus_error!(
+                InvalidTokenDistributionFunctionInvalidParameterTupleError,
+                e
+            )
+            .into()
+        }
+        BasicError::InvalidTokenDistributionFunctionIncoherenceError(e) => {
+            generic_consensus_error!(InvalidTokenDistributionFunctionIncoherenceError, e).into()
+        }
+        BasicError::InvalidTokenNoteTooBigError(e) => {
+            generic_consensus_error!(InvalidTokenNoteTooBigError, e).into()
+        }
+        BasicError::MissingDefaultLocalizationError(e) => {
+            generic_consensus_error!(MissingDefaultLocalizationError, e).into()
+        }
     }
 }
 

package/src/errors/consensus/fee/balance_is_not_enough_error.rs

@@ -29,13 +29,13 @@ impl BalanceIsNotEnoughErrorWasm {
     }
 
     #[wasm_bindgen(js_name=getBalance)]
-    pub fn get_balance(&self) -> f64 {
-        self.inner.balance() as f64
+    pub fn get_balance(&self) -> u64 {
+        self.inner.balance()
     }
 
     #[wasm_bindgen(js_name=getFee)]
-    pub fn get_fee(&self) -> f64 {
-        self.inner.fee() as f64
+    pub fn get_fee(&self) -> u64 {
+        self.inner.fee() as u64
     }
 
     #[wasm_bindgen(js_name=getCode)]

package/src/identity/identity.rs

@@ -105,38 +105,38 @@ impl IdentityWasm {
     }
 
     #[wasm_bindgen(getter)]
-    pub fn balance(&self) -> f64 {
-        self.inner.balance() as f64
+    pub fn balance(&self) -> u64 {
+        self.inner.balance()
     }
 
     #[wasm_bindgen(js_name=getBalance)]
-    pub fn get_balance(&self) -> f64 {
-        self.inner.balance() as f64
+    pub fn get_balance(&self) -> u64 {
+        self.inner.balance()
     }
 
     #[wasm_bindgen(js_name=setBalance)]
-    pub fn set_balance(&mut self, balance: f64) {
-        self.inner.set_balance(balance as u64);
+    pub fn set_balance(&mut self, balance: u64) {
+        self.inner.set_balance(balance);
     }
 
     #[wasm_bindgen(js_name=increaseBalance)]
-    pub fn increase_balance(&mut self, amount: f64) -> f64 {
-        self.inner.increase_balance(amount as u64) as f64
+    pub fn increase_balance(&mut self, amount: u64) -> u64 {
+        self.inner.increase_balance(amount)
     }
 
     #[wasm_bindgen(js_name=reduceBalance)]
-    pub fn reduce_balance(&mut self, amount: f64) -> f64 {
-        self.inner.reduce_balance(amount as u64) as f64
+    pub fn reduce_balance(&mut self, amount: u64) -> u64 {
+        self.inner.reduce_balance(amount)
     }
 
     #[wasm_bindgen(js_name=setRevision)]
-    pub fn set_revision(&mut self, revision: f64) {
-        self.inner.set_revision(revision as u64);
+    pub fn set_revision(&mut self, revision: u64) {
+        self.inner.set_revision(revision);
     }
 
     #[wasm_bindgen(js_name=getRevision)]
-    pub fn get_revision(&self) -> f64 {
-        self.inner.revision() as f64
+    pub fn get_revision(&self) -> u64 {
+        self.inner.revision() as u64
     }
 
     #[wasm_bindgen(js_name=setMetadata)]

package/src/identity/state_transition/identity_create_transition/identity_create_transition.rs

@@ -167,6 +167,16 @@ impl IdentityCreateTransitionWasm {
         (IdentityCreateTransitionAccessorsV0::owner_id(&self.0)).into()
     }
 
+    #[wasm_bindgen(js_name=getUserFeeIncrease)]
+    pub fn get_user_fee_increase(&self) -> u16 {
+        self.0.user_fee_increase() as u16
+    }
+
+    #[wasm_bindgen(js_name=setUserFeeIncrease)]
+    pub fn set_user_fee_increase(&mut self, user_fee_increase: u16) {
+        self.0.set_user_fee_increase(user_fee_increase);
+    }
+
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self, options: JsValue) -> Result<JsValue, JsValue> {
         let opts: super::to_object::ToObjectOptions = if options.is_object() {

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

@@ -90,13 +90,33 @@ impl IdentityCreditTransferTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=getAmount)]
-    pub fn get_amount(&self) -> f64 {
-        self.0.amount() as f64
+    pub fn get_amount(&self) -> u64 {
+        self.0.amount()
     }
 
     #[wasm_bindgen(js_name=setAmount)]
-    pub fn set_amount(&mut self, amount: f64) {
-        self.0.set_amount(amount as u64);
+    pub fn set_amount(&mut self, amount: u64) {
+        self.0.set_amount(amount);
+    }
+
+    #[wasm_bindgen(js_name=getUserFeeIncrease)]
+    pub fn get_user_fee_increase(&self) -> u16 {
+        self.0.user_fee_increase()
+    }
+
+    #[wasm_bindgen(js_name=setUserFeeIncrease)]
+    pub fn set_user_fee_increase(&mut self, user_fee_increase: u16) {
+        self.0.set_user_fee_increase(user_fee_increase);
+    }
+
+    #[wasm_bindgen(js_name=getNonce)]
+    pub fn get_nonce(&self) -> u64 {
+        self.0.nonce()
+    }
+
+    #[wasm_bindgen(js_name=setNonce)]
+    pub fn set_nonce(&mut self, nonce: u64) {
+        self.0.set_nonce(nonce)
     }
 
     #[wasm_bindgen(js_name=toObject)]
@@ -161,7 +181,7 @@ impl IdentityCreditTransferTransitionWasm {
         js_sys::Reflect::set(
             &js_object,
             &"amount".to_owned().into(),
-            &JsValue::from_f64(object.amount as f64),
+            &JsValue::bigint_from_str(&object.amount.to_string()),
         )?;
 
         Ok(js_object.into())
@@ -236,7 +256,7 @@ impl IdentityCreditTransferTransitionWasm {
         js_sys::Reflect::set(
             &js_object,
             &"amount".to_owned().into(),
-            &JsValue::from_f64(object.amount as f64),
+            &JsValue::bigint_from_str(&object.amount.to_string()),
         )?;
 
         Ok(js_object.into())
@@ -318,6 +338,11 @@ impl IdentityCreditTransferTransitionWasm {
             .set_signature(BinaryData::new(signature.unwrap_or_default()))
     }
 
+    #[wasm_bindgen(js_name=getSignaturePublicKeyId)]
+    pub fn get_signature_public_key_id(&self) -> u32 {
+        self.0.signature_public_key_id()
+    }
+
     #[wasm_bindgen]
     pub fn sign(
         &mut self,

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

@@ -136,6 +136,16 @@ impl IdentityCreditWithdrawalTransitionWasm {
         self.0.set_nonce(revision);
     }
 
+    #[wasm_bindgen(js_name=getUserFeeIncrease)]
+    pub fn get_user_fee_increase(&self) -> u16 {
+        self.0.user_fee_increase() as u16
+    }
+
+    #[wasm_bindgen(js_name=setUserFeeIncrease)]
+    pub fn set_user_fee_increase(&mut self, user_fee_increase: u16) {
+        self.0.set_user_fee_increase(user_fee_increase);
+    }
+
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self, options: JsValue) -> Result<JsValue, JsValue> {
         let opts: super::to_object::ToObjectOptions = if options.is_object() {
@@ -400,6 +410,11 @@ impl IdentityCreditWithdrawalTransitionWasm {
             .set_signature(BinaryData::new(signature.unwrap_or_default()))
     }
 
+    #[wasm_bindgen(js_name=getSignaturePublicKeyId)]
+    pub fn get_signature_public_key_id(&self) -> u32 {
+        self.0.signature_public_key_id()
+    }
+
     #[wasm_bindgen]
     pub fn sign(
         &mut self,

package/src/identity/state_transition/identity_topup_transition/identity_topup_transition.rs

@@ -115,6 +115,16 @@ impl IdentityTopUpTransitionWasm {
         self.0.owner_id().to_owned().into()
     }
 
+    #[wasm_bindgen(js_name=getUserFeeIncrease)]
+    pub fn get_user_fee_increase(&self) -> u16 {
+        self.0.user_fee_increase() as u16
+    }
+
+    #[wasm_bindgen(js_name=setUserFeeIncrease)]
+    pub fn set_user_fee_increase(&mut self, user_fee_increase: u16) {
+        self.0.set_user_fee_increase(user_fee_increase);
+    }
+
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self, options: JsValue) -> Result<JsValue, JsValue> {
         let opts: super::to_object::ToObjectOptions = if options.is_object() {

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

@@ -160,6 +160,26 @@ impl IdentityUpdateTransitionWasm {
         StateTransitionLike::owner_id(&self.0).to_owned().into()
     }
 
+    #[wasm_bindgen(js_name=getUserFeeIncrease)]
+    pub fn get_user_fee_increase(&self) -> u16 {
+        self.0.user_fee_increase()
+    }
+
+    #[wasm_bindgen(js_name=setUserFeeIncrease)]
+    pub fn set_user_fee_increase(&mut self, user_fee_increase: u16) {
+        self.0.set_user_fee_increase(user_fee_increase);
+    }
+
+    #[wasm_bindgen(js_name=getIdentityContractNonce)]
+    pub fn get_identity_nonce(&self) -> u64 {
+        self.0.nonce()
+    }
+
+    #[wasm_bindgen(js_name=setIdentityContractNonce)]
+    pub fn set_identity_contract_nonce(&mut self, identity_nonce: u64) {
+        self.0.set_nonce(identity_nonce)
+    }
+
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self, options: JsValue) -> Result<JsValue, JsValue> {
         let opts: super::to_object::ToObjectOptions = if options.is_object() {
@@ -403,6 +423,11 @@ impl IdentityUpdateTransitionWasm {
         Buffer::from_bytes_owned(self.0.signature().to_vec())
     }
 
+    #[wasm_bindgen(js_name=getSignaturePublicKeyId)]
+    pub fn get_signature_public_key_id(&self) -> u32 {
+        self.0.signature_public_key_id()
+    }
+
     #[wasm_bindgen(js_name=setSignature)]
     pub fn set_signature(&mut self, signature: Option<Vec<u8>>) {
         self.0
@@ -410,13 +435,13 @@ impl IdentityUpdateTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=getRevision)]
-    pub fn get_revision(&self) -> u32 {
-        self.0.revision() as u32
+    pub fn get_revision(&self) -> u64 {
+        self.0.revision()
     }
 
     #[wasm_bindgen(js_name=setRevision)]
-    pub fn set_revision(&mut self, revision: u32) {
-        self.0.set_revision(revision as u64)
+    pub fn set_revision(&mut self, revision: u64) {
+        self.0.set_revision(revision)
     }
 
     #[wasm_bindgen]

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

@@ -16,7 +16,7 @@ pub struct ToObjectOptions {
 #[derive(Default)]
 pub struct ToObject {
     pub transition_type: u8,
-    pub revision: u32,
+    pub revision: u64,
     pub signature: Option<Vec<u8>>,
     pub signature_public_key_id: KeyID,
     pub public_keys_to_add: Option<Vec<IdentityPublicKeyInCreation>>,
@@ -30,7 +30,7 @@ pub fn to_object_struct(
 ) -> ToObject {
     let mut to_object = ToObject {
         transition_type: transition.state_transition_type() as u8,
-        revision: transition.revision() as u32,
+        revision: transition.revision(),
         identity_id: transition.identity_id().to_owned(),
         ..ToObject::default()
     };

package/src/identity/state_transition/transition_types.rs

@@ -19,7 +19,7 @@ impl From<StateTransitionType> for StateTransitionTypeWasm {
     fn from(state_transition_type: StateTransitionType) -> Self {
         match state_transition_type {
             StateTransitionType::DataContractCreate => StateTransitionTypeWasm::DataContractCreate,
-            StateTransitionType::DocumentsBatch => StateTransitionTypeWasm::DocumentsBatch,
+            StateTransitionType::Batch => StateTransitionTypeWasm::DocumentsBatch,
             StateTransitionType::IdentityCreate => StateTransitionTypeWasm::IdentityCreate,
             StateTransitionType::IdentityTopUp => StateTransitionTypeWasm::IdentityTopUp,
             StateTransitionType::DataContractUpdate => StateTransitionTypeWasm::DataContractUpdate,

package/src/metadata.rs

@@ -3,10 +3,8 @@
 pub use serde::Serialize;
 use wasm_bindgen::prelude::*;
 
-use crate::utils::ToSerdeJSONExt;
 use dpp::metadata::Metadata;
 use dpp::util::deserializer::ProtocolVersion;
-use dpp::util::json_value::JsonValueExt;
 
 #[wasm_bindgen(js_name=Metadata)]
 #[derive(Clone, Debug)]
@@ -34,25 +32,16 @@ impl Into<Metadata> for MetadataWasm {
 #[wasm_bindgen(js_class=Metadata)]
 impl MetadataWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(options: JsValue) -> Result<MetadataWasm, JsValue> {
-        let metadata_options = options.with_serde_to_json_value()?;
-        let block_height = metadata_options
-            .get_f64("blockHeight")
-            .map_err(|e| JsError::new(&e.to_string()))?;
-        let core_chain_locked_height = metadata_options
-            .get_f64("coreChainLockedHeight")
-            .map_err(|e| JsError::new(&e.to_string()))?;
-        let time_ms = metadata_options
-            .get_f64("timeMs")
-            .map_err(|e| JsError::new(&e.to_string()))?;
-        let protocol_version = metadata_options
-            .get_f64("protocolVersion")
-            .map_err(|e| JsError::new(&e.to_string()))?;
-
+    pub fn new(
+        block_height: u64,
+        core_chain_locked_height: u32,
+        time_ms: u64,
+        protocol_version: u32,
+    ) -> Result<MetadataWasm, JsValue> {
         let inner = Metadata {
-            block_height: block_height as u64,
+            block_height,
             core_chain_locked_height: core_chain_locked_height as u64,
-            time_ms: time_ms as u64,
+            time_ms,
             protocol_version: protocol_version as u64 as ProtocolVersion,
         };
         Ok(inner.into())
@@ -77,22 +66,22 @@ impl MetadataWasm {
     }
 
     #[wasm_bindgen(js_name=getBlockHeight)]
-    pub fn block_height(&self) -> f64 {
-        self.0.block_height as f64
+    pub fn block_height(&self) -> u64 {
+        self.0.block_height
     }
 
     #[wasm_bindgen(js_name=getCoreChainLockedHeight)]
-    pub fn core_chain_locked_height(&self) -> f64 {
-        self.0.core_chain_locked_height as f64
+    pub fn core_chain_locked_height(&self) -> u32 {
+        self.0.core_chain_locked_height as u32
     }
 
     #[wasm_bindgen(js_name=getTimeMs)]
-    pub fn time_ms(&self) -> f64 {
-        self.0.time_ms as f64
+    pub fn time_ms(&self) -> u64 {
+        self.0.time_ms
     }
 
     #[wasm_bindgen(js_name=getProtocolVersion)]
-    pub fn protocol_version(&self) -> f64 {
-        self.0.protocol_version as f64
+    pub fn protocol_version(&self) -> u32 {
+        self.0.protocol_version
     }
 }

package/src/state_transition/state_transition_factory.rs

@@ -1,5 +1,5 @@
+use crate::batch_transition::BatchTransitionWasm;
 use crate::data_contract::{DataContractCreateTransitionWasm, DataContractUpdateTransitionWasm};
-use crate::document_batch_transition::DocumentsBatchTransitionWasm;
 use crate::errors::from_dpp_err;
 use crate::identity::state_transition::{
     IdentityCreateTransitionWasm, IdentityCreditTransferTransitionWasm,
@@ -56,9 +56,7 @@ impl StateTransitionFactoryWasm {
                 StateTransition::IdentityCreditWithdrawal(st) => {
                     Ok(IdentityCreditWithdrawalTransitionWasm::from(st).into())
                 }
-                StateTransition::DocumentsBatch(st) => {
-                    Ok(DocumentsBatchTransitionWasm::from(st).into())
-                }
+                StateTransition::Batch(st) => Ok(BatchTransitionWasm::from(st).into()),
                 StateTransition::MasternodeVote(st) => {
                     Ok(MasternodeVoteTransitionWasm::from(st).into())
                 }