@dashevo/wasm-dpp 5.0.0-beta.1 → 5.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.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": "5.0.0-beta.1",
+    "@dashevo/dpns-contract": "5.0.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

@@ -261,7 +261,11 @@ impl DataContractCreateTransitionWasm {
         let bls_adapter = BlsAdapter(bls);
 
         let verification_result = StateTransition::DataContractCreate(self.0.clone())
-            .verify_identity_signed_signature(&identity_public_key.to_owned().into(), &bls_adapter);
+            .verify_identity_signed_signature(
+                &identity_public_key.to_owned().into(),
+                &bls_adapter,
+                PlatformVersion::latest(),
+            );
 
         match verification_result {
             Ok(()) => Ok(true),

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

@@ -265,7 +265,11 @@ impl DataContractUpdateTransitionWasm {
         let bls_adapter = BlsAdapter(bls);
 
         let verification_result = StateTransition::DataContractUpdate(self.0.clone())
-            .verify_identity_signed_signature(&identity_public_key.to_owned().into(), &bls_adapter);
+            .verify_identity_signed_signature(
+                &identity_public_key.to_owned().into(),
+                &bls_adapter,
+                PlatformVersion::latest(),
+            );
 
         match verification_result {
             Ok(()) => Ok(true),

package/src/document/factory.rs

@@ -178,7 +178,7 @@ impl DocumentFactoryWASM {
                                 .document_type_for_name(extended_document.document_type_name())
                                 .expect("should be able to get document type"),
                             extended_document.entropy().to_owned(),
-                            extended_document.token_payment_info(),
+                            extended_document.token_payment_info_ref().clone(),
                         )
                     })
                     .collect();

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

@@ -33,6 +33,7 @@ use crate::batch_transition::batched_transition::BatchedTransitionWasm;
 use crate::batch_transition::document_transition::DocumentTransitionWasm;
 use crate::batch_transition::token_transition::TokenTransitionWasm;
 use dpp::state_transition::StateTransitionIdentitySigned;
+use dpp::version::PlatformVersion;
 
 pub mod batched_transition;
 pub mod document_transition;
@@ -340,7 +341,11 @@ impl BatchTransitionWasm {
         let bls_adapter = BlsAdapter(bls);
 
         let verification_result = StateTransition::Batch(self.0.clone())
-            .verify_identity_signed_signature(&identity_public_key.to_owned().into(), &bls_adapter);
+            .verify_identity_signed_signature(
+                &identity_public_key.to_owned().into(),
+                &bls_adapter,
+                PlatformVersion::latest(),
+            );
 
         match verification_result {
             Ok(()) => Ok(true),

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

@@ -44,6 +44,13 @@ pub enum TokenTransitionType {
     ConfigUpdate,
     DirectPurchase,
     SetPriceForDirectPurchase,
+    Shield,
+    Unshield,
+    ShieldedTransfer,
+    MintToPool,
+    BurnFromPool,
+    ClaimToPool,
+    DirectPurchaseToPool,
 }
 
 impl From<&TokenTransition> for TokenTransitionType {
@@ -62,6 +69,13 @@ impl From<&TokenTransition> for TokenTransitionType {
             TokenTransition::SetPriceForDirectPurchase(_) => {
                 TokenTransitionType::SetPriceForDirectPurchase
             }
+            TokenTransition::Shield(_) => TokenTransitionType::Shield,
+            TokenTransition::Unshield(_) => TokenTransitionType::Unshield,
+            TokenTransition::ShieldedTransfer(_) => TokenTransitionType::ShieldedTransfer,
+            TokenTransition::MintToPool(_) => TokenTransitionType::MintToPool,
+            TokenTransition::BurnFromPool(_) => TokenTransitionType::BurnFromPool,
+            TokenTransition::ClaimToPool(_) => TokenTransitionType::ClaimToPool,
+            TokenTransition::DirectPurchaseToPool(_) => TokenTransitionType::DirectPurchaseToPool,
         }
     }
 }
@@ -120,35 +134,48 @@ impl TokenTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=toTransition)]
-    pub fn to_transition(&self) -> JsValue {
+    pub fn to_transition(&self) -> Result<JsValue, JsValue> {
         match &self.0 {
-            TokenTransition::Burn(burn) => TokenBurnTransitionWasm::from(burn.clone()).into(),
-            TokenTransition::Mint(mint) => TokenMintTransitionWasm::from(mint.clone()).into(),
+            TokenTransition::Burn(burn) => Ok(TokenBurnTransitionWasm::from(burn.clone()).into()),
+            TokenTransition::Mint(mint) => Ok(TokenMintTransitionWasm::from(mint.clone()).into()),
             TokenTransition::Transfer(transfer) => {
-                TokenTransferTransitionWasm::from(transfer.clone()).into()
+                Ok(TokenTransferTransitionWasm::from(transfer.clone()).into())
             }
             TokenTransition::Freeze(freeze) => {
-                TokenFreezeTransitionWasm::from(freeze.clone()).into()
+                Ok(TokenFreezeTransitionWasm::from(freeze.clone()).into())
             }
             TokenTransition::Unfreeze(unfreeze) => {
-                TokenUnfreezeTransitionWasm::from(unfreeze.clone()).into()
-            }
-            TokenTransition::DestroyFrozenFunds(destroy_frozen_funds) => {
-                TokenDestroyFrozenFundsTransitionWasm::from(destroy_frozen_funds.clone()).into()
+                Ok(TokenUnfreezeTransitionWasm::from(unfreeze.clone()).into())
             }
+            TokenTransition::DestroyFrozenFunds(destroy_frozen_funds) => Ok(
+                TokenDestroyFrozenFundsTransitionWasm::from(destroy_frozen_funds.clone()).into(),
+            ),
             TokenTransition::EmergencyAction(emergency_action) => {
-                TokenEmergencyActionTransitionWasm::from(emergency_action.clone()).into()
+                Ok(TokenEmergencyActionTransitionWasm::from(emergency_action.clone()).into())
             }
             TokenTransition::ConfigUpdate(config_update) => {
-                TokenConfigUpdateTransitionWasm::from(config_update.clone()).into()
+                Ok(TokenConfigUpdateTransitionWasm::from(config_update.clone()).into())
+            }
+            TokenTransition::Claim(claim) => {
+                Ok(TokenClaimTransitionWasm::from(claim.clone()).into())
             }
-            TokenTransition::Claim(claim) => TokenClaimTransitionWasm::from(claim.clone()).into(),
             TokenTransition::DirectPurchase(direct_purchase) => {
-                TokenDirectPurchaseTransitionWasm::from(direct_purchase.clone()).into()
+                Ok(TokenDirectPurchaseTransitionWasm::from(direct_purchase.clone()).into())
             }
             TokenTransition::SetPriceForDirectPurchase(set_price) => {
-                TokenSetPriceForDirectPurchaseTransitionWasm::from(set_price.clone()).into()
+                Ok(TokenSetPriceForDirectPurchaseTransitionWasm::from(set_price.clone()).into())
             }
+            // The shielded-pool token transition kinds have no wrapper class here, so there is
+            // nothing to hand back; wasm-dpp2 is the binding that exposes them.
+            TokenTransition::Shield(_)
+            | TokenTransition::Unshield(_)
+            | TokenTransition::ShieldedTransfer(_)
+            | TokenTransition::MintToPool(_)
+            | TokenTransition::BurnFromPool(_)
+            | TokenTransition::ClaimToPool(_)
+            | TokenTransition::DirectPurchaseToPool(_) => Err(JsValue::from_str(
+                "shielded and pool-backed token transitions are not supported in wasm-dpp TokenTransition; use wasm-dpp2",
+            )),
         }
     }
 }

package/src/errors/consensus/consensus_error.rs

@@ -66,7 +66,7 @@ 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, PreProgrammedDistributionAmountOverLimitError, RedundantDocumentPaidForByTokenWithContractId, TokenPaymentByBurningOnlyAllowedOnInternalTokenError, TooManyKeywordsError, UnknownDocumentActionTokenEffectError, UnknownDocumentCreationRestrictionModeError, UnknownGasFeesPaidByError, UnknownSecurityLevelError, UnknownStorageKeyRequirementsError, UnknownTradeModeError, UnknownTransferableTypeError};
+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};
@@ -82,6 +82,7 @@ use dpp::consensus::state::document::document_contest_maximum_contenders_reached
 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;
@@ -112,6 +113,7 @@ use dpp::consensus::state::contract_moderation::{
     ModerationCharterAddedModeratorLimitReachedError, ModerationReasonNotListedError,
     ContractTeamActionAlreadyCompletedError, ContractTeamActionAlreadySignedError,
     ContractTeamActionDocumentChangedError, ContractTeamActionDoesNotExistError,
+    ContractTeamMemberAddedAfterDocumentError,
     SettledDeletionNotRestorableError,
     ContractModerationNotEnabledError, ContractModerationTargetNotAllowedError,
     ContractModerationCounterpartyBarredError, ContractModerationTargetNotFoundError,
@@ -152,7 +154,7 @@ 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, TokenOncePerIdentityDistributionAlreadyClaimedError};
+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;
@@ -162,7 +164,6 @@ use dpp::consensus::state::document::referenced_document_property_agreement_inva
 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::token::{GasFeesPaidByNotAllowedError, InconsistentGasFeesPaidByInBatchError};
 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;
@@ -511,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()
         }
@@ -750,6 +760,9 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
         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()
         }
@@ -777,6 +790,9 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
         StateError::ReferencedDocumentRemovedError(e) => {
             generic_consensus_error!(ReferencedDocumentRemovedError, e).into()
         }
+        StateError::ReferencedDocumentTypeIndexOnlyError(e) => {
+            generic_consensus_error!(ReferencedDocumentTypeIndexOnlyError, e).into()
+        }
     }
 }
 
@@ -1381,6 +1397,9 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
         BasicError::DocumentReferencePreimageInvalidError(e) => {
             generic_consensus_error!(DocumentReferencePreimageInvalidError, e).into()
         }
+        BasicError::TokenShieldedPoolIncompatibleRulesError(e) => {
+            generic_consensus_error!(TokenShieldedPoolIncompatibleRulesError, e).into()
+        }
     }
 }
 

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

@@ -482,7 +482,11 @@ impl IdentityUpdateTransitionWasm {
         let bls_adapter = BlsAdapter(bls);
 
         let verification_result = StateTransition::IdentityUpdate(self.0.clone())
-            .verify_identity_signed_signature(&identity_public_key.to_owned().into(), &bls_adapter);
+            .verify_identity_signed_signature(
+                &identity_public_key.to_owned().into(),
+                &bls_adapter,
+                PlatformVersion::latest(),
+            );
 
         match verification_result {
             Ok(()) => Ok(true),

package/src/state_transition/state_transition_factory.rs

@@ -86,6 +86,9 @@ impl StateTransitionFactoryWasm {
                 | StateTransition::ShieldedWithdrawal(_)
                 | StateTransition::IdentityCreateFromShieldedPool(_)
                 | StateTransition::ShieldFromIdentity(_)
+                | StateTransition::TokenShieldedTransferWithShieldedFee(_)
+                | StateTransition::TokenUnshieldWithShieldedFee(_)
+                | StateTransition::TokenPurchaseFromShieldedPool(_)
                 | StateTransition::IdentityTopUpFromShieldedPool(_) => Err(JsValue::from_str(
                     "shielded transitions are not yet supported in wasm-dpp StateTransitionFactory",
                 )),