@dashevo/wasm-dpp 4.1.1 → 4.2.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "4.1.1",
+  "version": "4.2.0-beta.2",
   "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": "4.1.1",
+    "@dashevo/dpns-contract": "4.2.0-beta.2",
     "@types/bs58": "^4.0.1",
     "@types/node": "^20.10.0",
     "@yarnpkg/pnpify": "^4.0.0-rc.42",

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

@@ -7,7 +7,7 @@ use crate::errors::protocol_error::from_protocol_error;
 use dpp::errors::consensus::signature::SignatureError;
 use dpp::errors::consensus::ConsensusError;
 
-use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
+use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable};
 use dpp::state_transition::data_contract_create_transition::accessors::DataContractCreateTransitionAccessorsV0;
 use dpp::state_transition::data_contract_create_transition::DataContractCreateTransition;
 use dpp::state_transition::StateTransitionHasUserFeeIncrease;
@@ -169,7 +169,8 @@ impl DataContractCreateTransitionWasm {
     #[wasm_bindgen(js_name=fromBuffer)]
     pub fn from_buffer(buffer: Vec<u8>) -> Result<DataContractCreateTransitionWasm, JsValue> {
         let state_transition: StateTransition =
-            PlatformDeserializable::deserialize_from_bytes(&buffer).with_js_error()?;
+            PlatformDeserializableUntrusted::deserialize_from_bytes_untrusted(&buffer)
+                .with_js_error()?;
         match state_transition {
             StateTransition::DataContractCreate(dct) => Ok(dct.into()),
             _ => Err(JsValue::from_str("Invalid state transition type")),

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

@@ -4,7 +4,7 @@
 
 use dpp::consensus::ConsensusError;
 use dpp::serialization::ValueConvertible;
-use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
+use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable};
 use dpp::state_transition::data_contract_update_transition::accessors::DataContractUpdateTransitionAccessorsV0;
 use dpp::state_transition::data_contract_update_transition::DataContractUpdateTransition;
 use dpp::state_transition::StateTransition;
@@ -164,7 +164,8 @@ impl DataContractUpdateTransitionWasm {
     #[wasm_bindgen(js_name=fromBuffer)]
     pub fn from_buffer(buffer: Vec<u8>) -> Result<DataContractUpdateTransitionWasm, JsValue> {
         let state_transition: StateTransition =
-            PlatformDeserializable::deserialize_from_bytes(&buffer).with_js_error()?;
+            PlatformDeserializableUntrusted::deserialize_from_bytes_untrusted(&buffer)
+                .with_js_error()?;
         match state_transition {
             StateTransition::DataContractUpdate(dct) => Ok(dct.into()),
             _ => Err(JsValue::from_str("Invalid state transition type")),

package/src/document/factory.rs

@@ -145,7 +145,7 @@ impl DocumentFactoryWASM {
 
         let documents_by_action = extract_documents_by_action(documents)?;
 
-        for (_, documents) in documents_by_action.iter() {
+        for documents in documents_by_action.values() {
             for document in documents.iter() {
                 if !contract_ids_to_check.contains(&document.data_contract().id()) {
                     return Err(JsValue::from_str(

package/src/document/state_transition/batch_transition/document_transition/mod.rs

@@ -23,6 +23,7 @@ use dpp::state_transition::batch_transition::document_replace_transition::v0::v0
 use dpp::state_transition::batch_transition::batched_transition::document_purchase_transition::v0::v0_methods::DocumentPurchaseTransitionV0Methods;
 use dpp::state_transition::batch_transition::batched_transition::document_transfer_transition::v0::v0_methods::DocumentTransferTransitionV0Methods;
 use dpp::state_transition::batch_transition::batched_transition::document_update_price_transition::v0::v0_methods::DocumentUpdatePriceTransitionV0Methods;
+use dpp::state_transition::batch_transition::batched_transition::document_index_only_delete_transition::v0::v0_methods::DocumentIndexOnlyDeleteTransitionV0Methods;
 use dpp::state_transition::batch_transition::document_base_transition::v0::v0_methods::DocumentBaseTransitionV0Methods;
 use crate::{
     buffer::Buffer,
@@ -67,6 +68,12 @@ impl DocumentTransitionWasm {
             DocumentTransition::Transfer(_) => JsValue::null(),
             DocumentTransition::UpdatePrice(_) => JsValue::null(),
             DocumentTransition::Purchase(_) => JsValue::null(),
+            DocumentTransition::IndexOnlyDelete(index_only_delete) => {
+                let json_value = index_only_delete.data().to_json_value().unwrap();
+                json_value
+                    .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+                    .unwrap()
+            }
         }
     }
 
@@ -110,6 +117,7 @@ impl DocumentTransitionWasm {
             DocumentTransition::Transfer(_) => None,
             DocumentTransition::UpdatePrice(update_price) => Some(update_price.price()),
             DocumentTransition::Purchase(purchase) => Some(purchase.price()),
+            DocumentTransition::IndexOnlyDelete(_) => None,
         }
     }
 
@@ -122,6 +130,7 @@ impl DocumentTransitionWasm {
             DocumentTransition::Transfer(transfer) => Some(transfer.recipient_owner_id().into()),
             DocumentTransition::UpdatePrice(_) => None,
             DocumentTransition::Purchase(_) => None,
+            DocumentTransition::IndexOnlyDelete(_) => None,
         }
     }
 

package/src/errors/consensus/basic/identity/contract_group_bound_key_not_allowed_in_shielded_identity_creation_error.rs

@@ -0,0 +1,36 @@
+use dpp::consensus::basic::identity::ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationError;
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::ConsensusError;
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationError)]
+pub struct ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationErrorWasm {
+    inner: ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationError,
+}
+
+impl From<&ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationError>
+    for ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationErrorWasm
+{
+    fn from(e: &ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationError)]
+impl ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationErrorWasm {
+    #[wasm_bindgen(js_name=getKeyId)]
+    pub fn get_key_id(&self) -> u32 {
+        self.inner.key_id()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> String {
+        self.inner.to_string()
+    }
+}

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

@@ -1,3 +1,4 @@
+mod contract_group_bound_key_not_allowed_in_shielded_identity_creation_error;
 mod duplicated_identity_public_key_error;
 mod duplicated_identity_public_key_id_error;
 mod identity_asset_lock_proof_locked_transaction_mismatch_error;
@@ -28,6 +29,7 @@ mod missing_master_public_key_error;
 mod missing_public_key_error;
 mod not_implemented_credit_withdrawal_transition_pooling_error;
 
+pub use contract_group_bound_key_not_allowed_in_shielded_identity_creation_error::*;
 pub use duplicated_identity_public_key_error::*;
 pub use duplicated_identity_public_key_id_error::*;
 pub use identity_asset_lock_proof_locked_transaction_mismatch_error::*;

package/src/errors/consensus/consensus_error.rs

@@ -1,3 +1,6 @@
+use super::signature::ContractBoundedKeyNonBatchErrorWasm;
+use super::signature::ContractBoundedKeyOutOfBoundsErrorWasm;
+use crate::errors::consensus::basic::identity::ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationErrorWasm;
 use crate::errors::consensus::basic::{
     IncompatibleProtocolVersionErrorWasm, InvalidIdentifierErrorWasm,
     InvalidSignaturePublicKeyPurposeErrorWasm, JsonSchemaErrorWasm,
@@ -34,6 +37,7 @@ use crate::errors::consensus::state::identity::{
 };
 use dpp::consensus::basic::decode::VersionError;
 use dpp::consensus::basic::BasicError::{
+    ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationError,
     DuplicatedIdentityPublicKeyBasicError, DuplicatedIdentityPublicKeyIdBasicError,
     IdentityAssetLockProofLockedTransactionMismatchError,
     IdentityAssetLockStateTransitionReplayError, IdentityAssetLockTransactionIsNotFoundError,
@@ -62,25 +66,50 @@ 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, 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::data_contract::{ContestedUniqueIndexOnMutableDocumentTypeError, DataContractInvalidRequiredFieldsUpdateError, 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, 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, TokenNoteOnlyAllowedWhenProposerError, TokenPricingScheduleEmptyError, TokenTransferToOurselfError, InvalidTokenDistributionTimeIntervalNotMinuteAlignedError, InvalidTokenDistributionTimeIntervalTooShortError, InvalidTokenDistributionBlockIntervalTooShortError};
+use dpp::consensus::basic::token::{ChoosingTokenMintRecipientNotAllowedError, ContractHasNoTokensError, DestinationIdentityForTokenMintingNotSetError, InvalidActionIdError, InvalidTokenAmountError, InvalidTokenConfigUpdateNoChangeError, InvalidTokenIdError, InvalidTokenNoteTooBigError, InvalidTokenPositionError, MissingDefaultLocalizationError, TokenNoteOnlyAllowedWhenProposerError, TokenPricingScheduleEmptyError, TokenTransferToOurselfError, InvalidTokenDistributionTimeIntervalNotMinuteAlignedError, InvalidTokenDistributionTimeIntervalTooShortError, InvalidTokenDistributionBlockIntervalTooShortError, InvalidTokenDistributionEpochIntervalTooShortError};
 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;
 use dpp::consensus::state::document::document_contest_document_with_same_id_already_present_error::DocumentContestDocumentWithSameIdAlreadyPresentError;
 use dpp::consensus::state::document::document_contest_identity_already_contestant::DocumentContestIdentityAlreadyContestantError;
+use dpp::consensus::state::document::document_contest_index_mismatch_error::DocumentContestIndexMismatchError;
 use dpp::consensus::state::document::document_contest_not_joinable_error::DocumentContestNotJoinableError;
 use dpp::consensus::state::document::document_contest_not_paid_for_error::DocumentContestNotPaidForError;
+use dpp::consensus::state::document::document_contest_not_required_error::DocumentContestNotRequiredError;
 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::basic::contract_group::{
+    ContractGroupMemberNotInContractError, ContractGroupMembershipsOverLimitError,
+    DuplicateContractGroupMembershipError,
+    InvalidContractGroupDescriptionLengthError, InvalidContractGroupNameLengthError,
+    InvalidContractGroupAdminsError, RedundantContractGroupMembershipError,
+};
+use dpp::consensus::state::contract_group::{
+    ContractGroupAdminNotFoundError, ContractGroupAlreadyExistsError, ContractGroupNotFoundError,
+    IdentityNotContractGroupOwnerOrAdminError,
+};
 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::basic::identity::{
+    IdentityKeyLimitsUpdateEmptyError, IdentityPublicKeyLimitsNotAllowedError,
+    IdentityPublicKeyLimitsNotAllowedInShieldedIdentityCreationError,
+    InvalidIdentityPublicKeyBudgetError,
+};
+use dpp::consensus::signature::{
+    PublicKeyBudgetExhaustedError, PublicKeyExpiredError,
+    PublicKeyWithLimitsCannotUpdateKeyLimitsError,
+};
+use dpp::consensus::state::identity::identity_public_key_already_expired_error::IdentityPublicKeyAlreadyExpiredError;
+use dpp::consensus::state::identity::identity_public_key_limit_not_raised_error::IdentityPublicKeyLimitNotRaisedError;
+use dpp::consensus::state::identity::identity_public_key_limit_not_set_error::IdentityPublicKeyLimitNotSetError;
+use dpp::consensus::state::identity::identity_public_key_budget_exceeded_error::IdentityPublicKeyBudgetExceededError;
 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;
@@ -90,6 +119,14 @@ use dpp::consensus::state::prefunded_specialized_balances::prefunded_specialized
 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, InvalidTokenPositionStateError};
 use dpp::consensus::state::address_funds::{AddressDoesNotExistError, AddressInvalidNonceError, AddressNotEnoughFundsError, AddressesNotEnoughFundsError};
+use dpp::consensus::state::document::referenced_document_type_deletable_error::ReferencedDocumentTypeDeletableError;
+use dpp::consensus::state::document::referenced_identity_key_disabled_error::ReferencedIdentityKeyDisabledError;
+use dpp::consensus::state::document::referenced_identity_key_not_found_error::ReferencedIdentityKeyNotFoundError;
+use dpp::consensus::state::document::referenced_document_property_agreement_invalid_error::ReferencedDocumentPropertyAgreementInvalidError;
+use dpp::consensus::state::document::referenced_document_property_mismatch_error::ReferencedDocumentPropertyMismatchError;
+use dpp::consensus::state::document::document_immutable_property_changed_error::DocumentImmutablePropertyChangedError;
+use dpp::consensus::state::document::referenced_key_id_property_invalid_error::ReferencedKeyIdPropertyInvalidError;
+use dpp::consensus::state::document::referenced_document_type_not_found_error::ReferencedDocumentTypeNotFoundError;
 use dpp::consensus::state::shielded::insufficient_pool_notes_error::InsufficientPoolNotesError;
 use dpp::consensus::state::shielded::insufficient_shielded_fee_error::InsufficientShieldedFeeError;
 use dpp::consensus::state::shielded::invalid_anchor_error::InvalidAnchorError;
@@ -136,6 +173,7 @@ use crate::errors::consensus::state::document::{
     DocumentAlreadyPresentErrorWasm, DocumentNotFoundErrorWasm, DocumentOwnerIdMismatchErrorWasm,
     DocumentTimestampWindowViolationErrorWasm, DocumentTimestampsMismatchErrorWasm,
     DuplicateUniqueIndexErrorWasm, InvalidDocumentRevisionErrorWasm,
+    ReferencedEntityNotFoundErrorWasm,
 };
 use crate::errors::consensus::state::identity::{
     IdentityAlreadyExistsErrorWasm, IdentityPublicKeyIsDisabledErrorWasm,
@@ -325,6 +363,12 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
         StateError::DocumentContestNotPaidForError(e) => {
             generic_consensus_error!(DocumentContestNotPaidForError, e).into()
         }
+        StateError::DocumentContestIndexMismatchError(e) => {
+            generic_consensus_error!(DocumentContestIndexMismatchError, e).into()
+        }
+        StateError::DocumentContestNotRequiredError(e) => {
+            generic_consensus_error!(DocumentContestNotRequiredError, e).into()
+        }
         StateError::RecipientIdentityDoesNotExistError(e) => {
             generic_consensus_error!(RecipientIdentityDoesNotExistError, e).into()
         }
@@ -463,6 +507,57 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
         StateError::InsufficientShieldedFeeError(e) => {
             generic_consensus_error!(InsufficientShieldedFeeError, e).into()
         }
+        StateError::ReferencedEntityNotFoundError(e) => {
+            ReferencedEntityNotFoundErrorWasm::from(e).into()
+        }
+        StateError::ReferencedDocumentTypeNotFoundError(e) => {
+            generic_consensus_error!(ReferencedDocumentTypeNotFoundError, e).into()
+        }
+        StateError::ReferencedDocumentTypeDeletableError(e) => {
+            generic_consensus_error!(ReferencedDocumentTypeDeletableError, e).into()
+        }
+        StateError::ReferencedIdentityKeyNotFoundError(e) => {
+            generic_consensus_error!(ReferencedIdentityKeyNotFoundError, e).into()
+        }
+        StateError::ReferencedIdentityKeyDisabledError(e) => {
+            generic_consensus_error!(ReferencedIdentityKeyDisabledError, e).into()
+        }
+        StateError::ReferencedKeyIdPropertyInvalidError(e) => {
+            generic_consensus_error!(ReferencedKeyIdPropertyInvalidError, e).into()
+        }
+        StateError::ReferencedDocumentPropertyAgreementInvalidError(e) => {
+            generic_consensus_error!(ReferencedDocumentPropertyAgreementInvalidError, e).into()
+        }
+        StateError::ReferencedDocumentPropertyMismatchError(e) => {
+            generic_consensus_error!(ReferencedDocumentPropertyMismatchError, e).into()
+        }
+        StateError::ContractGroupAlreadyExistsError(e) => {
+            generic_consensus_error!(ContractGroupAlreadyExistsError, e).into()
+        }
+        StateError::ContractGroupNotFoundError(e) => {
+            generic_consensus_error!(ContractGroupNotFoundError, e).into()
+        }
+        StateError::IdentityNotContractGroupOwnerOrAdminError(e) => {
+            generic_consensus_error!(IdentityNotContractGroupOwnerOrAdminError, e).into()
+        }
+        StateError::ContractGroupAdminNotFoundError(e) => {
+            generic_consensus_error!(ContractGroupAdminNotFoundError, e).into()
+        }
+        StateError::IdentityPublicKeyBudgetExceededError(e) => {
+            generic_consensus_error!(IdentityPublicKeyBudgetExceededError, e).into()
+        }
+        StateError::IdentityPublicKeyAlreadyExpiredError(e) => {
+            generic_consensus_error!(IdentityPublicKeyAlreadyExpiredError, e).into()
+        }
+        StateError::IdentityPublicKeyLimitNotSetError(e) => {
+            generic_consensus_error!(IdentityPublicKeyLimitNotSetError, e).into()
+        }
+        StateError::IdentityPublicKeyLimitNotRaisedError(e) => {
+            generic_consensus_error!(IdentityPublicKeyLimitNotRaisedError, e).into()
+        }
+        StateError::DocumentImmutablePropertyChangedError(e) => {
+            generic_consensus_error!(DocumentImmutablePropertyChangedError, e).into()
+        }
     }
 }
 
@@ -619,6 +714,9 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
         IdentityAssetLockTransactionTooManyInputsError(e) => {
             IdentityAssetLockTransactionTooManyInputsErrorWasm::from(e).into()
         }
+        ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationError(e) => {
+            ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationErrorWasm::from(e).into()
+        }
         InvalidInstantAssetLockProofError(e) => {
             InvalidInstantAssetLockProofErrorWasm::from(e).into()
         }
@@ -877,6 +975,9 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
             generic_consensus_error!(InvalidTokenDistributionTimeIntervalNotMinuteAlignedError, e)
                 .into()
         }
+        BasicError::InvalidTokenDistributionEpochIntervalTooShortError(e) => {
+            generic_consensus_error!(InvalidTokenDistributionEpochIntervalTooShortError, e).into()
+        }
         BasicError::RedundantDocumentPaidForByTokenWithContractId(e) => {
             generic_consensus_error!(RedundantDocumentPaidForByTokenWithContractId, e).into()
         }
@@ -973,6 +1074,46 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
         BasicError::TokenPricingScheduleEmptyError(e) => {
             generic_consensus_error!(TokenPricingScheduleEmptyError, e).into()
         }
+        BasicError::DataContractInvalidRequiredFieldsUpdateError(e) => {
+            generic_consensus_error!(DataContractInvalidRequiredFieldsUpdateError, e).into()
+        }
+        BasicError::ContractGroupMembershipsOverLimitError(e) => {
+            generic_consensus_error!(ContractGroupMembershipsOverLimitError, e).into()
+        }
+        BasicError::DuplicateContractGroupMembershipError(e) => {
+            generic_consensus_error!(DuplicateContractGroupMembershipError, e).into()
+        }
+        BasicError::RedundantContractGroupMembershipError(e) => {
+            generic_consensus_error!(RedundantContractGroupMembershipError, e).into()
+        }
+        BasicError::ContractGroupMemberNotInContractError(e) => {
+            generic_consensus_error!(ContractGroupMemberNotInContractError, e).into()
+        }
+        BasicError::InvalidContractGroupAdminsError(e) => {
+            generic_consensus_error!(InvalidContractGroupAdminsError, e).into()
+        }
+        BasicError::InvalidContractGroupNameLengthError(e) => {
+            generic_consensus_error!(InvalidContractGroupNameLengthError, e).into()
+        }
+        BasicError::InvalidContractGroupDescriptionLengthError(e) => {
+            generic_consensus_error!(InvalidContractGroupDescriptionLengthError, e).into()
+        }
+        BasicError::IdentityPublicKeyLimitsNotAllowedError(e) => {
+            generic_consensus_error!(IdentityPublicKeyLimitsNotAllowedError, e).into()
+        }
+        BasicError::InvalidIdentityPublicKeyBudgetError(e) => {
+            generic_consensus_error!(InvalidIdentityPublicKeyBudgetError, e).into()
+        }
+        BasicError::IdentityPublicKeyLimitsNotAllowedInShieldedIdentityCreationError(e) => {
+            generic_consensus_error!(
+                IdentityPublicKeyLimitsNotAllowedInShieldedIdentityCreationError,
+                e
+            )
+            .into()
+        }
+        BasicError::IdentityKeyLimitsUpdateEmptyError(e) => {
+            generic_consensus_error!(IdentityKeyLimitsUpdateEmptyError, e).into()
+        }
     }
 }
 
@@ -1006,9 +1147,24 @@ fn from_signature_error(signature_error: &SignatureError) -> JsValue {
         SignatureError::InvalidSignaturePublicKeyPurposeError(err) => {
             InvalidSignaturePublicKeyPurposeErrorWasm::from(err).into()
         }
+        SignatureError::ContractBoundedKeyNonBatchError(err) => {
+            ContractBoundedKeyNonBatchErrorWasm::from(err).into()
+        }
+        SignatureError::ContractBoundedKeyOutOfBoundsError(err) => {
+            ContractBoundedKeyOutOfBoundsErrorWasm::from(err).into()
+        }
         SignatureError::UncompressedPublicKeyNotAllowedError(err) => {
             UncompressedPublicKeyNotAllowedErrorWasm::from(err).into()
         }
+        SignatureError::PublicKeyBudgetExhaustedError(e) => {
+            generic_consensus_error!(PublicKeyBudgetExhaustedError, e).into()
+        }
+        SignatureError::PublicKeyExpiredError(e) => {
+            generic_consensus_error!(PublicKeyExpiredError, e).into()
+        }
+        SignatureError::PublicKeyWithLimitsCannotUpdateKeyLimitsError(e) => {
+            generic_consensus_error!(PublicKeyWithLimitsCannotUpdateKeyLimitsError, e).into()
+        }
     }
 }
 

package/src/errors/consensus/deserialize.rs

@@ -1,12 +1,12 @@
 use crate::errors::consensus::consensus_error::from_consensus_error;
 use dpp::consensus::ConsensusError;
-use dpp::serialization::PlatformDeserializable;
+use dpp::serialization::PlatformDeserializableUntrusted;
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::{JsError, JsValue};
 
 #[wasm_bindgen(js_name=deserializeConsensusError)]
 pub fn deserialize_consensus_error(bytes: Vec<u8>) -> Result<JsValue, JsError> {
-    ConsensusError::deserialize_from_bytes(bytes.as_slice())
+    ConsensusError::deserialize_from_bytes_untrusted(bytes.as_slice())
         .map(from_consensus_error)
         .map_err(|e| e.into())
 }

package/src/errors/consensus/signature/contract_bounded_key_non_batch_error.rs

@@ -0,0 +1,29 @@
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::signature::ContractBoundedKeyNonBatchError;
+use dpp::consensus::ConsensusError;
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=ContractBoundedKeyNonBatchError)]
+pub struct ContractBoundedKeyNonBatchErrorWasm {
+    inner: ContractBoundedKeyNonBatchError,
+}
+
+impl From<&ContractBoundedKeyNonBatchError> for ContractBoundedKeyNonBatchErrorWasm {
+    fn from(e: &ContractBoundedKeyNonBatchError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=ContractBoundedKeyNonBatchError)]
+impl ContractBoundedKeyNonBatchErrorWasm {
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> String {
+        self.inner.to_string()
+    }
+}

package/src/errors/consensus/signature/contract_bounded_key_out_of_bounds_error.rs

@@ -0,0 +1,29 @@
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::signature::ContractBoundedKeyOutOfBoundsError;
+use dpp::consensus::ConsensusError;
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=ContractBoundedKeyOutOfBoundsError)]
+pub struct ContractBoundedKeyOutOfBoundsErrorWasm {
+    inner: ContractBoundedKeyOutOfBoundsError,
+}
+
+impl From<&ContractBoundedKeyOutOfBoundsError> for ContractBoundedKeyOutOfBoundsErrorWasm {
+    fn from(e: &ContractBoundedKeyOutOfBoundsError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=ContractBoundedKeyOutOfBoundsError)]
+impl ContractBoundedKeyOutOfBoundsErrorWasm {
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> String {
+        self.inner.to_string()
+    }
+}

package/src/errors/consensus/signature/mod.rs

@@ -9,3 +9,9 @@ pub use basic_ecdsa_error::*;
 pub use identity_not_found_error::*;
 pub use signature_should_not_be_present_error::*;
 pub use uncompressed_public_key_not_allowed_error::*;
+
+mod contract_bounded_key_non_batch_error;
+pub use contract_bounded_key_non_batch_error::ContractBoundedKeyNonBatchErrorWasm;
+
+mod contract_bounded_key_out_of_bounds_error;
+pub use contract_bounded_key_out_of_bounds_error::ContractBoundedKeyOutOfBoundsErrorWasm;

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

@@ -6,6 +6,7 @@ mod document_timestamps_are_equal_error;
 mod document_timestamps_mismatch_error;
 mod duplicate_unique_index_error;
 mod invalid_document_revision_error;
+mod referenced_entity_not_found_error;
 
 pub use document_already_present_error::*;
 pub use document_not_found_error::*;
@@ -15,3 +16,4 @@ pub use document_timestamps_are_equal_error::*;
 pub use document_timestamps_mismatch_error::*;
 pub use duplicate_unique_index_error::*;
 pub use invalid_document_revision_error::*;
+pub use referenced_entity_not_found_error::*;

package/src/errors/consensus/state/document/referenced_entity_not_found_error.rs

@@ -0,0 +1,44 @@
+use crate::buffer::Buffer;
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::state::document::referenced_entity_not_found_error::ReferencedEntityNotFoundError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=ReferencedEntityNotFoundError)]
+pub struct ReferencedEntityNotFoundErrorWasm {
+    inner: ReferencedEntityNotFoundError,
+}
+
+impl From<&ReferencedEntityNotFoundError> for ReferencedEntityNotFoundErrorWasm {
+    fn from(e: &ReferencedEntityNotFoundError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=ReferencedEntityNotFoundError)]
+impl ReferencedEntityNotFoundErrorWasm {
+    #[wasm_bindgen(js_name=getEntityId)]
+    pub fn entity_id(&self) -> Buffer {
+        Buffer::from_bytes(self.inner.entity_id().as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getEntityType)]
+    pub fn entity_type(&self) -> String {
+        self.inner.entity_type().to_string()
+    }
+
+    #[wasm_bindgen(js_name=getPath)]
+    pub fn path(&self) -> String {
+        self.inner.path().to_string()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> String {
+        self.inner.to_string()
+    }
+}

package/src/identity/identity.rs

@@ -10,7 +10,7 @@ use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV
 use dpp::identity::{Identity, IdentityPublicKey, KeyID};
 use dpp::metadata::Metadata;
 use dpp::platform_value::ReplacementType;
-use dpp::serialization::PlatformDeserializable;
+use dpp::serialization::PlatformDeserializableUntrusted;
 use dpp::serialization::PlatformSerializable;
 use dpp::serialization::ValueConvertible;
 use dpp::version::PlatformVersion;
@@ -267,7 +267,8 @@ impl IdentityWasm {
     #[wasm_bindgen(js_name=fromBuffer)]
     pub fn from_buffer(buffer: Vec<u8>) -> Result<IdentityWasm, JsValue> {
         let identity: Identity =
-            PlatformDeserializable::deserialize_from_bytes(buffer.as_slice()).with_js_error()?;
+            PlatformDeserializableUntrusted::deserialize_from_bytes_untrusted(buffer.as_slice())
+                .with_js_error()?;
         Ok(identity.into())
     }
 }

package/src/identity/identity_public_key/mod.rs

@@ -11,7 +11,7 @@ use dpp::identity::identity_public_key::accessors::v0::{
 use dpp::identity::identity_public_key::hash::IdentityPublicKeyHashMethodsV0;
 use dpp::identity::{IdentityPublicKey, KeyID, TimestampMillis};
 use dpp::platform_value::{BinaryData, ReplacementType};
-use dpp::serialization::{PlatformDeserializable, PlatformSerializable, ValueConvertible};
+use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable, ValueConvertible};
 use dpp::ProtocolError;
 
 use dpp::version::PlatformVersion;
@@ -196,7 +196,8 @@ impl IdentityPublicKeyWasm {
     #[wasm_bindgen(js_name=fromBuffer)]
     pub fn from_buffer(buffer: Vec<u8>) -> Result<IdentityPublicKeyWasm, JsValue> {
         let key: IdentityPublicKey =
-            PlatformDeserializable::deserialize_from_bytes(buffer.as_slice()).with_js_error()?;
+            PlatformDeserializableUntrusted::deserialize_from_bytes_untrusted(buffer.as_slice())
+                .with_js_error()?;
         Ok(key.into())
     }
 }

package/src/identity/mod.rs

@@ -12,7 +12,7 @@ mod identity_public_key;
 // use dpp::identity::IdentityPublicKey;
 // use dpp::identity::{Identity, KeyID};
 // use dpp::metadata::Metadata;
-// use dpp::serialization::serialization_traits::{PlatformDeserializable, PlatformSerializable};
+// use dpp::serialization::serialization_traits::{PlatformDeserializableUntrusted, PlatformSerializable};
 // use dpp::{ ProtocolError};
 //
 // use crate::identifier::IdentifierWrapper;

package/src/lib.rs

@@ -1,3 +1,7 @@
+// Same allowance the dpp crate root carries: the `ProtocolError` values
+// threaded through these bindings are larger than clippy's default threshold.
+#![allow(clippy::result_large_err)]
+
 extern crate core;
 
 pub use dash_platform_protocol::*;

package/src/state_transition/state_transition_factory.rs

@@ -84,9 +84,14 @@ impl StateTransitionFactoryWasm {
                 | StateTransition::Unshield(_)
                 | StateTransition::ShieldFromAssetLock(_)
                 | StateTransition::ShieldedWithdrawal(_)
-                | StateTransition::IdentityCreateFromShieldedPool(_) => Err(JsValue::from_str(
+                | StateTransition::IdentityCreateFromShieldedPool(_)
+                | StateTransition::ShieldFromIdentity(_)
+                | StateTransition::IdentityTopUpFromShieldedPool(_) => Err(JsValue::from_str(
                     "shielded transitions are not yet supported in wasm-dpp StateTransitionFactory",
                 )),
+                StateTransition::IdentityKeyLimitsUpdate(_) => Err(JsValue::from_str(
+                    "identity key limits update transitions are not supported in wasm-dpp StateTransitionFactory; use wasm-dpp2",
+                )),
             },
             Err(dpp::ProtocolError::StateTransitionError(e)) => match e {
                 StateTransitionError::InvalidStateTransitionError {