@dashevo/wasm-dpp 2.0.0-rc.8 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "2.0.0-rc.8",
+  "version": "2.0.0",
   "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.26.10",
     "@babel/preset-env": "^7.26.9",
     "@dashevo/dashcore-lib": "~0.22.0",
-    "@dashevo/dpns-contract": "2.0.0-rc.8",
+    "@dashevo/dpns-contract": "2.0.0",
     "@types/bs58": "^4.0.1",
     "@types/node": "^14.6.0",
     "@yarnpkg/pnpify": "^4.0.0-rc.42",
@@ -55,7 +55,7 @@
     "chai-as-promised": "^7.1.1",
     "chai-exclude": "^2.1.0",
     "chai-string": "^1.5.0",
-    "crypto-browserify": "^3.12.0",
+    "crypto-browserify": "^3.12.1",
     "dirty-chai": "^2.0.1",
     "eslint": "^8.53.0",
     "eslint-config-airbnb-base": "^15.0.0",

package/src/data_contract/data_contract.rs

@@ -415,12 +415,11 @@ impl DataContractWasm {
         self.clone()
     }
 
-    pub(crate) fn try_from_serialization_format(
+    pub(crate) fn try_from_serialization_format_with_platform_version(
         value: DataContractInSerializationFormat,
         full_validation: bool,
+        platform_version: &PlatformVersion,
     ) -> Result<Self, JsValue> {
-        let platform_version = PlatformVersion::first();
-
         DataContract::try_from_platform_versioned(
             value,
             full_validation,

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

@@ -55,9 +55,24 @@ impl DataContractCreateTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=getDataContract)]
-    pub fn get_data_contract(&self) -> DataContractWasm {
-        DataContractWasm::try_from_serialization_format(self.0.data_contract().clone(), false)
-            .expect("should convert from serialziation format")
+    pub fn get_data_contract(
+        &self,
+        protocol_version: Option<u32>,
+    ) -> Result<DataContractWasm, JsValue> {
+        // Use provided protocol version or latest if not specified
+        let platform_version = if let Some(version) = protocol_version {
+            PlatformVersion::get(version)
+                .map_err(ProtocolError::PlatformVersionError)
+                .with_js_error()?
+        } else {
+            PlatformVersion::latest()
+        };
+
+        DataContractWasm::try_from_serialization_format_with_platform_version(
+            self.0.data_contract().clone(),
+            false,
+            platform_version,
+        )
     }
 
     // #[wasm_bindgen(js_name=setDataContractConfig)]

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

@@ -56,9 +56,24 @@ impl DataContractUpdateTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=getDataContract)]
-    pub fn get_data_contract(&self) -> DataContractWasm {
-        DataContractWasm::try_from_serialization_format(self.0.data_contract().clone(), false)
-            .expect("should create data contract from serialized format")
+    pub fn get_data_contract(
+        &self,
+        protocol_version: Option<u32>,
+    ) -> Result<DataContractWasm, JsValue> {
+        // Use provided protocol version or latest if not specified
+        let platform_version = if let Some(version) = protocol_version {
+            PlatformVersion::get(version)
+                .map_err(ProtocolError::PlatformVersionError)
+                .with_js_error()?
+        } else {
+            PlatformVersion::latest()
+        };
+
+        DataContractWasm::try_from_serialization_format_with_platform_version(
+            self.0.data_contract().clone(),
+            false,
+            platform_version,
+        )
     }
 
     // #[wasm_bindgen(js_name=setDataContractConfig)]

package/src/document/state_transition/batch_transition/token_transition/burn.rs

@@ -1,3 +1,4 @@
+use dpp::state_transition::batch_transition::token_burn_transition::v0::v0_methods::TokenBurnTransitionV0Methods;
 use dpp::state_transition::batch_transition::TokenBurnTransition;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -10,3 +11,16 @@ impl From<TokenBurnTransition> for TokenBurnTransitionWasm {
         Self(value)
     }
 }
+
+#[wasm_bindgen(js_class = TokenBurnTransition)]
+impl TokenBurnTransitionWasm {
+    #[wasm_bindgen(js_name=getPublicNote)]
+    pub fn public_note(&self) -> Option<String> {
+        self.0.public_note().cloned()
+    }
+
+    #[wasm_bindgen(js_name=getBurnAmount)]
+    pub fn amount(&self) -> u64 {
+        self.0.burn_amount()
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/claim.rs

@@ -1,3 +1,5 @@
+use dpp::data_contract::associated_token::token_distribution_key::TokenDistributionType;
+use dpp::state_transition::batch_transition::token_claim_transition::v0::v0_methods::TokenClaimTransitionV0Methods;
 use dpp::state_transition::batch_transition::TokenClaimTransition;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -10,3 +12,19 @@ impl From<TokenClaimTransition> for TokenClaimTransitionWasm {
         Self(value)
     }
 }
+
+#[wasm_bindgen(js_class = TokenClaimTransition)]
+impl TokenClaimTransitionWasm {
+    #[wasm_bindgen(js_name=getPublicNote)]
+    pub fn public_note(&self) -> Option<String> {
+        self.0.public_note().cloned()
+    }
+
+    #[wasm_bindgen(js_name=getDistributionType)]
+    pub fn distribution_type(&self) -> u8 {
+        match self.0.distribution_type() {
+            TokenDistributionType::PreProgrammed => 0,
+            TokenDistributionType::Perpetual => 1,
+        }
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/config.rs

@@ -1,3 +1,4 @@
+use dpp::state_transition::batch_transition::token_config_update_transition::v0::v0_methods::TokenConfigUpdateTransitionV0Methods;
 use dpp::state_transition::batch_transition::TokenConfigUpdateTransition;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -10,3 +11,11 @@ impl From<TokenConfigUpdateTransition> for TokenConfigUpdateTransitionWasm {
         Self(value)
     }
 }
+
+#[wasm_bindgen(js_class = TokenConfigUpdateTransition)]
+impl TokenConfigUpdateTransitionWasm {
+    #[wasm_bindgen(js_name=getPublicNote)]
+    pub fn public_note(&self) -> Option<String> {
+        self.0.public_note().cloned()
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/destroy.rs

@@ -19,4 +19,9 @@ impl TokenDestroyFrozenFundsTransitionWasm {
     pub fn frozen_identity_id(&self) -> IdentifierWrapper {
         self.0.frozen_identity_id().into()
     }
+
+    #[wasm_bindgen(js_name=getPublicNote)]
+    pub fn public_note(&self) -> Option<String> {
+        self.0.public_note().cloned()
+    }
 }

package/src/document/state_transition/batch_transition/token_transition/direct_purchase.rs

@@ -1,3 +1,6 @@
+use dpp::balances::credits::TokenAmount;
+use dpp::fee::Credits;
+use dpp::state_transition::batch_transition::token_direct_purchase_transition::v0::v0_methods::TokenDirectPurchaseTransitionV0Methods;
 use dpp::state_transition::batch_transition::TokenDirectPurchaseTransition;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -10,3 +13,16 @@ impl From<TokenDirectPurchaseTransition> for TokenDirectPurchaseTransitionWasm {
         Self(value)
     }
 }
+
+#[wasm_bindgen(js_class = TokenDirectPurchaseTransition)]
+impl TokenDirectPurchaseTransitionWasm {
+    #[wasm_bindgen(js_name=getTokenCount)]
+    pub fn count(&self) -> TokenAmount {
+        self.0.token_count()
+    }
+
+    #[wasm_bindgen(js_name=getTotalAgreedPrice)]
+    pub fn total_agreed_price(&self) -> Credits {
+        self.0.total_agreed_price()
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/emergency_action.rs

@@ -1,4 +1,6 @@
+use dpp::state_transition::batch_transition::token_emergency_action_transition::v0::v0_methods::TokenEmergencyActionTransitionV0Methods;
 use dpp::state_transition::batch_transition::TokenEmergencyActionTransition;
+use dpp::tokens::emergency_action::TokenEmergencyAction;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 #[wasm_bindgen(js_name=TokenEmergencyActionTransition)]
@@ -10,3 +12,19 @@ impl From<TokenEmergencyActionTransition> for TokenEmergencyActionTransitionWasm
         Self(value)
     }
 }
+
+#[wasm_bindgen(js_class = TokenEmergencyActionTransition)]
+impl TokenEmergencyActionTransitionWasm {
+    #[wasm_bindgen(js_name=getPublicNote)]
+    pub fn public_note(&self) -> Option<String> {
+        self.0.public_note().cloned()
+    }
+
+    #[wasm_bindgen(js_name=getEmergencyAction)]
+    pub fn emergency_action(&self) -> u8 {
+        match self.0.emergency_action() {
+            TokenEmergencyAction::Pause => 0,
+            TokenEmergencyAction::Resume => 1,
+        }
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/freeze.rs

@@ -19,4 +19,9 @@ impl TokenFreezeTransitionWasm {
     pub fn frozen_identity_id(&self) -> IdentifierWrapper {
         self.0.frozen_identity_id().into()
     }
+
+    #[wasm_bindgen(js_name=getPublicNote)]
+    pub fn public_note(&self) -> Option<String> {
+        self.0.public_note().cloned()
+    }
 }

package/src/document/state_transition/batch_transition/token_transition/mint.rs

@@ -28,4 +28,19 @@ impl TokenMintTransitionWasm {
             .with_js_error()
             .map(Into::into)
     }
+
+    #[wasm_bindgen(js_name=getIssuedToIdentityId)]
+    pub fn issued_to_identity_id(&self) -> Option<IdentifierWrapper> {
+        self.0.issued_to_identity_id().map(|id| id.into())
+    }
+
+    #[wasm_bindgen(js_name=getPublicNote)]
+    pub fn public_note(&self) -> Option<String> {
+        self.0.public_note().cloned()
+    }
+
+    #[wasm_bindgen(js_name=getAmount)]
+    pub fn amount(&self) -> u64 {
+        self.0.amount()
+    }
 }

package/src/document/state_transition/batch_transition/token_transition/set_price_for_direct_purchase.rs

@@ -1,5 +1,8 @@
 use dpp::state_transition::batch_transition::TokenSetPriceForDirectPurchaseTransition;
 use wasm_bindgen::prelude::wasm_bindgen;
+use dpp::fee::Credits;
+use dpp::state_transition::batch_transition::token_set_price_for_direct_purchase_transition::v0::v0_methods::TokenSetPriceForDirectPurchaseTransitionV0Methods;
+use dpp::tokens::token_pricing_schedule::TokenPricingSchedule;
 
 #[wasm_bindgen(js_name=TokenSetPriceForDirectPurchaseTransition)]
 #[derive(Debug, Clone)]
@@ -12,3 +15,22 @@ impl From<TokenSetPriceForDirectPurchaseTransition>
         Self(value)
     }
 }
+
+#[wasm_bindgen(js_class=TokenSetPriceForDirectPurchaseTransition)]
+impl TokenSetPriceForDirectPurchaseTransitionWasm {
+    #[wasm_bindgen(js_name=getPublicNote)]
+    pub fn public_note(&self) -> Option<String> {
+        self.0.public_note().cloned()
+    }
+
+    #[wasm_bindgen(js_name=getPrice)]
+    pub fn price(&self) -> Option<Credits> {
+        match self.0.price() {
+            Some(token_pricing_schedule) => match token_pricing_schedule {
+                TokenPricingSchedule::SinglePrice(credits) => Some(*credits),
+                TokenPricingSchedule::SetPrices(_) => None,
+            },
+            None => None,
+        }
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/transfer.rs

@@ -19,4 +19,14 @@ impl TokenTransferTransitionWasm {
     pub fn recipient_id(&self) -> IdentifierWrapper {
         self.0.recipient_id().into()
     }
+
+    #[wasm_bindgen(js_name=getPublicNote)]
+    pub fn public_note(&self) -> Option<String> {
+        self.0.public_note().cloned()
+    }
+
+    #[wasm_bindgen(js_name=getAmount)]
+    pub fn amount(&self) -> u64 {
+        self.0.amount()
+    }
 }

package/src/document/state_transition/batch_transition/token_transition/unfreeze.rs

@@ -19,4 +19,9 @@ impl TokenUnfreezeTransitionWasm {
     pub fn frozen_identity_id(&self) -> IdentifierWrapper {
         self.0.frozen_identity_id().into()
     }
+
+    #[wasm_bindgen(js_name=getPublicNote)]
+    pub fn public_note(&self) -> Option<String> {
+        self.0.public_note().cloned()
+    }
 }

package/src/errors/consensus/consensus_error.rs

@@ -61,12 +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, DataContractTokenConfigurationUpdateError, DecimalsOverLimitError, DuplicateKeywordsError, GroupExceedsMaxMembersError, GroupMemberHasPowerOfZeroError, GroupMemberHasPowerOverLimitError, GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError, GroupPositionDoesNotExistError, GroupRequiredPowerIsInvalidError, GroupTotalPowerLessThanRequiredError, InvalidDescriptionLengthError, InvalidDocumentTypeRequiredSecurityLevelError, InvalidKeywordCharacterError, InvalidKeywordLengthError, InvalidTokenBaseSupplyError, InvalidTokenDistributionFunctionDivideByZeroError, InvalidTokenDistributionFunctionIncoherenceError, InvalidTokenDistributionFunctionInvalidParameterError, InvalidTokenDistributionFunctionInvalidParameterTupleError, InvalidTokenLanguageCodeError, InvalidTokenNameCharacterError, InvalidTokenNameLengthError, MainGroupIsNotDefinedError, NewTokensDestinationIdentityOptionRequiredError, NonContiguousContractGroupPositionsError, NonContiguousContractTokenPositionsError, TokenPaymentByBurningOnlyAllowedOnInternalTokenError, TooManyKeywordsError, UnknownDocumentActionTokenEffectError, UnknownDocumentCreationRestrictionModeError, UnknownGasFeesPaidByError, UnknownSecurityLevelError, UnknownStorageKeyRequirementsError, UnknownTradeModeError, UnknownTransferableTypeError};
+use dpp::consensus::basic::data_contract::{ContestedUniqueIndexOnMutableDocumentTypeError, ContestedUniqueIndexWithUniqueIndexError, DataContractTokenConfigurationUpdateError, DecimalsOverLimitError, DuplicateKeywordsError, GroupExceedsMaxMembersError, GroupHasTooFewMembersError, GroupMemberHasPowerOfZeroError, GroupMemberHasPowerOverLimitError, GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError, GroupPositionDoesNotExistError, GroupRequiredPowerIsInvalidError, GroupTotalPowerLessThanRequiredError, InvalidDescriptionLengthError, InvalidDocumentTypeRequiredSecurityLevelError, InvalidKeywordCharacterError, InvalidKeywordLengthError, InvalidTokenBaseSupplyError, InvalidTokenDistributionFunctionDivideByZeroError, InvalidTokenDistributionFunctionIncoherenceError, InvalidTokenDistributionFunctionInvalidParameterError, InvalidTokenDistributionFunctionInvalidParameterTupleError, InvalidTokenLanguageCodeError, InvalidTokenNameCharacterError, InvalidTokenNameLengthError, MainGroupIsNotDefinedError, NewTokensDestinationIdentityOptionRequiredError, NonContiguousContractGroupPositionsError, NonContiguousContractTokenPositionsError, RedundantDocumentPaidForByTokenWithContractId, TokenPaymentByBurningOnlyAllowedOnInternalTokenError, TooManyKeywordsError, UnknownDocumentActionTokenEffectError, UnknownDocumentCreationRestrictionModeError, UnknownGasFeesPaidByError, 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::identity::{DataContractBoundsNotPresentError, DisablingKeyIdAlsoBeingAddedInSameTransitionError, InvalidIdentityCreditWithdrawalTransitionAmountError, InvalidIdentityUpdateTransitionDisableKeysError, InvalidIdentityUpdateTransitionEmptyError, InvalidKeyPurposeForContractBoundsError, 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::basic::token::{ChoosingTokenMintRecipientNotAllowedError, ContractHasNoTokensError, DestinationIdentityForTokenMintingNotSetError, InvalidActionIdError, InvalidTokenAmountError, InvalidTokenConfigUpdateNoChangeError, InvalidTokenIdError, InvalidTokenNoteTooBigError, InvalidTokenPositionError, MissingDefaultLocalizationError, TokenNoteOnlyAllowedWhenProposerError, TokenTransferToOurselfError, InvalidTokenDistributionTimeIntervalNotMinuteAlignedError, InvalidTokenDistributionTimeIntervalTooShortError, InvalidTokenDistributionBlockIntervalTooShortError};
+use dpp::consensus::state::data_contract::data_contract_not_found_error::DataContractNotFoundError;
 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;
@@ -76,16 +77,17 @@ 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, IdentityMemberOfGroupNotFoundError, IdentityNotMemberOfGroupError};
+use dpp::consensus::state::group::{GroupActionAlreadyCompletedError, GroupActionAlreadySignedByIdentityError, GroupActionDoesNotExistError, IdentityMemberOfGroupNotFoundError, IdentityNotMemberOfGroupError, ModificationOfGroupActionMainParametersNotPermittedError};
 use dpp::consensus::state::identity::identity_for_token_configuration_not_found_error::IdentityInTokenConfigurationNotFoundError;
 use dpp::consensus::state::identity::identity_public_key_already_exists_for_unique_contract_bounds_error::IdentityPublicKeyAlreadyExistsForUniqueContractBoundsError;
+use dpp::consensus::state::identity::identity_to_freeze_does_not_exist_error::IdentityToFreezeDoesNotExistError;
 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, TokenTransferRecipientIdentityNotExistError, PreProgrammedDistributionTimestampInPastError, IdentityHasNotAgreedToPayRequiredTokenAmountError, RequiredTokenPaymentInfoNotSetError, IdentityTryingToPayWithWrongTokenError, TokenDirectPurchaseUserPriceTooLow, TokenAmountUnderMinimumSaleAmount, TokenNotForDirectSale};
+use dpp::consensus::state::token::{IdentityDoesNotHaveEnoughTokenBalanceError, IdentityTokenAccountNotFrozenError, IdentityTokenAccountFrozenError, TokenIsPausedError, IdentityTokenAccountAlreadyFrozenError, UnauthorizedTokenActionError, TokenSettingMaxSupplyToLessThanCurrentSupplyError, TokenMintPastMaxSupplyError, NewTokensDestinationIdentityDoesNotExistError, NewAuthorizedActionTakerIdentityDoesNotExistError, NewAuthorizedActionTakerGroupDoesNotExistError, NewAuthorizedActionTakerMainGroupNotSetError, InvalidGroupPositionError, TokenAlreadyPausedError, TokenNotPausedError, InvalidTokenClaimPropertyMismatch, InvalidTokenClaimNoCurrentRewards, InvalidTokenClaimWrongClaimant, TokenTransferRecipientIdentityNotExistError, PreProgrammedDistributionTimestampInPastError, IdentityHasNotAgreedToPayRequiredTokenAmountError, RequiredTokenPaymentInfoNotSetError, IdentityTryingToPayWithWrongTokenError, TokenDirectPurchaseUserPriceTooLow, TokenAmountUnderMinimumSaleAmount, TokenNotForDirectSale, InvalidTokenPositionStateError};
 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;
@@ -415,6 +417,19 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
         StateError::IdentityMemberOfGroupNotFoundError(e) => {
             generic_consensus_error!(IdentityMemberOfGroupNotFoundError, e).into()
         }
+        StateError::ModificationOfGroupActionMainParametersNotPermittedError(e) => {
+            generic_consensus_error!(ModificationOfGroupActionMainParametersNotPermittedError, e)
+                .into()
+        }
+        StateError::IdentityToFreezeDoesNotExistError(e) => {
+            generic_consensus_error!(IdentityToFreezeDoesNotExistError, e).into()
+        }
+        StateError::DataContractNotFoundError(e) => {
+            generic_consensus_error!(DataContractNotFoundError, e).into()
+        }
+        StateError::InvalidTokenPositionStateError(e) => {
+            generic_consensus_error!(InvalidTokenPositionStateError, e).into()
+        }
     }
 }
 
@@ -813,6 +828,28 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
         BasicError::GroupRequiredPowerIsInvalidError(e) => {
             generic_consensus_error!(GroupRequiredPowerIsInvalidError, e).into()
         }
+        BasicError::TokenNoteOnlyAllowedWhenProposerError(e) => {
+            generic_consensus_error!(TokenNoteOnlyAllowedWhenProposerError, e).into()
+        }
+        BasicError::InvalidTokenDistributionBlockIntervalTooShortError(e) => {
+            generic_consensus_error!(InvalidTokenDistributionBlockIntervalTooShortError, e).into()
+        }
+        BasicError::InvalidTokenDistributionTimeIntervalTooShortError(e) => {
+            generic_consensus_error!(InvalidTokenDistributionTimeIntervalTooShortError, e).into()
+        }
+        BasicError::InvalidTokenDistributionTimeIntervalNotMinuteAlignedError(e) => {
+            generic_consensus_error!(InvalidTokenDistributionTimeIntervalNotMinuteAlignedError, e)
+                .into()
+        }
+        BasicError::RedundantDocumentPaidForByTokenWithContractId(e) => {
+            generic_consensus_error!(RedundantDocumentPaidForByTokenWithContractId, e).into()
+        }
+        BasicError::GroupHasTooFewMembersError(e) => {
+            generic_consensus_error!(GroupHasTooFewMembersError, e).into()
+        }
+        BasicError::InvalidKeyPurposeForContractBoundsError(e) => {
+            generic_consensus_error!(InvalidKeyPurposeForContractBoundsError, e).into()
+        }
     }
 }
 

package/test/unit/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition.spec.js

@@ -46,6 +46,12 @@ describe('DataContractCreateTransition', () => {
 
       expect(result.toObject()).to.deep.equal(dataContract.toObject());
     });
+
+    it('should return Data Contract with specific protocol version', () => {
+      const result = stateTransition.getDataContract(1);
+
+      expect(result.toObject()).to.deep.equal(dataContract.toObject());
+    });
   });
 
   describe.skip('#toJSON', () => {
@@ -66,7 +72,7 @@ describe('DataContractCreateTransition', () => {
     it('should return serialized State Transition', () => {
       const result = stateTransition.toBuffer();
       expect(result).to.be.instanceOf(Buffer);
-      expect(result).to.have.lengthOf(2360);
+      expect(result).to.have.lengthOf(2359);
     });
 
     it('should be able to restore contract config from bytes', () => {

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition.spec.js

@@ -65,7 +65,7 @@ describe('DataContractUpdateTransition', () => {
     it('should return serialized State Transition', () => {
       const result = stateTransition.toBuffer();
       expect(result).to.be.instanceOf(Buffer);
-      expect(result).to.have.lengthOf(2360);
+      expect(result).to.have.lengthOf(2359);
     });
 
     it('should be able to restore contract config from bytes', () => {