@dashevo/wasm-dpp 4.2.0-dev.9 → 5.0.0-beta.2

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,27 +66,87 @@ use dpp::consensus::state::data_trigger::DataTriggerError::{
   DataTriggerConditionError, DataTriggerExecutionError, DataTriggerInvalidResultError,
 };
 use wasm_bindgen::{JsError, JsValue};
-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::data_contract::{ContestedUniqueIndexOnMutableDocumentTypeError, ContestedUniqueIndexWithUniqueIndexError, DataContractInvalidRequiredFieldsUpdateError, 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, PreProgrammedDistributionAmountOverLimitError, RedundantDocumentPaidForByTokenWithContractId, TokenPaymentByBurningOnlyAllowedOnInternalTokenError, TokenShieldedPoolIncompatibleRulesError, TooManyKeywordsError, UnknownDocumentActionTokenEffectError, UnknownDocumentCreationRestrictionModeError, UnknownGasFeesPaidByError, UnknownSecurityLevelError, UnknownStorageKeyRequirementsError, UnknownTradeModeError, UnknownTransferableTypeError};
+use dpp::consensus::basic::document::{ContestedDocumentsTemporarilyNotAllowedError, DocumentCreationNotAllowedError, DocumentFieldMaxSizeExceededError, DocumentPropertyConstraintViolatedError, DocumentPropertyMaxBytesExceededError, DocumentPropertyNotDistinctError, DocumentPropertyNotGeneratedError, DocumentReferencePreimageInvalidError, InvalidEncryptedPropertyShapeError, 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, InvalidTokenOncePerIdentityDistributionAmountError};
 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_maximum_contenders_reached_error::DocumentContestMaximumContendersReachedError;
+use dpp::consensus::state::document::referenced_document_requirement_not_met_error::ReferencedDocumentRequirementNotMetError;
+use dpp::consensus::state::document::referenced_document_removed_error::ReferencedDocumentRemovedError;
+use dpp::consensus::state::document::referenced_document_type_moderated_error::ReferencedDocumentTypeModeratedError;
+use dpp::consensus::state::document::referenced_document_type_index_only_error::ReferencedDocumentTypeIndexOnlyError;
+use dpp::consensus::state::document::referenced_document_type_not_moderated_error::ReferencedDocumentTypeNotModeratedError;
 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::basic::contract_moderation::{
+    ContractModerationReasonTooLongError, InvalidContractModerationDocumentFieldsError,
+    InvalidContractModerationReasonDocumentsError, ContractModerationSelfTargetError,
+    DocumentActionFeesWithoutModerationError,
+    InvalidContractModerationConfigError,
+};
+use dpp::consensus::basic::moderation_charter::{
+    ModerationCharterMalformedFieldError, ModerationCharterRewardSplitNotOneHundredError,
+};
+use dpp::consensus::state::contract_moderation::{
+    ContractFeeClaimNotAllowedError, ContractFeesAlreadyClaimedThisEpochError,
+    ContractFeesNothingToClaimError, ContractModeratedDocumentTypeNotYetUsableError,
+    ContractModerationAbilityNotGrantedError, ContractModerationTeamNotSeatedError,
+    DocumentNotSettledError, DocumentTypeNotDeletableOnceSettledError,
+    ModerationCharterAddedModeratorLimitReachedError, ModerationReasonNotListedError,
+    ContractTeamActionAlreadyCompletedError, ContractTeamActionAlreadySignedError,
+    ContractTeamActionDocumentChangedError, ContractTeamActionDoesNotExistError,
+    ContractTeamMemberAddedAfterDocumentError,
+    SettledDeletionNotRestorableError,
+    ContractModerationNotEnabledError, ContractModerationTargetNotAllowedError,
+    ContractModerationCounterpartyBarredError, ContractModerationTargetNotFoundError,
+    ContractModeratorIdentityNotFoundError,
+    ContractSuspensionNotInFutureError,
+    ContractUserAlreadyBannedError, ContractUserBannedError, ContractUserNotBannedError,
+    ContractUserNotSuspendedError, ContractUserNotWarnedError, ContractUserSuspendedError,
+    ContractUserWarningLimitReachedError, ContractDocumentAlreadyRestoredError,
+    ContractDocumentRemovalNotFoundError, DocumentFieldNotChangeableByModeratorsError,
+    DocumentModerationWindowElapsedError, DocumentModeratorFieldNotWritableError,
+    DocumentRestoreHashMismatchError, DocumentRestoreWindowElapsedError,
+    DocumentTypeNotDeletableByModeratorsError, IdentityNotContractModeratorError,
+};
+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,13 +154,21 @@ use dpp::consensus::state::identity::no_transfer_key_for_core_withdrawal_availab
 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, InvalidTokenPositionStateError};
+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, TokenOncePerIdentityDistributionAlreadyClaimedError, TokenShieldedPoolNotEnabledError, TokenShieldedPaymentAmountMismatchError, TokenShieldedPaymentNotRequiredError, GasFeesPaidByNotAllowedError, InconsistentGasFeesPaidByInBatchError};
 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_document_type_not_deletable_error::ReferencedDocumentTypeNotDeletableError;
 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::identity::gas_sponsor_insufficient_balance_error::GasSponsorInsufficientBalanceError;
+use dpp::consensus::state::document::document_action_fee_agreement_mismatch_error::DocumentActionFeeAgreementMismatchError;
+use dpp::consensus::state::document::document_action_fee_moderators_share_mismatch_error::DocumentActionFeeModeratorsShareMismatchError;
+use dpp::consensus::state::document::document_expired_error::DocumentExpiredError;
+use dpp::consensus::state::document::document_action_fee_agreement_not_set_error::DocumentActionFeeAgreementNotSetError;
+use dpp::consensus::state::document::document_action_fee_multiplier_not_tolerated_error::DocumentActionFeeMultiplierNotToleratedError;
 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;
@@ -105,12 +177,17 @@ use dpp::consensus::state::shielded::invalid_anchor_error::InvalidAnchorError;
 use dpp::consensus::state::shielded::invalid_shielded_proof_error::InvalidShieldedProofError;
 use dpp::consensus::state::shielded::nullifier_already_spent_error::NullifierAlreadySpentError;
 use dpp::consensus::basic::state_transition::{StateTransitionNotActiveError, TransitionOverMaxInputsError, TransitionOverMaxOutputsError, InputWitnessCountMismatchError, TransitionNoInputsError, TransitionNoOutputsError, FeeStrategyEmptyError, FeeStrategyDuplicateError, FeeStrategyIndexOutOfBoundsError, FeeStrategyTooManyStepsError, InputBelowMinimumError, OutputBelowMinimumError, InputOutputBalanceMismatchError, OutputsNotGreaterThanInputsError, WithdrawalBalanceMismatchError, InsufficientFundingAmountError, InputsNotLessThanOutputsError, OutputAddressAlsoInputError, InvalidRemainderOutputCountError, WithdrawalBelowMinAmountError, ShieldedNoActionsError, ShieldedTooManyActionsError, ShieldedEmptyProofError, ShieldedZeroAnchorError, ShieldedInvalidValueBalanceError, ShieldedEncryptedNoteSizeMismatchError, ShieldedImplicitFeeCapExceededError, ShieldedInvalidDenominationError};
+use dpp::consensus::state::document::referenced_contract_requirement_not_met_error::ReferencedContractRequirementNotMetError;
+use dpp::consensus::state::document::referenced_identity_key_requirement_not_met_error::ReferencedIdentityKeyRequirementNotMetError;
+use dpp::consensus::state::document::referenced_document_lookup_invalid_error::ReferencedDocumentLookupInvalidError;
+use dpp::consensus::state::document::referenced_document_list_invalid_error::ReferencedDocumentListInvalidError;
 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;
 use dpp::consensus::state::voting::masternode_vote_already_present_error::MasternodeVoteAlreadyPresentError;
 use dpp::consensus::state::voting::masternode_voted_too_many_times::MasternodeVotedTooManyTimesError;
 use dpp::consensus::state::voting::vote_poll_not_available_for_voting_error::VotePollNotAvailableForVotingError;
+use dpp::consensus::state::voting::vote_choice_not_allowed_for_vote_poll_error::VoteChoiceNotAllowedForVotePollError;
 use dpp::consensus::state::voting::vote_poll_not_found_error::VotePollNotFoundError;
 
 use crate::errors::consensus::basic::data_contract::{
@@ -435,6 +512,15 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
         StateError::TokenNotForDirectSale(e) => {
             generic_consensus_error!(TokenNotForDirectSale, e).into()
         }
+        StateError::TokenShieldedPoolNotEnabledError(e) => {
+            generic_consensus_error!(TokenShieldedPoolNotEnabledError, e).into()
+        }
+        StateError::TokenShieldedPaymentAmountMismatchError(e) => {
+            generic_consensus_error!(TokenShieldedPaymentAmountMismatchError, e).into()
+        }
+        StateError::TokenShieldedPaymentNotRequiredError(e) => {
+            generic_consensus_error!(TokenShieldedPaymentNotRequiredError, e).into()
+        }
         StateError::IdentityInTokenConfigurationNotFoundError(e) => {
             generic_consensus_error!(IdentityInTokenConfigurationNotFoundError, e).into()
         }
@@ -503,6 +589,210 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
         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()
+        }
+        StateError::TokenOncePerIdentityDistributionAlreadyClaimedError(e) => {
+            generic_consensus_error!(TokenOncePerIdentityDistributionAlreadyClaimedError, e).into()
+        }
+        StateError::GasFeesPaidByNotAllowedError(e) => {
+            generic_consensus_error!(GasFeesPaidByNotAllowedError, e).into()
+        }
+        StateError::InconsistentGasFeesPaidByInBatchError(e) => {
+            generic_consensus_error!(InconsistentGasFeesPaidByInBatchError, e).into()
+        }
+        StateError::DocumentActionFeeAgreementNotSetError(e) => {
+            generic_consensus_error!(DocumentActionFeeAgreementNotSetError, e).into()
+        }
+        StateError::DocumentActionFeeAgreementMismatchError(e) => {
+            generic_consensus_error!(DocumentActionFeeAgreementMismatchError, e).into()
+        }
+        StateError::DocumentActionFeeMultiplierNotToleratedError(e) => {
+            generic_consensus_error!(DocumentActionFeeMultiplierNotToleratedError, e).into()
+        }
+        StateError::GasSponsorInsufficientBalanceError(e) => {
+            generic_consensus_error!(GasSponsorInsufficientBalanceError, e).into()
+        }
+        StateError::ContractModerationNotEnabledError(e) => {
+            generic_consensus_error!(ContractModerationNotEnabledError, e).into()
+        }
+        StateError::IdentityNotContractModeratorError(e) => {
+            generic_consensus_error!(IdentityNotContractModeratorError, e).into()
+        }
+        StateError::ContractModerationTargetNotAllowedError(e) => {
+            generic_consensus_error!(ContractModerationTargetNotAllowedError, e).into()
+        }
+        StateError::ContractUserAlreadyBannedError(e) => {
+            generic_consensus_error!(ContractUserAlreadyBannedError, e).into()
+        }
+        StateError::ContractUserNotBannedError(e) => {
+            generic_consensus_error!(ContractUserNotBannedError, e).into()
+        }
+        StateError::ContractUserNotSuspendedError(e) => {
+            generic_consensus_error!(ContractUserNotSuspendedError, e).into()
+        }
+        StateError::ContractSuspensionNotInFutureError(e) => {
+            generic_consensus_error!(ContractSuspensionNotInFutureError, e).into()
+        }
+        StateError::ContractUserBannedError(e) => {
+            generic_consensus_error!(ContractUserBannedError, e).into()
+        }
+        StateError::ContractUserSuspendedError(e) => {
+            generic_consensus_error!(ContractUserSuspendedError, e).into()
+        }
+        StateError::ContractModerationTargetNotFoundError(e) => {
+            generic_consensus_error!(ContractModerationTargetNotFoundError, e).into()
+        }
+        StateError::ContractModeratorIdentityNotFoundError(e) => {
+            generic_consensus_error!(ContractModeratorIdentityNotFoundError, e).into()
+        }
+        StateError::ContractModerationCounterpartyBarredError(e) => {
+            generic_consensus_error!(ContractModerationCounterpartyBarredError, e).into()
+        }
+        StateError::ContractFeesAlreadyClaimedThisEpochError(e) => {
+            generic_consensus_error!(ContractFeesAlreadyClaimedThisEpochError, e).into()
+        }
+        StateError::ContractFeesNothingToClaimError(e) => {
+            generic_consensus_error!(ContractFeesNothingToClaimError, e).into()
+        }
+        StateError::ContractFeeClaimNotAllowedError(e) => {
+            generic_consensus_error!(ContractFeeClaimNotAllowedError, e).into()
+        }
+        StateError::ReferencedDocumentTypeNotDeletableError(e) => {
+            generic_consensus_error!(ReferencedDocumentTypeNotDeletableError, e).into()
+        }
+        StateError::DocumentTypeNotDeletableByModeratorsError(e) => {
+            generic_consensus_error!(DocumentTypeNotDeletableByModeratorsError, e).into()
+        }
+        StateError::DocumentModerationWindowElapsedError(e) => {
+            generic_consensus_error!(DocumentModerationWindowElapsedError, e).into()
+        }
+        StateError::ContractDocumentRemovalNotFoundError(e) => {
+            generic_consensus_error!(ContractDocumentRemovalNotFoundError, e).into()
+        }
+        StateError::DocumentRestoreWindowElapsedError(e) => {
+            generic_consensus_error!(DocumentRestoreWindowElapsedError, e).into()
+        }
+        StateError::DocumentRestoreHashMismatchError(e) => {
+            generic_consensus_error!(DocumentRestoreHashMismatchError, e).into()
+        }
+        StateError::ContractDocumentAlreadyRestoredError(e) => {
+            generic_consensus_error!(ContractDocumentAlreadyRestoredError, e).into()
+        }
+        StateError::ContractUserNotWarnedError(e) => {
+            generic_consensus_error!(ContractUserNotWarnedError, e).into()
+        }
+        StateError::ContractUserWarningLimitReachedError(e) => {
+            generic_consensus_error!(ContractUserWarningLimitReachedError, e).into()
+        }
+        StateError::ContractModeratedDocumentTypeNotYetUsableError(e) => {
+            generic_consensus_error!(ContractModeratedDocumentTypeNotYetUsableError, e).into()
+        }
+        StateError::VoteChoiceNotAllowedForVotePollError(e) => {
+            generic_consensus_error!(VoteChoiceNotAllowedForVotePollError, e).into()
+        }
+        StateError::ReferencedContractRequirementNotMetError(e) => {
+            generic_consensus_error!(ReferencedContractRequirementNotMetError, e).into()
+        }
+        StateError::ReferencedIdentityKeyRequirementNotMetError(e) => {
+            generic_consensus_error!(ReferencedIdentityKeyRequirementNotMetError, e).into()
+        }
+        StateError::ReferencedDocumentLookupInvalidError(e) => {
+            generic_consensus_error!(ReferencedDocumentLookupInvalidError, e).into()
+        }
+        StateError::ReferencedDocumentListInvalidError(e) => {
+            generic_consensus_error!(ReferencedDocumentListInvalidError, e).into()
+        }
+        StateError::ContractModerationAbilityNotGrantedError(e) => {
+            generic_consensus_error!(ContractModerationAbilityNotGrantedError, e).into()
+        }
+        StateError::ModerationCharterAddedModeratorLimitReachedError(e) => {
+            generic_consensus_error!(ModerationCharterAddedModeratorLimitReachedError, e).into()
+        }
+        StateError::ModerationReasonNotListedError(e) => {
+            generic_consensus_error!(ModerationReasonNotListedError, e).into()
+        }
+        StateError::DocumentTypeNotDeletableOnceSettledError(e) => {
+            generic_consensus_error!(DocumentTypeNotDeletableOnceSettledError, e).into()
+        }
+        StateError::ContractModerationTeamNotSeatedError(e) => {
+            generic_consensus_error!(ContractModerationTeamNotSeatedError, e).into()
+        }
+        StateError::DocumentNotSettledError(e) => {
+            generic_consensus_error!(DocumentNotSettledError, e).into()
+        }
+        StateError::ContractTeamActionDoesNotExistError(e) => {
+            generic_consensus_error!(ContractTeamActionDoesNotExistError, e).into()
+        }
+        StateError::ContractTeamActionAlreadySignedError(e) => {
+            generic_consensus_error!(ContractTeamActionAlreadySignedError, e).into()
+        }
+        StateError::SettledDeletionNotRestorableError(e) => {
+            generic_consensus_error!(SettledDeletionNotRestorableError, e).into()
+        }
+        StateError::ContractTeamActionAlreadyCompletedError(e) => {
+            generic_consensus_error!(ContractTeamActionAlreadyCompletedError, e).into()
+        }
+        StateError::ContractTeamActionDocumentChangedError(e) => {
+            generic_consensus_error!(ContractTeamActionDocumentChangedError, e).into()
+        }
+        StateError::ContractTeamMemberAddedAfterDocumentError(e) => {
+            generic_consensus_error!(ContractTeamMemberAddedAfterDocumentError, e).into()
+        }
+        StateError::DocumentActionFeeModeratorsShareMismatchError(e) => {
+            generic_consensus_error!(DocumentActionFeeModeratorsShareMismatchError, e).into()
+        }
+        StateError::DocumentExpiredError(e) => {
+            generic_consensus_error!(DocumentExpiredError, e).into()
+        }
+        StateError::DocumentContestMaximumContendersReachedError(e) => {
+            generic_consensus_error!(DocumentContestMaximumContendersReachedError, e).into()
+        }
+        StateError::DocumentFieldNotChangeableByModeratorsError(e) => {
+            generic_consensus_error!(DocumentFieldNotChangeableByModeratorsError, e).into()
+        }
+        StateError::DocumentModeratorFieldNotWritableError(e) => {
+            generic_consensus_error!(DocumentModeratorFieldNotWritableError, e).into()
+        }
+        StateError::ReferencedDocumentRequirementNotMetError(e) => {
+            generic_consensus_error!(ReferencedDocumentRequirementNotMetError, e).into()
+        }
+        StateError::ReferencedDocumentTypeNotModeratedError(e) => {
+            generic_consensus_error!(ReferencedDocumentTypeNotModeratedError, e).into()
+        }
+        StateError::ReferencedDocumentTypeModeratedError(e) => {
+            generic_consensus_error!(ReferencedDocumentTypeModeratedError, e).into()
+        }
+        StateError::ReferencedDocumentRemovedError(e) => {
+            generic_consensus_error!(ReferencedDocumentRemovedError, e).into()
+        }
+        StateError::ReferencedDocumentTypeIndexOnlyError(e) => {
+            generic_consensus_error!(ReferencedDocumentTypeIndexOnlyError, e).into()
+        }
     }
 }
 
@@ -659,6 +949,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()
         }
@@ -756,6 +1049,9 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
         BasicError::DocumentFieldMaxSizeExceededError(e) => {
             generic_consensus_error!(DocumentFieldMaxSizeExceededError, e).into()
         }
+        BasicError::DocumentPropertyNotDistinctError(e) => {
+            generic_consensus_error!(DocumentPropertyNotDistinctError, e).into()
+        }
         BasicError::ContestedUniqueIndexWithUniqueIndexError(e) => {
             generic_consensus_error!(ContestedUniqueIndexWithUniqueIndexError, e).into()
         }
@@ -917,6 +1213,12 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
             generic_consensus_error!(InvalidTokenDistributionTimeIntervalNotMinuteAlignedError, e)
                 .into()
         }
+        BasicError::InvalidTokenDistributionEpochIntervalTooShortError(e) => {
+            generic_consensus_error!(InvalidTokenDistributionEpochIntervalTooShortError, e).into()
+        }
+        BasicError::InvalidTokenOncePerIdentityDistributionAmountError(e) => {
+            generic_consensus_error!(InvalidTokenOncePerIdentityDistributionAmountError, e).into()
+        }
         BasicError::RedundantDocumentPaidForByTokenWithContractId(e) => {
             generic_consensus_error!(RedundantDocumentPaidForByTokenWithContractId, e).into()
         }
@@ -1016,6 +1318,88 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
         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()
+        }
+        BasicError::PreProgrammedDistributionAmountOverLimitError(e) => {
+            generic_consensus_error!(PreProgrammedDistributionAmountOverLimitError, e).into()
+        }
+        BasicError::InvalidContractModerationConfigError(e) => {
+            generic_consensus_error!(InvalidContractModerationConfigError, e).into()
+        }
+        BasicError::ContractModerationSelfTargetError(e) => {
+            generic_consensus_error!(ContractModerationSelfTargetError, e).into()
+        }
+        BasicError::DocumentActionFeesWithoutModerationError(e) => {
+            generic_consensus_error!(DocumentActionFeesWithoutModerationError, e).into()
+        }
+        BasicError::ContractModerationReasonTooLongError(e) => {
+            generic_consensus_error!(ContractModerationReasonTooLongError, e).into()
+        }
+        BasicError::ModerationCharterMalformedFieldError(e) => {
+            generic_consensus_error!(ModerationCharterMalformedFieldError, e).into()
+        }
+        BasicError::ModerationCharterRewardSplitNotOneHundredError(e) => {
+            generic_consensus_error!(ModerationCharterRewardSplitNotOneHundredError, e).into()
+        }
+        BasicError::InvalidContractModerationReasonDocumentsError(e) => {
+            generic_consensus_error!(InvalidContractModerationReasonDocumentsError, e).into()
+        }
+        BasicError::InvalidEncryptedPropertyShapeError(e) => {
+            generic_consensus_error!(InvalidEncryptedPropertyShapeError, e).into()
+        }
+        BasicError::DocumentPropertyMaxBytesExceededError(e) => {
+            generic_consensus_error!(DocumentPropertyMaxBytesExceededError, e).into()
+        }
+        BasicError::DocumentPropertyConstraintViolatedError(e) => {
+            generic_consensus_error!(DocumentPropertyConstraintViolatedError, e).into()
+        }
+        BasicError::DocumentPropertyNotGeneratedError(e) => {
+            generic_consensus_error!(DocumentPropertyNotGeneratedError, e).into()
+        }
+        BasicError::InvalidContractModerationDocumentFieldsError(e) => {
+            generic_consensus_error!(InvalidContractModerationDocumentFieldsError, e).into()
+        }
+        BasicError::DocumentReferencePreimageInvalidError(e) => {
+            generic_consensus_error!(DocumentReferencePreimageInvalidError, e).into()
+        }
+        BasicError::TokenShieldedPoolIncompatibleRulesError(e) => {
+            generic_consensus_error!(TokenShieldedPoolIncompatibleRulesError, e).into()
+        }
     }
 }
 
@@ -1049,9 +1433,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/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())
     }
 }