@dashevo/wasm-dpp 4.2.0-dev.1 → 4.2.0-dev.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "4.2.0-dev.1",
+  "version": "4.2.0-dev.11",
   "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.2.0-dev.1",
+    "@dashevo/dpns-contract": "4.2.0-dev.11",
     "@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/consensus_error.rs

@@ -62,12 +62,12 @@ 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;
@@ -92,6 +92,13 @@ 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::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;
@@ -138,6 +145,7 @@ use crate::errors::consensus::state::document::{
     DocumentAlreadyPresentErrorWasm, DocumentNotFoundErrorWasm, DocumentOwnerIdMismatchErrorWasm,
     DocumentTimestampWindowViolationErrorWasm, DocumentTimestampsMismatchErrorWasm,
     DuplicateUniqueIndexErrorWasm, InvalidDocumentRevisionErrorWasm,
+    ReferencedEntityNotFoundErrorWasm,
 };
 use crate::errors::consensus::state::identity::{
     IdentityAlreadyExistsErrorWasm, IdentityPublicKeyIsDisabledErrorWasm,
@@ -471,6 +479,30 @@ 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()
+        }
     }
 }
 
@@ -885,6 +917,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()
         }
@@ -981,6 +1016,9 @@ 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()
+        }
     }
 }
 

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/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,7 +84,9 @@ 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",
                 )),
             },

package/src/utils.rs

@@ -5,7 +5,7 @@ use anyhow::{anyhow, bail, Context};
 use dpp::{consensus::ConsensusError, ProtocolError};
 
 use dpp::platform_value::Value;
-use dpp::serialization::PlatformDeserializable;
+use dpp::serialization::PlatformDeserializableUntrusted;
 use js_sys::{Function, Uint8Array};
 use serde::de::DeserializeOwned;
 use serde_json::Value as JsonValue;
@@ -355,7 +355,7 @@ pub(crate) fn consensus_errors_from_buffers(
             .to_vec()
         })
         .map(|error_bytes| {
-            ConsensusError::deserialize_from_bytes(&error_bytes.to_vec()).with_js_error()
+            ConsensusError::deserialize_from_bytes_untrusted(&error_bytes.to_vec()).with_js_error()
         })
         .collect::<Result<Vec<ConsensusError>, JsValue>>()
 }