dpp/errors/consensus/state/
state_error.rs

1use crate::errors::ProtocolError;
2use bincode::{Decode, DecodeUntrusted, Encode};
3use platform_serialization_derive::{
4    PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize,
5};
6use thiserror::Error;
7
8use crate::consensus::state::address_funds::{AddressDoesNotExistError, AddressInvalidNonceError, AddressNotEnoughFundsError, AddressesNotEnoughFundsError};
9use crate::consensus::state::shielded::insufficient_pool_notes_error::InsufficientPoolNotesError;
10use crate::consensus::state::shielded::insufficient_shielded_fee_error::InsufficientShieldedFeeError;
11use crate::consensus::state::shielded::invalid_anchor_error::InvalidAnchorError;
12use crate::consensus::state::shielded::invalid_shielded_proof_error::InvalidShieldedProofError;
13use crate::consensus::state::shielded::nullifier_already_spent_error::NullifierAlreadySpentError;
14use crate::consensus::state::contract_moderation::{
15    ContractModeratedDocumentTypeNotYetUsableError, ContractModerationAbilityNotGrantedError,
16    ContractModerationTeamNotSeatedError, DocumentNotSettledError,
17    ContractTeamActionAlreadyCompletedError, ContractTeamActionAlreadySignedError,
18    ContractTeamActionDocumentChangedError, ContractTeamActionDoesNotExistError,
19    ContractTeamMemberAddedAfterDocumentError,
20    DocumentTypeNotDeletableOnceSettledError, SettledDeletionNotRestorableError,
21    ModerationCharterAddedModeratorLimitReachedError, ModerationReasonNotListedError,
22    ContractModerationNotEnabledError, ContractModerationTargetNotAllowedError,
23    ContractFeeClaimNotAllowedError, ContractFeesAlreadyClaimedThisEpochError,
24    ContractFeesNothingToClaimError, ContractModerationCounterpartyBarredError,
25    ContractModerationTargetNotFoundError,
26    ContractModeratorIdentityNotFoundError,
27    ContractSuspensionNotInFutureError, ContractUserAlreadyBannedError, ContractUserBannedError,
28    ContractUserNotBannedError, ContractUserNotSuspendedError, ContractUserNotWarnedError,
29    ContractUserSuspendedError, ContractUserWarningLimitReachedError,
30    ContractDocumentAlreadyRestoredError, ContractDocumentRemovalNotFoundError,
31    DocumentFieldNotChangeableByModeratorsError, DocumentModerationWindowElapsedError,
32    DocumentModeratorFieldNotWritableError, DocumentRestoreHashMismatchError,
33    DocumentRestoreWindowElapsedError, DocumentTypeNotDeletableByModeratorsError,
34    IdentityNotContractModeratorError,
35};
36use crate::consensus::state::contract_group::{
37    ContractGroupAlreadyExistsError, ContractGroupNotFoundError,
38    ContractGroupAdminNotFoundError, IdentityNotContractGroupOwnerOrAdminError,
39};
40use crate::consensus::state::data_contract::data_contract_already_present_error::DataContractAlreadyPresentError;
41use crate::consensus::state::data_contract::data_contract_config_update_error::DataContractConfigUpdateError;
42use crate::consensus::state::data_contract::data_contract_is_readonly_error::DataContractIsReadonlyError;
43use crate::consensus::state::data_trigger::DataTriggerError;
44use crate::consensus::state::document::document_action_fee_agreement_mismatch_error::DocumentActionFeeAgreementMismatchError;
45use crate::consensus::state::document::document_action_fee_moderators_share_mismatch_error::DocumentActionFeeModeratorsShareMismatchError;
46use crate::consensus::state::document::document_expired_error::DocumentExpiredError;
47use crate::consensus::state::document::document_action_fee_agreement_not_set_error::DocumentActionFeeAgreementNotSetError;
48use crate::consensus::state::document::document_action_fee_multiplier_not_tolerated_error::DocumentActionFeeMultiplierNotToleratedError;
49use crate::consensus::state::document::document_already_present_error::DocumentAlreadyPresentError;
50use crate::consensus::state::document::document_not_found_error::DocumentNotFoundError;
51use crate::consensus::state::document::document_owner_id_mismatch_error::DocumentOwnerIdMismatchError;
52use crate::consensus::state::document::document_timestamp_window_violation_error::DocumentTimestampWindowViolationError;
53use crate::consensus::state::document::document_timestamps_mismatch_error::DocumentTimestampsMismatchError;
54use crate::consensus::state::document::duplicate_unique_index_error::DuplicateUniqueIndexError;
55use crate::consensus::state::document::invalid_document_revision_error::InvalidDocumentRevisionError;
56use crate::consensus::state::identity::duplicated_identity_public_key_id_state_error::DuplicatedIdentityPublicKeyIdStateError;
57use crate::consensus::state::identity::duplicated_identity_public_key_state_error::DuplicatedIdentityPublicKeyStateError;
58use crate::consensus::state::identity::identity_public_key_is_disabled_error::IdentityPublicKeyIsDisabledError;
59use crate::consensus::state::identity::identity_public_key_is_read_only_error::IdentityPublicKeyIsReadOnlyError;
60use crate::consensus::state::identity::invalid_identity_public_key_id_error::InvalidIdentityPublicKeyIdError;
61use crate::consensus::state::identity::invalid_identity_revision_error::InvalidIdentityRevisionError;
62use crate::consensus::state::identity::max_identity_public_key_limit_reached_error::MaxIdentityPublicKeyLimitReachedError;
63use crate::consensus::state::identity::missing_identity_public_key_ids_error::MissingIdentityPublicKeyIdsError;
64use crate::consensus::state::identity::{IdentityAlreadyExistsError, IdentityInsufficientBalanceError, RecipientIdentityDoesNotExistError};
65use crate::consensus::ConsensusError;
66use crate::consensus::state::data_contract::data_contract_not_found_error::DataContractNotFoundError;
67use crate::consensus::state::data_contract::data_contract_update_action_not_allowed_error::DataContractUpdateActionNotAllowedError;
68use crate::consensus::state::data_contract::data_contract_update_permission_error::DataContractUpdatePermissionError;
69use crate::consensus::state::data_contract::document_type_update_error::DocumentTypeUpdateError;
70use crate::consensus::state::document::document_contest_currently_locked_error::DocumentContestCurrentlyLockedError;
71use crate::consensus::state::document::document_contest_document_with_same_id_already_present_error::DocumentContestDocumentWithSameIdAlreadyPresentError;
72use crate::consensus::state::document::document_contest_identity_already_contestant::DocumentContestIdentityAlreadyContestantError;
73use crate::consensus::state::document::document_contest_maximum_contenders_reached_error::DocumentContestMaximumContendersReachedError;
74use crate::consensus::state::document::document_contest_index_mismatch_error::DocumentContestIndexMismatchError;
75use crate::consensus::state::document::document_contest_not_joinable_error::DocumentContestNotJoinableError;
76use crate::consensus::state::document::document_contest_not_paid_for_error::DocumentContestNotPaidForError;
77use crate::consensus::state::document::document_contest_not_required_error::DocumentContestNotRequiredError;
78use crate::consensus::state::document::referenced_document_type_deletable_error::ReferencedDocumentTypeDeletableError;
79use crate::consensus::state::document::referenced_document_type_not_deletable_error::ReferencedDocumentTypeNotDeletableError;
80use crate::consensus::state::document::referenced_document_type_not_found_error::ReferencedDocumentTypeNotFoundError;
81use crate::consensus::state::document::referenced_contract_requirement_not_met_error::ReferencedContractRequirementNotMetError;
82use crate::consensus::state::document::referenced_document_requirement_not_met_error::ReferencedDocumentRequirementNotMetError;
83use crate::consensus::state::document::referenced_document_removed_error::ReferencedDocumentRemovedError;
84use crate::consensus::state::document::referenced_document_type_moderated_error::ReferencedDocumentTypeModeratedError;
85use crate::consensus::state::document::referenced_document_type_index_only_error::ReferencedDocumentTypeIndexOnlyError;
86use crate::consensus::state::document::document_delete_constraint_violated_error::DocumentDeleteConstraintViolatedError;
87use crate::consensus::state::document::referenced_document_type_not_moderated_error::ReferencedDocumentTypeNotModeratedError;
88use crate::consensus::state::document::referenced_document_lookup_invalid_error::ReferencedDocumentLookupInvalidError;
89use crate::consensus::state::document::referenced_document_list_invalid_error::ReferencedDocumentListInvalidError;
90use crate::consensus::state::document::referenced_entity_not_found_error::ReferencedEntityNotFoundError;
91use crate::consensus::state::document::referenced_identity_key_disabled_error::ReferencedIdentityKeyDisabledError;
92use crate::consensus::state::document::referenced_identity_key_not_found_error::ReferencedIdentityKeyNotFoundError;
93use crate::consensus::state::document::referenced_identity_key_requirement_not_met_error::ReferencedIdentityKeyRequirementNotMetError;
94use crate::consensus::state::document::referenced_document_property_agreement_invalid_error::ReferencedDocumentPropertyAgreementInvalidError;
95use crate::consensus::state::document::referenced_document_property_mismatch_error::ReferencedDocumentPropertyMismatchError;
96use crate::consensus::state::document::referenced_key_id_property_invalid_error::ReferencedKeyIdPropertyInvalidError;
97use crate::consensus::state::document::document_incorrect_purchase_price_error::DocumentIncorrectPurchasePriceError;
98use crate::consensus::state::document::document_not_for_sale_error::DocumentNotForSaleError;
99use crate::consensus::state::group::{GroupActionAlreadyCompletedError, GroupActionAlreadySignedByIdentityError, GroupActionDoesNotExistError, IdentityMemberOfGroupNotFoundError, IdentityNotMemberOfGroupError, ModificationOfGroupActionMainParametersNotPermittedError};
100use crate::consensus::state::identity::identity_for_token_configuration_not_found_error::IdentityInTokenConfigurationNotFoundError;
101use crate::consensus::state::identity::identity_public_key_already_exists_for_unique_contract_bounds_error::IdentityPublicKeyAlreadyExistsForUniqueContractBoundsError;
102use crate::consensus::state::identity::identity_public_key_already_expired_error::IdentityPublicKeyAlreadyExpiredError;
103use crate::consensus::state::identity::identity_public_key_budget_exceeded_error::IdentityPublicKeyBudgetExceededError;
104use crate::consensus::state::identity::identity_public_key_limit_not_raised_error::IdentityPublicKeyLimitNotRaisedError;
105use crate::consensus::state::document::document_immutable_property_changed_error::DocumentImmutablePropertyChangedError;
106use crate::consensus::state::identity::identity_public_key_limit_not_set_error::IdentityPublicKeyLimitNotSetError;
107use crate::consensus::state::identity::gas_sponsor_insufficient_balance_error::GasSponsorInsufficientBalanceError;
108use crate::consensus::state::token::{GasFeesPaidByNotAllowedError, InconsistentGasFeesPaidByInBatchError};
109use crate::consensus::state::identity::identity_to_freeze_does_not_exist_error::IdentityToFreezeDoesNotExistError;
110use crate::consensus::state::identity::invalid_identity_contract_nonce_error::InvalidIdentityNonceError;
111use crate::consensus::state::identity::missing_transfer_key_error::MissingTransferKeyError;
112use crate::consensus::state::identity::no_transfer_key_for_core_withdrawal_available_error::NoTransferKeyForCoreWithdrawalAvailableError;
113use crate::consensus::state::prefunded_specialized_balances::prefunded_specialized_balance_insufficient_error::PrefundedSpecializedBalanceInsufficientError;
114use crate::consensus::state::prefunded_specialized_balances::prefunded_specialized_balance_not_found_error::PrefundedSpecializedBalanceNotFoundError;
115use crate::consensus::state::token::{IdentityDoesNotHaveEnoughTokenBalanceError, IdentityTokenAccountFrozenError, IdentityTokenAccountNotFrozenError, InvalidGroupPositionError, NewAuthorizedActionTakerGroupDoesNotExistError, NewAuthorizedActionTakerIdentityDoesNotExistError, NewAuthorizedActionTakerMainGroupNotSetError, NewTokensDestinationIdentityDoesNotExistError, TokenMintPastMaxSupplyError, TokenSettingMaxSupplyToLessThanCurrentSupplyError, UnauthorizedTokenActionError, IdentityTokenAccountAlreadyFrozenError, TokenAlreadyPausedError, TokenIsPausedError, TokenNotPausedError, InvalidTokenClaimPropertyMismatch, InvalidTokenClaimNoCurrentRewards, InvalidTokenClaimWrongClaimant, PreProgrammedDistributionTimestampInPastError, TokenTransferRecipientIdentityNotExistError, IdentityHasNotAgreedToPayRequiredTokenAmountError, RequiredTokenPaymentInfoNotSetError, IdentityTryingToPayWithWrongTokenError, TokenDirectPurchaseUserPriceTooLow, TokenAmountUnderMinimumSaleAmount, TokenNotForDirectSale, InvalidTokenPositionStateError, TokenOncePerIdentityDistributionAlreadyClaimedError, TokenShieldedPoolNotEnabledError, TokenShieldedPaymentAmountMismatchError, TokenShieldedPaymentNotRequiredError};
116use crate::consensus::state::voting::masternode_incorrect_voter_identity_id_error::MasternodeIncorrectVoterIdentityIdError;
117use crate::consensus::state::voting::masternode_incorrect_voting_address_error::MasternodeIncorrectVotingAddressError;
118use crate::consensus::state::voting::masternode_not_found_error::MasternodeNotFoundError;
119use crate::consensus::state::voting::masternode_vote_already_present_error::MasternodeVoteAlreadyPresentError;
120use crate::consensus::state::voting::masternode_voted_too_many_times::MasternodeVotedTooManyTimesError;
121use crate::consensus::state::voting::vote_poll_not_available_for_voting_error::VotePollNotAvailableForVotingError;
122use crate::consensus::state::voting::vote_choice_not_allowed_for_vote_poll_error::VoteChoiceNotAllowedForVotePollError;
123use crate::consensus::state::voting::vote_poll_not_found_error::VotePollNotFoundError;
124
125use super::document::document_timestamps_are_equal_error::DocumentTimestampsAreEqualError;
126
127#[derive(
128    Error,
129    Debug,
130    PartialEq,
131    Encode,
132    Decode,
133    PlatformSerialize,
134    PlatformDeserializeTrusted,
135    PlatformDeserializeUntrusted,
136    Clone,
137    DecodeUntrusted,
138)]
139pub enum StateError {
140    /*
141
142    DO NOT CHANGE ORDER OF VARIANTS WITHOUT INTRODUCING OF NEW VERSION
143
144    */
145    #[error(transparent)]
146    DataContractAlreadyPresentError(DataContractAlreadyPresentError),
147
148    #[error(transparent)]
149    DataTriggerError(DataTriggerError),
150
151    #[error(transparent)]
152    DocumentAlreadyPresentError(DocumentAlreadyPresentError),
153
154    #[error(transparent)]
155    DocumentContestCurrentlyLockedError(DocumentContestCurrentlyLockedError),
156
157    #[error(transparent)]
158    DocumentContestNotJoinableError(DocumentContestNotJoinableError),
159
160    #[error(transparent)]
161    DocumentContestIdentityAlreadyContestantError(DocumentContestIdentityAlreadyContestantError),
162
163    #[error(transparent)]
164    DocumentContestNotPaidForError(DocumentContestNotPaidForError),
165
166    #[error(transparent)]
167    DocumentContestDocumentWithSameIdAlreadyPresentError(
168        DocumentContestDocumentWithSameIdAlreadyPresentError,
169    ),
170
171    #[error(transparent)]
172    DocumentNotFoundError(DocumentNotFoundError),
173
174    #[error(transparent)]
175    DocumentNotForSaleError(DocumentNotForSaleError),
176
177    #[error(transparent)]
178    DocumentIncorrectPurchasePriceError(DocumentIncorrectPurchasePriceError),
179
180    #[error(transparent)]
181    DocumentOwnerIdMismatchError(DocumentOwnerIdMismatchError),
182
183    #[error(transparent)]
184    DocumentTimestampsMismatchError(DocumentTimestampsMismatchError),
185
186    #[error(transparent)]
187    DocumentTimestampWindowViolationError(DocumentTimestampWindowViolationError),
188
189    #[error(transparent)]
190    DuplicateUniqueIndexError(DuplicateUniqueIndexError),
191
192    #[error(transparent)]
193    InvalidDocumentRevisionError(InvalidDocumentRevisionError),
194
195    #[error(transparent)]
196    IdentityAlreadyExistsError(IdentityAlreadyExistsError),
197
198    #[error(transparent)]
199    IdentityPublicKeyAlreadyExistsForUniqueContractBoundsError(
200        IdentityPublicKeyAlreadyExistsForUniqueContractBoundsError,
201    ),
202
203    #[error(transparent)]
204    IdentityPublicKeyIsReadOnlyError(IdentityPublicKeyIsReadOnlyError),
205
206    #[error(transparent)]
207    MissingIdentityPublicKeyIdsError(MissingIdentityPublicKeyIdsError),
208
209    #[error(transparent)]
210    MissingTransferKeyError(MissingTransferKeyError),
211
212    #[error(transparent)]
213    NoTransferKeyForCoreWithdrawalAvailableError(NoTransferKeyForCoreWithdrawalAvailableError),
214
215    #[error(transparent)]
216    InvalidIdentityPublicKeyIdError(InvalidIdentityPublicKeyIdError),
217
218    #[error(transparent)]
219    InvalidIdentityRevisionError(InvalidIdentityRevisionError),
220
221    #[error(transparent)]
222    InvalidIdentityNonceError(InvalidIdentityNonceError),
223
224    #[error(transparent)]
225    MaxIdentityPublicKeyLimitReachedError(MaxIdentityPublicKeyLimitReachedError),
226
227    #[error(transparent)]
228    DuplicatedIdentityPublicKeyStateError(DuplicatedIdentityPublicKeyStateError),
229
230    #[error(transparent)]
231    DuplicatedIdentityPublicKeyIdStateError(DuplicatedIdentityPublicKeyIdStateError),
232
233    #[error(transparent)]
234    IdentityPublicKeyIsDisabledError(IdentityPublicKeyIsDisabledError),
235
236    #[error(transparent)]
237    IdentityInsufficientBalanceError(IdentityInsufficientBalanceError),
238
239    #[error(transparent)]
240    DocumentTimestampsAreEqualError(DocumentTimestampsAreEqualError),
241
242    #[error(transparent)]
243    DataContractIsReadonlyError(DataContractIsReadonlyError),
244
245    #[error(transparent)]
246    DataContractConfigUpdateError(DataContractConfigUpdateError),
247
248    #[error(transparent)]
249    DocumentTypeUpdateError(DocumentTypeUpdateError),
250
251    #[error(transparent)]
252    PrefundedSpecializedBalanceInsufficientError(PrefundedSpecializedBalanceInsufficientError),
253
254    #[error(transparent)]
255    PrefundedSpecializedBalanceNotFoundError(PrefundedSpecializedBalanceNotFoundError),
256
257    #[error(transparent)]
258    DataContractUpdatePermissionError(DataContractUpdatePermissionError),
259
260    #[error(transparent)]
261    MasternodeNotFoundError(MasternodeNotFoundError),
262
263    #[error(transparent)]
264    MasternodeIncorrectVoterIdentityIdError(MasternodeIncorrectVoterIdentityIdError),
265
266    #[error(transparent)]
267    MasternodeIncorrectVotingAddressError(MasternodeIncorrectVotingAddressError),
268
269    #[error(transparent)]
270    VotePollNotFoundError(VotePollNotFoundError),
271
272    #[error(transparent)]
273    VotePollNotAvailableForVotingError(VotePollNotAvailableForVotingError),
274
275    #[error(transparent)]
276    MasternodeVotedTooManyTimesError(MasternodeVotedTooManyTimesError),
277
278    #[error(transparent)]
279    MasternodeVoteAlreadyPresentError(MasternodeVoteAlreadyPresentError),
280
281    #[error(transparent)]
282    RecipientIdentityDoesNotExistError(RecipientIdentityDoesNotExistError),
283
284    #[error(transparent)]
285    IdentityDoesNotHaveEnoughTokenBalanceError(IdentityDoesNotHaveEnoughTokenBalanceError),
286
287    #[error(transparent)]
288    UnauthorizedTokenActionError(UnauthorizedTokenActionError),
289
290    #[error(transparent)]
291    IdentityTokenAccountFrozenError(IdentityTokenAccountFrozenError),
292
293    #[error(transparent)]
294    IdentityTokenAccountNotFrozenError(IdentityTokenAccountNotFrozenError),
295
296    #[error(transparent)]
297    IdentityNotMemberOfGroupError(IdentityNotMemberOfGroupError),
298
299    #[error(transparent)]
300    GroupActionDoesNotExistError(GroupActionDoesNotExistError),
301
302    #[error(transparent)]
303    GroupActionAlreadyCompletedError(GroupActionAlreadyCompletedError),
304
305    #[error(transparent)]
306    GroupActionAlreadySignedByIdentityError(GroupActionAlreadySignedByIdentityError),
307
308    #[error(transparent)]
309    DataContractUpdateActionNotAllowedError(DataContractUpdateActionNotAllowedError),
310
311    #[error(transparent)]
312    TokenSettingMaxSupplyToLessThanCurrentSupplyError(
313        TokenSettingMaxSupplyToLessThanCurrentSupplyError,
314    ),
315
316    #[error(transparent)]
317    TokenMintPastMaxSupplyError(TokenMintPastMaxSupplyError),
318
319    #[error(transparent)]
320    InvalidTokenClaimPropertyMismatch(InvalidTokenClaimPropertyMismatch),
321
322    #[error(transparent)]
323    InvalidTokenClaimNoCurrentRewards(InvalidTokenClaimNoCurrentRewards),
324
325    #[error(transparent)]
326    InvalidTokenClaimWrongClaimant(InvalidTokenClaimWrongClaimant),
327
328    #[error(transparent)]
329    NewTokensDestinationIdentityDoesNotExistError(NewTokensDestinationIdentityDoesNotExistError),
330
331    #[error(transparent)]
332    NewAuthorizedActionTakerIdentityDoesNotExistError(
333        NewAuthorizedActionTakerIdentityDoesNotExistError,
334    ),
335
336    #[error(transparent)]
337    NewAuthorizedActionTakerGroupDoesNotExistError(NewAuthorizedActionTakerGroupDoesNotExistError),
338
339    #[error(transparent)]
340    NewAuthorizedActionTakerMainGroupNotSetError(NewAuthorizedActionTakerMainGroupNotSetError),
341
342    #[error(transparent)]
343    InvalidGroupPositionError(InvalidGroupPositionError),
344
345    #[error(transparent)]
346    TokenIsPausedError(TokenIsPausedError),
347
348    #[error(transparent)]
349    IdentityTokenAccountAlreadyFrozenError(IdentityTokenAccountAlreadyFrozenError),
350
351    #[error(transparent)]
352    TokenAlreadyPausedError(TokenAlreadyPausedError),
353
354    #[error(transparent)]
355    TokenNotPausedError(TokenNotPausedError),
356
357    #[error(transparent)]
358    TokenTransferRecipientIdentityNotExistError(TokenTransferRecipientIdentityNotExistError),
359
360    #[error(transparent)]
361    PreProgrammedDistributionTimestampInPastError(PreProgrammedDistributionTimestampInPastError),
362
363    #[error(transparent)]
364    IdentityHasNotAgreedToPayRequiredTokenAmountError(
365        IdentityHasNotAgreedToPayRequiredTokenAmountError,
366    ),
367
368    #[error(transparent)]
369    RequiredTokenPaymentInfoNotSetError(RequiredTokenPaymentInfoNotSetError),
370
371    #[error(transparent)]
372    IdentityTryingToPayWithWrongTokenError(IdentityTryingToPayWithWrongTokenError),
373
374    #[error(transparent)]
375    TokenDirectPurchaseUserPriceTooLow(TokenDirectPurchaseUserPriceTooLow),
376
377    #[error(transparent)]
378    TokenAmountUnderMinimumSaleAmount(TokenAmountUnderMinimumSaleAmount),
379
380    #[error(transparent)]
381    TokenNotForDirectSale(TokenNotForDirectSale),
382
383    #[error(transparent)]
384    IdentityInTokenConfigurationNotFoundError(IdentityInTokenConfigurationNotFoundError),
385
386    #[error(transparent)]
387    IdentityMemberOfGroupNotFoundError(IdentityMemberOfGroupNotFoundError),
388
389    #[error(transparent)]
390    ModificationOfGroupActionMainParametersNotPermittedError(
391        ModificationOfGroupActionMainParametersNotPermittedError,
392    ),
393
394    #[error(transparent)]
395    IdentityToFreezeDoesNotExistError(IdentityToFreezeDoesNotExistError),
396
397    #[error(transparent)]
398    DataContractNotFoundError(DataContractNotFoundError),
399
400    #[error(transparent)]
401    InvalidTokenPositionStateError(InvalidTokenPositionStateError),
402
403    #[error(transparent)]
404    AddressDoesNotExistError(AddressDoesNotExistError),
405
406    #[error(transparent)]
407    AddressNotEnoughFundsError(AddressNotEnoughFundsError),
408
409    #[error(transparent)]
410    AddressesNotEnoughFundsError(AddressesNotEnoughFundsError),
411
412    #[error(transparent)]
413    AddressInvalidNonceError(AddressInvalidNonceError),
414
415    #[error(transparent)]
416    InvalidAnchorError(InvalidAnchorError),
417
418    #[error(transparent)]
419    NullifierAlreadySpentError(NullifierAlreadySpentError),
420
421    #[error(transparent)]
422    InvalidShieldedProofError(InvalidShieldedProofError),
423
424    #[error(transparent)]
425    InsufficientPoolNotesError(InsufficientPoolNotesError),
426
427    #[error(transparent)]
428    InsufficientShieldedFeeError(InsufficientShieldedFeeError),
429
430    #[error(transparent)]
431    DocumentContestIndexMismatchError(DocumentContestIndexMismatchError),
432
433    #[error(transparent)]
434    DocumentContestNotRequiredError(DocumentContestNotRequiredError),
435
436    #[error(transparent)]
437    ReferencedEntityNotFoundError(ReferencedEntityNotFoundError),
438
439    #[error(transparent)]
440    ReferencedDocumentTypeNotFoundError(ReferencedDocumentTypeNotFoundError),
441
442    #[error(transparent)]
443    ReferencedDocumentTypeDeletableError(ReferencedDocumentTypeDeletableError),
444
445    #[error(transparent)]
446    ReferencedIdentityKeyNotFoundError(ReferencedIdentityKeyNotFoundError),
447
448    #[error(transparent)]
449    ReferencedIdentityKeyDisabledError(ReferencedIdentityKeyDisabledError),
450
451    #[error(transparent)]
452    ReferencedKeyIdPropertyInvalidError(ReferencedKeyIdPropertyInvalidError),
453
454    #[error(transparent)]
455    ReferencedDocumentPropertyAgreementInvalidError(
456        ReferencedDocumentPropertyAgreementInvalidError,
457    ),
458
459    #[error(transparent)]
460    ReferencedDocumentPropertyMismatchError(ReferencedDocumentPropertyMismatchError),
461
462    // Contract groups (protocol version 14).
463    #[error(transparent)]
464    ContractGroupAlreadyExistsError(ContractGroupAlreadyExistsError),
465
466    #[error(transparent)]
467    ContractGroupNotFoundError(ContractGroupNotFoundError),
468
469    #[error(transparent)]
470    IdentityNotContractGroupOwnerOrAdminError(IdentityNotContractGroupOwnerOrAdminError),
471
472    #[error(transparent)]
473    ContractGroupAdminNotFoundError(ContractGroupAdminNotFoundError),
474
475    // Authentication key limits (protocol version 14).
476    #[error(transparent)]
477    IdentityPublicKeyBudgetExceededError(IdentityPublicKeyBudgetExceededError),
478
479    #[error(transparent)]
480    IdentityPublicKeyAlreadyExpiredError(IdentityPublicKeyAlreadyExpiredError),
481
482    // Identity key limits update (protocol version 14).
483    #[error(transparent)]
484    IdentityPublicKeyLimitNotSetError(IdentityPublicKeyLimitNotSetError),
485
486    #[error(transparent)]
487    IdentityPublicKeyLimitNotRaisedError(IdentityPublicKeyLimitNotRaisedError),
488
489    // Immutable document properties (protocol version 14).
490    #[error(transparent)]
491    DocumentImmutablePropertyChangedError(DocumentImmutablePropertyChangedError),
492
493    // Once-per-identity token distribution (protocol version 14).
494    #[error(transparent)]
495    TokenOncePerIdentityDistributionAlreadyClaimedError(
496        TokenOncePerIdentityDistributionAlreadyClaimedError,
497    ),
498
499    // Gas paid by the contract owner (protocol version 14).
500    #[error(transparent)]
501    GasFeesPaidByNotAllowedError(GasFeesPaidByNotAllowedError),
502
503    #[error(transparent)]
504    InconsistentGasFeesPaidByInBatchError(InconsistentGasFeesPaidByInBatchError),
505
506    #[error(transparent)]
507    GasSponsorInsufficientBalanceError(GasSponsorInsufficientBalanceError),
508
509    // Contract moderation (protocol version 14).
510    #[error(transparent)]
511    ContractModerationNotEnabledError(ContractModerationNotEnabledError),
512
513    #[error(transparent)]
514    IdentityNotContractModeratorError(IdentityNotContractModeratorError),
515
516    #[error(transparent)]
517    ContractModerationTargetNotAllowedError(ContractModerationTargetNotAllowedError),
518
519    #[error(transparent)]
520    ContractUserAlreadyBannedError(ContractUserAlreadyBannedError),
521
522    #[error(transparent)]
523    ContractUserNotBannedError(ContractUserNotBannedError),
524
525    #[error(transparent)]
526    ContractUserNotSuspendedError(ContractUserNotSuspendedError),
527
528    #[error(transparent)]
529    ContractSuspensionNotInFutureError(ContractSuspensionNotInFutureError),
530
531    #[error(transparent)]
532    ContractUserBannedError(ContractUserBannedError),
533
534    #[error(transparent)]
535    ContractUserSuspendedError(ContractUserSuspendedError),
536
537    #[error(transparent)]
538    ContractModerationTargetNotFoundError(ContractModerationTargetNotFoundError),
539
540    #[error(transparent)]
541    ContractModeratorIdentityNotFoundError(ContractModeratorIdentityNotFoundError),
542
543    #[error(transparent)]
544    ContractModerationCounterpartyBarredError(ContractModerationCounterpartyBarredError),
545
546    // Contract fee claims (protocol version 14).
547    #[error(transparent)]
548    ContractFeesAlreadyClaimedThisEpochError(ContractFeesAlreadyClaimedThisEpochError),
549
550    #[error(transparent)]
551    ContractFeesNothingToClaimError(ContractFeesNothingToClaimError),
552
553    #[error(transparent)]
554    ContractFeeClaimNotAllowedError(ContractFeeClaimNotAllowedError),
555
556    // `refersTo: deletableDocument` (protocol version 14). Appended here,
557    // away from the other reference errors, because the enum is append-only.
558    #[error(transparent)]
559    ReferencedDocumentTypeNotDeletableError(ReferencedDocumentTypeNotDeletableError),
560
561    // Document deletion by moderators (protocol version 14).
562    #[error(transparent)]
563    DocumentTypeNotDeletableByModeratorsError(DocumentTypeNotDeletableByModeratorsError),
564
565    // Document action fee agreements (protocol version 14).
566    #[error(transparent)]
567    DocumentActionFeeAgreementNotSetError(DocumentActionFeeAgreementNotSetError),
568
569    #[error(transparent)]
570    DocumentActionFeeAgreementMismatchError(DocumentActionFeeAgreementMismatchError),
571
572    #[error(transparent)]
573    DocumentActionFeeMultiplierNotToleratedError(DocumentActionFeeMultiplierNotToleratedError),
574
575    // The moderators' deletion window (protocol version 14).
576    #[error(transparent)]
577    DocumentModerationWindowElapsedError(DocumentModerationWindowElapsedError),
578
579    // The warning list (protocol version 14).
580    #[error(transparent)]
581    ContractUserNotWarnedError(ContractUserNotWarnedError),
582
583    #[error(transparent)]
584    ContractUserWarningLimitReachedError(ContractUserWarningLimitReachedError),
585    // The moderators' restore of a deleted document (protocol version 14).
586    #[error(transparent)]
587    ContractDocumentRemovalNotFoundError(ContractDocumentRemovalNotFoundError),
588
589    #[error(transparent)]
590    DocumentRestoreWindowElapsedError(DocumentRestoreWindowElapsedError),
591
592    #[error(transparent)]
593    DocumentRestoreHashMismatchError(DocumentRestoreHashMismatchError),
594
595    #[error(transparent)]
596    ContractDocumentAlreadyRestoredError(ContractDocumentAlreadyRestoredError),
597
598    // Elected moderation teams (protocol version 14).
599    #[error(transparent)]
600    ContractModeratedDocumentTypeNotYetUsableError(ContractModeratedDocumentTypeNotYetUsableError),
601
602    // Contested indexes resolved without a Lock choice (protocol version 14).
603    #[error(transparent)]
604    VoteChoiceNotAllowedForVotePollError(VoteChoiceNotAllowedForVotePollError),
605
606    // Requirements on a referenced contract (protocol version 14).
607    #[error(transparent)]
608    ReferencedContractRequirementNotMetError(ReferencedContractRequirementNotMetError),
609
610    // Requirements on a referenced identity key (protocol version 14).
611    #[error(transparent)]
612    ReferencedIdentityKeyRequirementNotMetError(ReferencedIdentityKeyRequirementNotMetError),
613
614    // Document references resolved through a unique index (protocol version 14).
615    #[error(transparent)]
616    ReferencedDocumentLookupInvalidError(ReferencedDocumentLookupInvalidError),
617
618    // References to an element of a list of a referenced document (protocol version 14).
619    #[error(transparent)]
620    ReferencedDocumentListInvalidError(ReferencedDocumentListInvalidError),
621
622    // Elected moderation teams moderating from their seated charter (protocol version 14).
623    #[error(transparent)]
624    ContractModerationAbilityNotGrantedError(ContractModerationAbilityNotGrantedError),
625
626    #[error(transparent)]
627    ModerationCharterAddedModeratorLimitReachedError(
628        ModerationCharterAddedModeratorLimitReachedError,
629    ),
630
631    #[error(transparent)]
632    DocumentActionFeeModeratorsShareMismatchError(DocumentActionFeeModeratorsShareMismatchError),
633
634    // A seated moderation team's action names a reason its proposal lists (protocol version
635    // 14).
636    #[error(transparent)]
637    ModerationReasonNotListedError(ModerationReasonNotListedError),
638
639    // NOTE: `StateError` is bincode-encoded positionally, so a new variant MUST be appended at
640    // the tail: inserting mid-enum shifts the wire discriminant of every variant after it and
641    // mis-decodes errors already encoded. The error code in `codes.rs` is independent of order.
642
643    // A document whose type declares a `ttl` is changed or restored after it expired
644    // (protocol version 14).
645    #[error(transparent)]
646    DocumentExpiredError(DocumentExpiredError),
647
648    // A contest holding the most contenders a contest accepts refuses another (protocol version
649    // 14).
650    #[error(transparent)]
651    DocumentContestMaximumContendersReachedError(DocumentContestMaximumContendersReachedError),
652
653    // Fields of a document only the contract's moderators write, `moderatorAbilities.changeFields`
654    // (protocol version 14).
655    #[error(transparent)]
656    DocumentFieldNotChangeableByModeratorsError(DocumentFieldNotChangeableByModeratorsError),
657
658    #[error(transparent)]
659    DocumentModeratorFieldNotWritableError(DocumentModeratorFieldNotWritableError),
660
661    // The commitment a `refersTo` `findBy` function found does not meet the reference's
662    // `minimumAgeBlocks` (protocol version 14).
663    #[error(transparent)]
664    ReferencedDocumentRequirementNotMetError(ReferencedDocumentRequirementNotMetError),
665
666    // A `moderatedDocument` reference names a document type whose documents can leave state
667    // otherwise than through a moderator's recorded removal, a `deletableDocument` reference
668    // names one whose documents leave it only that way, and a replace keeping a reference to a
669    // removed document had to compare one of its properties (protocol version 14).
670    #[error(transparent)]
671    ReferencedDocumentTypeNotModeratedError(ReferencedDocumentTypeNotModeratedError),
672
673    #[error(transparent)]
674    ReferencedDocumentTypeModeratedError(ReferencedDocumentTypeModeratedError),
675
676    #[error(transparent)]
677    ReferencedDocumentRemovedError(ReferencedDocumentRemovedError),
678
679    // The deletion of a settled document by the approvals of a seated moderation team,
680    // `moderatorAbilities.deleteSettled`, and the team actions that carry them (protocol
681    // version 14).
682    #[error(transparent)]
683    DocumentTypeNotDeletableOnceSettledError(DocumentTypeNotDeletableOnceSettledError),
684
685    #[error(transparent)]
686    ContractModerationTeamNotSeatedError(ContractModerationTeamNotSeatedError),
687
688    #[error(transparent)]
689    DocumentNotSettledError(DocumentNotSettledError),
690
691    #[error(transparent)]
692    ContractTeamActionDoesNotExistError(ContractTeamActionDoesNotExistError),
693
694    #[error(transparent)]
695    ContractTeamActionAlreadySignedError(ContractTeamActionAlreadySignedError),
696
697    #[error(transparent)]
698    SettledDeletionNotRestorableError(SettledDeletionNotRestorableError),
699
700    #[error(transparent)]
701    ContractTeamActionAlreadyCompletedError(ContractTeamActionAlreadyCompletedError),
702
703    #[error(transparent)]
704    ContractTeamActionDocumentChangedError(ContractTeamActionDocumentChangedError),
705
706    // A token shielded pool refuses a transition (protocol version 14).
707    #[error(transparent)]
708    TokenShieldedPoolNotEnabledError(TokenShieldedPoolNotEnabledError),
709
710    #[error(transparent)]
711    TokenShieldedPaymentAmountMismatchError(TokenShieldedPaymentAmountMismatchError),
712
713    #[error(transparent)]
714    TokenShieldedPaymentNotRequiredError(TokenShieldedPaymentNotRequiredError),
715
716    // A member the leader added after a settled document was created proposes or approves its
717    // deletion, the type's rule admitting only members from before it
718    // (`deleteSettled.approversPredateDocument`, protocol version 14).
719    #[error(transparent)]
720    ContractTeamMemberAddedAfterDocumentError(ContractTeamMemberAddedAfterDocumentError),
721
722    // A document reference resolved by a document's id names an indexOnly document type, whose
723    // documents can not be fetched by id (protocol version 14).
724    #[error(transparent)]
725    ReferencedDocumentTypeIndexOnlyError(ReferencedDocumentTypeIndexOnlyError),
726
727    // The owner's delete of a document breaks a rule of its type's `deleteConstraints`
728    // (protocol version 14).
729    #[error(transparent)]
730    DocumentDeleteConstraintViolatedError(DocumentDeleteConstraintViolatedError),
731}
732
733impl From<StateError> for ConsensusError {
734    fn from(error: StateError) -> Self {
735        Self::StateError(error)
736    }
737}
738
739#[cfg(test)]
740mod tests {
741    use super::*;
742    use crate::consensus::basic::document::PropertyConstraintViolation;
743    use crate::consensus::state::contract_moderation::ContractModerationCounterpartyRole;
744    use crate::consensus::state::identity::identity_public_key_limit_not_set_error::KeyLimit;
745    use crate::data_contract::config::moderation::{ContractModerationList, ModerationAbility};
746    use crate::data_contract::document_type::action_fees::agreement::{
747        AgreedFeeMultiplier, DocumentActionFeeAgreement,
748    };
749    use crate::data_contract::document_type::action_fees::{
750        ActionFeePricing, ContractFeePot, DocumentActionFee,
751    };
752    use crate::data_contract::document_type::{
753        DocumentPropertyReferenceTarget, DocumentReferenceLookup, ListElementReference,
754        LookupKeySource,
755    };
756    use crate::tokens::gas_fees_paid_by::GasFeesPaidBy;
757    use crate::voting::vote_choices::resource_vote_choice::ResourceVoteChoice;
758    use crate::voting::vote_polls::contested_document_resource_vote_poll::ContestedDocumentResourceVotePoll;
759    use crate::voting::vote_polls::VotePoll;
760    use platform_value::Identifier;
761    use std::collections::BTreeMap;
762
763    /// `StateError` is encoded by variant position, so inserting a variant
764    /// anywhere but the end silently reassigns the discriminant of every
765    /// variant after it — consensus errors travel to WASM and JavaScript
766    /// clients, which would then decode an existing error as a different one.
767    /// These are the frozen discriminants of the first variant, of the variant
768    /// that follows the document contest block (the one an insertion there
769    /// would shift first), and of the variants appended since, down to the
770    /// last one, which the test's final assertion pins.
771    fn discriminant_of(error: StateError) -> u32 {
772        let bytes = bincode::encode_to_vec(error, bincode::config::standard())
773            .expect("expected to encode the state error");
774        let (discriminant, _): (u32, usize) =
775            bincode::decode_from_slice(&bytes, bincode::config::standard())
776                .expect("expected to decode the discriminant");
777        discriminant
778    }
779
780    /// A reference error for an id reference encodes exactly as it did before
781    /// lookup references existed: the lookup form is an appended variant of
782    /// `DocumentPropertyReferenceTarget` (`PermanentDocumentLookup`), not a
783    /// field of `PermanentDocument`, so a client decoding with an earlier dpp
784    /// still reads every error an id reference produces. The bytes are pinned;
785    /// `PermanentDocument` keeps variant 3 of the target, the lookup form
786    /// takes 6.
787    #[test]
788    fn should_keep_the_encoding_of_a_reference_error_for_an_id_reference() {
789        let id_reference = DocumentPropertyReferenceTarget::PermanentDocument {
790            contract_id: None,
791            document_type_name: "note".to_string(),
792            property_agreement: BTreeMap::new(),
793        };
794        let error = StateError::ReferencedEntityNotFoundError(ReferencedEntityNotFoundError::new(
795            Identifier::from([1; 32]),
796            id_reference.clone(),
797            "noteId".to_string(),
798        ));
799        let bytes = bincode::encode_to_vec(error, bincode::config::standard())
800            .expect("expected to encode the state error");
801        // StateError variant 93, the referenced id, target variant 3
802        // (PermanentDocument: no contract id, "note", no agreement), the path.
803        assert_eq!(
804            hex::encode(bytes),
805            concat!(
806                "5d",
807                "0101010101010101010101010101010101010101010101010101010101010101",
808                "03",
809                "00",
810                "046e6f7465",
811                "00",
812                "066e6f74654964",
813            )
814        );
815
816        let target_variant = |target: &DocumentPropertyReferenceTarget| {
817            bincode::encode_to_vec(target, bincode::config::standard())
818                .expect("expected to encode the target")[0]
819        };
820        assert_eq!(target_variant(&id_reference), 3);
821        assert_eq!(
822            target_variant(&DocumentPropertyReferenceTarget::PermanentDocumentLookup {
823                contract_id: None,
824                document_type_name: "note".to_string(),
825                property_agreement: BTreeMap::new(),
826                lookup: DocumentReferenceLookup {
827                    keys: [("$ownerId".to_string(), LookupKeySource::ReferenceValue)].into(),
828                    minimum_age_blocks: None,
829                    consume: false,
830                },
831            }),
832            6
833        );
834        // A list element reference is appended after the expressions (anyOf
835        // 7, allOf 8, pinned in `reference_expression.rs`)
836        assert_eq!(
837            target_variant(&DocumentPropertyReferenceTarget::ListElement(
838                ListElementReference {
839                    contract_id: None,
840                    document_type_name: "electedCharter".to_string(),
841                    property_agreement: [("electedCharterId".to_string(), "$id".to_string())]
842                        .into(),
843                    in_list: "members".to_string(),
844                }
845            )),
846            9
847        );
848        // A deletable document found through a lookup is appended after it
849        assert_eq!(
850            target_variant(&DocumentPropertyReferenceTarget::DeletableDocumentLookup {
851                contract_id: None,
852                document_type_name: "note".to_string(),
853                property_agreement: BTreeMap::new(),
854                lookup: DocumentReferenceLookup {
855                    keys: [("$ownerId".to_string(), LookupKeySource::ReferenceValue)].into(),
856                    minimum_age_blocks: None,
857                    consume: false,
858                },
859            }),
860            10
861        );
862    }
863
864    #[test]
865    fn state_error_discriminants_are_frozen() {
866        assert_eq!(
867            discriminant_of(StateError::DataContractAlreadyPresentError(
868                DataContractAlreadyPresentError::new(Identifier::from([1; 32]))
869            )),
870            0
871        );
872        assert_eq!(
873            discriminant_of(StateError::DocumentNotFoundError(
874                DocumentNotFoundError::new(Identifier::from([1; 32]))
875            )),
876            8
877        );
878        assert_eq!(
879            discriminant_of(StateError::InsufficientShieldedFeeError(
880                InsufficientShieldedFeeError::new("fee".to_string())
881            )),
882            90
883        );
884        assert_eq!(
885            discriminant_of(StateError::DocumentContestIndexMismatchError(
886                DocumentContestIndexMismatchError::new(
887                    Identifier::from([1; 32]),
888                    "expected".to_string(),
889                    "provided".to_string(),
890                )
891            )),
892            91
893        );
894        assert_eq!(
895            discriminant_of(StateError::DocumentContestNotRequiredError(
896                DocumentContestNotRequiredError::new(
897                    Identifier::from([1; 32]),
898                    "provided".to_string(),
899                )
900            )),
901            92
902        );
903        assert_eq!(
904            discriminant_of(StateError::ReferencedEntityNotFoundError(
905                ReferencedEntityNotFoundError::new(
906                    Identifier::from([1; 32]),
907                    crate::data_contract::document_type::DocumentPropertyReferenceTarget::Identity,
908                    "toUserId".to_string(),
909                )
910            )),
911            93
912        );
913        assert_eq!(
914            discriminant_of(StateError::ReferencedDocumentTypeNotFoundError(
915                ReferencedDocumentTypeNotFoundError::new(
916                    Identifier::from([1; 32]),
917                    "note".to_string(),
918                    "parentNoteId".to_string(),
919                )
920            )),
921            94
922        );
923        assert_eq!(
924            discriminant_of(StateError::ReferencedDocumentTypeDeletableError(
925                ReferencedDocumentTypeDeletableError::new(
926                    Identifier::from([1; 32]),
927                    "note".to_string(),
928                    "parentNoteId".to_string(),
929                )
930            )),
931            95
932        );
933        assert_eq!(
934            discriminant_of(StateError::ReferencedIdentityKeyNotFoundError(
935                ReferencedIdentityKeyNotFoundError::new(
936                    Identifier::from([1; 32]),
937                    2,
938                    "toUserId".to_string(),
939                )
940            )),
941            96
942        );
943        assert_eq!(
944            discriminant_of(StateError::ReferencedIdentityKeyDisabledError(
945                ReferencedIdentityKeyDisabledError::new(
946                    Identifier::from([1; 32]),
947                    2,
948                    "toUserId".to_string(),
949                )
950            )),
951            97
952        );
953        assert_eq!(
954            discriminant_of(StateError::ReferencedKeyIdPropertyInvalidError(
955                ReferencedKeyIdPropertyInvalidError::new(
956                    "recipientKeyIndex".to_string(),
957                    "toUserId".to_string(),
958                    "missing".to_string(),
959                )
960            )),
961            98
962        );
963        assert_eq!(
964            discriminant_of(StateError::ReferencedDocumentPropertyAgreementInvalidError(
965                ReferencedDocumentPropertyAgreementInvalidError::new(
966                    "like.postId".to_string(),
967                    "hashtag".to_string(),
968                    "hashtag".to_string(),
969                    "missing".to_string(),
970                )
971            )),
972            99
973        );
974        assert_eq!(
975            discriminant_of(StateError::ReferencedDocumentPropertyMismatchError(
976                ReferencedDocumentPropertyMismatchError::new(
977                    "postId".to_string(),
978                    "hashtag".to_string(),
979                    "hashtag".to_string(),
980                )
981            )),
982            100
983        );
984        // Contract groups (protocol version 14).
985        let group_id = Identifier::from([1u8; 32]);
986        let identity_id = Identifier::from([2u8; 32]);
987        assert_eq!(
988            discriminant_of(StateError::ContractGroupAlreadyExistsError(
989                ContractGroupAlreadyExistsError::new(group_id)
990            )),
991            101
992        );
993        assert_eq!(
994            discriminant_of(StateError::ContractGroupNotFoundError(
995                ContractGroupNotFoundError::new(group_id)
996            )),
997            102
998        );
999        assert_eq!(
1000            discriminant_of(StateError::IdentityNotContractGroupOwnerOrAdminError(
1001                IdentityNotContractGroupOwnerOrAdminError::new(identity_id, group_id)
1002            )),
1003            103
1004        );
1005        assert_eq!(
1006            discriminant_of(StateError::ContractGroupAdminNotFoundError(
1007                ContractGroupAdminNotFoundError::new(group_id, identity_id)
1008            )),
1009            104
1010        );
1011        // Authentication key limits (protocol version 14): the tail of the enum.
1012        assert_eq!(
1013            discriminant_of(StateError::IdentityPublicKeyBudgetExceededError(
1014                IdentityPublicKeyBudgetExceededError::new(identity_id, 1, 2, 3)
1015            )),
1016            105
1017        );
1018        assert_eq!(
1019            discriminant_of(StateError::IdentityPublicKeyAlreadyExpiredError(
1020                IdentityPublicKeyAlreadyExpiredError::new(1, 2, 3)
1021            )),
1022            106
1023        );
1024        // Identity key limits update (protocol version 14): the tail of the enum.
1025        assert_eq!(
1026            discriminant_of(StateError::IdentityPublicKeyLimitNotSetError(
1027                IdentityPublicKeyLimitNotSetError::new(1, KeyLimit::Budget)
1028            )),
1029            107
1030        );
1031        assert_eq!(
1032            discriminant_of(StateError::IdentityPublicKeyLimitNotRaisedError(
1033                IdentityPublicKeyLimitNotRaisedError::new(1, KeyLimit::Expiry, 2, 3)
1034            )),
1035            108
1036        );
1037        // Immutable document properties (protocol version 14).
1038        assert_eq!(
1039            discriminant_of(StateError::DocumentImmutablePropertyChangedError(
1040                DocumentImmutablePropertyChangedError::new(
1041                    identity_id,
1042                    "post".to_string(),
1043                    "author".to_string()
1044                )
1045            )),
1046            109
1047        );
1048        // Once-per-identity token distribution (protocol version 14).
1049        assert_eq!(
1050            discriminant_of(
1051                StateError::TokenOncePerIdentityDistributionAlreadyClaimedError(
1052                    TokenOncePerIdentityDistributionAlreadyClaimedError::new(
1053                        group_id,
1054                        identity_id,
1055                        1
1056                    )
1057                )
1058            ),
1059            110
1060        );
1061        // Gas paid by the contract owner (protocol version 14): the tail of the enum.
1062        assert_eq!(
1063            discriminant_of(StateError::GasFeesPaidByNotAllowedError(
1064                GasFeesPaidByNotAllowedError::new(
1065                    "post".to_string(),
1066                    "create".to_string(),
1067                    GasFeesPaidBy::ContractOwner,
1068                    GasFeesPaidBy::DocumentOwner,
1069                )
1070            )),
1071            111
1072        );
1073        assert_eq!(
1074            discriminant_of(StateError::InconsistentGasFeesPaidByInBatchError(
1075                InconsistentGasFeesPaidByInBatchError::new(Some(identity_id), None)
1076            )),
1077            112
1078        );
1079        assert_eq!(
1080            discriminant_of(StateError::GasSponsorInsufficientBalanceError(
1081                GasSponsorInsufficientBalanceError::new(identity_id, 1, 2)
1082            )),
1083            113
1084        );
1085        // Contract moderation (protocol version 14): every variant, the tail of the enum.
1086        assert_eq!(
1087            discriminant_of(StateError::ContractModerationNotEnabledError(
1088                ContractModerationNotEnabledError::new(group_id, ContractModerationList::Banlist,)
1089            )),
1090            114
1091        );
1092        assert_eq!(
1093            discriminant_of(StateError::IdentityNotContractModeratorError(
1094                IdentityNotContractModeratorError::new(group_id, identity_id)
1095            )),
1096            115
1097        );
1098        assert_eq!(
1099            discriminant_of(StateError::ContractModerationTargetNotAllowedError(
1100                ContractModerationTargetNotAllowedError::new(group_id, identity_id)
1101            )),
1102            116
1103        );
1104        assert_eq!(
1105            discriminant_of(StateError::ContractUserAlreadyBannedError(
1106                ContractUserAlreadyBannedError::new(group_id, identity_id)
1107            )),
1108            117
1109        );
1110        assert_eq!(
1111            discriminant_of(StateError::ContractUserNotBannedError(
1112                ContractUserNotBannedError::new(group_id, identity_id)
1113            )),
1114            118
1115        );
1116        assert_eq!(
1117            discriminant_of(StateError::ContractUserNotSuspendedError(
1118                ContractUserNotSuspendedError::new(group_id, identity_id)
1119            )),
1120            119
1121        );
1122        assert_eq!(
1123            discriminant_of(StateError::ContractSuspensionNotInFutureError(
1124                ContractSuspensionNotInFutureError::new(group_id, identity_id, 1, 2)
1125            )),
1126            120
1127        );
1128        assert_eq!(
1129            discriminant_of(StateError::ContractUserBannedError(
1130                ContractUserBannedError::new(group_id, identity_id)
1131            )),
1132            121
1133        );
1134        assert_eq!(
1135            discriminant_of(StateError::ContractUserSuspendedError(
1136                ContractUserSuspendedError::new(group_id, identity_id, 1)
1137            )),
1138            122
1139        );
1140        assert_eq!(
1141            discriminant_of(StateError::ContractModerationTargetNotFoundError(
1142                ContractModerationTargetNotFoundError::new(group_id, identity_id)
1143            )),
1144            123
1145        );
1146        assert_eq!(
1147            discriminant_of(StateError::ContractModeratorIdentityNotFoundError(
1148                ContractModeratorIdentityNotFoundError::new(group_id, identity_id)
1149            )),
1150            124
1151        );
1152        assert_eq!(
1153            discriminant_of(StateError::ContractModerationCounterpartyBarredError(
1154                ContractModerationCounterpartyBarredError::new(
1155                    group_id,
1156                    identity_id,
1157                    ContractModerationCounterpartyRole::Recipient,
1158                )
1159            )),
1160            125
1161        );
1162        // Contract fee claims (protocol version 14).
1163        assert_eq!(
1164            discriminant_of(StateError::ContractFeesAlreadyClaimedThisEpochError(
1165                ContractFeesAlreadyClaimedThisEpochError::new(
1166                    group_id,
1167                    ContractFeePot::Moderators,
1168                    7
1169                )
1170            )),
1171            126
1172        );
1173        assert_eq!(
1174            discriminant_of(StateError::ContractFeesNothingToClaimError(
1175                ContractFeesNothingToClaimError::new(group_id, ContractFeePot::Owner)
1176            )),
1177            127
1178        );
1179        assert_eq!(
1180            discriminant_of(StateError::ContractFeeClaimNotAllowedError(
1181                ContractFeeClaimNotAllowedError::new(group_id, ContractFeePot::Owner, identity_id)
1182            )),
1183            128
1184        );
1185        // `refersTo: deletableDocument` (protocol version 14).
1186        assert_eq!(
1187            discriminant_of(StateError::ReferencedDocumentTypeNotDeletableError(
1188                ReferencedDocumentTypeNotDeletableError::new(
1189                    group_id,
1190                    "note".to_string(),
1191                    "noteId".to_string()
1192                )
1193            )),
1194            129
1195        );
1196        // Document deletion by moderators (protocol version 14).
1197        assert_eq!(
1198            discriminant_of(StateError::DocumentTypeNotDeletableByModeratorsError(
1199                DocumentTypeNotDeletableByModeratorsError::new(group_id, "post".to_string())
1200            )),
1201            130
1202        );
1203        // Document action fee agreements (protocol version 14).
1204        let declared_fee = DocumentActionFee {
1205            owner: 1,
1206            moderators: 2,
1207        };
1208        let agreed_fee_multiplier = AgreedFeeMultiplier {
1209            known_permille: 1000,
1210            increase_tolerance_percent: 20,
1211        };
1212        assert_eq!(
1213            discriminant_of(StateError::DocumentActionFeeAgreementNotSetError(
1214                DocumentActionFeeAgreementNotSetError::new(
1215                    "post".to_string(),
1216                    "create".to_string(),
1217                    ActionFeePricing::Fixed,
1218                    declared_fee,
1219                )
1220            )),
1221            131
1222        );
1223        assert_eq!(
1224            discriminant_of(StateError::DocumentActionFeeAgreementMismatchError(
1225                DocumentActionFeeAgreementMismatchError::new(
1226                    "post".to_string(),
1227                    "create".to_string(),
1228                    ActionFeePricing::Fixed,
1229                    declared_fee,
1230                    &DocumentActionFeeAgreement::for_declared_fee(
1231                        ActionFeePricing::FeeMultiplier,
1232                        declared_fee,
1233                        agreed_fee_multiplier,
1234                    ),
1235                )
1236            )),
1237            132
1238        );
1239        assert_eq!(
1240            discriminant_of(StateError::DocumentActionFeeMultiplierNotToleratedError(
1241                DocumentActionFeeMultiplierNotToleratedError::new(
1242                    "post".to_string(),
1243                    "create".to_string(),
1244                    agreed_fee_multiplier,
1245                    1500,
1246                )
1247            )),
1248            133
1249        );
1250        // The moderators' deletion window (protocol version 14).
1251        assert_eq!(
1252            discriminant_of(StateError::DocumentModerationWindowElapsedError(
1253                DocumentModerationWindowElapsedError::new(group_id, identity_id, 1, 2, 3)
1254            )),
1255            134
1256        );
1257        // The warning list (protocol version 14).
1258        assert_eq!(
1259            discriminant_of(StateError::ContractUserNotWarnedError(
1260                ContractUserNotWarnedError::new(group_id, identity_id)
1261            )),
1262            135
1263        );
1264        assert_eq!(
1265            discriminant_of(StateError::ContractUserWarningLimitReachedError(
1266                ContractUserWarningLimitReachedError::new(group_id, identity_id, 16)
1267            )),
1268            136
1269        );
1270        // The moderators' restore of a deleted document (protocol version 14).
1271        assert_eq!(
1272            discriminant_of(StateError::ContractDocumentRemovalNotFoundError(
1273                ContractDocumentRemovalNotFoundError::new(
1274                    group_id,
1275                    "post".to_string(),
1276                    identity_id
1277                )
1278            )),
1279            137
1280        );
1281        assert_eq!(
1282            discriminant_of(StateError::DocumentRestoreWindowElapsedError(
1283                DocumentRestoreWindowElapsedError::new(group_id, identity_id, 1, 2, 3)
1284            )),
1285            138
1286        );
1287        assert_eq!(
1288            discriminant_of(StateError::DocumentRestoreHashMismatchError(
1289                DocumentRestoreHashMismatchError::new(group_id, identity_id, [1; 32], [2; 32])
1290            )),
1291            139
1292        );
1293        assert_eq!(
1294            discriminant_of(StateError::ContractDocumentAlreadyRestoredError(
1295                ContractDocumentAlreadyRestoredError::new(group_id, identity_id, identity_id, 4)
1296            )),
1297            140
1298        );
1299        // Elected moderation teams (protocol version 14): the tail of the enum.
1300        assert_eq!(
1301            discriminant_of(StateError::ContractModeratedDocumentTypeNotYetUsableError(
1302                ContractModeratedDocumentTypeNotYetUsableError::new(group_id, "post".to_string())
1303            )),
1304            141
1305        );
1306        // Contested indexes without a Lock choice (protocol version 14).
1307        assert_eq!(
1308            discriminant_of(StateError::VoteChoiceNotAllowedForVotePollError(
1309                VoteChoiceNotAllowedForVotePollError::new(
1310                    VotePoll::ContestedDocumentResourceVotePoll(
1311                        ContestedDocumentResourceVotePoll {
1312                            contract_id: Identifier::new([7; 32]),
1313                            document_type_name: "domain".to_string(),
1314                            index_name: "parentNameAndLabel".to_string(),
1315                            index_values: vec![],
1316                        }
1317                    ),
1318                    ResourceVoteChoice::Lock,
1319                )
1320            )),
1321            142
1322        );
1323        // Requirements on a referenced contract (protocol version 14).
1324        assert_eq!(
1325            discriminant_of(StateError::ReferencedContractRequirementNotMetError(
1326                ReferencedContractRequirementNotMetError::new(
1327                    group_id,
1328                    "moderation".to_string(),
1329                    "elected".to_string(),
1330                    "targetContractId".to_string(),
1331                )
1332            )),
1333            143
1334        );
1335        // Requirements on a referenced identity key (protocol version 14).
1336        assert_eq!(
1337            discriminant_of(StateError::ReferencedIdentityKeyRequirementNotMetError(
1338                ReferencedIdentityKeyRequirementNotMetError::new(
1339                    "joinRequest".to_string(),
1340                    "recipientId".to_string(),
1341                    group_id,
1342                    2,
1343                    "purpose".to_string(),
1344                    "decryption".to_string(),
1345                    "encryption".to_string(),
1346                )
1347            )),
1348            144
1349        );
1350        // Document references resolved through a unique index (protocol version 14).
1351        assert_eq!(
1352            discriminant_of(StateError::ReferencedDocumentLookupInvalidError(
1353                ReferencedDocumentLookupInvalidError::new(
1354                    "electedCharter.members".to_string(),
1355                    "bySubmittedCharter".to_string(),
1356                    "is not unique".to_string(),
1357                )
1358            )),
1359            145
1360        );
1361        // References to an element of a list of a referenced document (protocol version 14).
1362        assert_eq!(
1363            discriminant_of(StateError::ReferencedDocumentListInvalidError(
1364                ReferencedDocumentListInvalidError::new(
1365                    "resignation.memberId".to_string(),
1366                    "members".to_string(),
1367                    "is not a typed array of identifiers".to_string(),
1368                )
1369            )),
1370            146
1371        );
1372        // Elected moderation teams moderating from their seated charter (protocol version
1373        // 14): the tail of the enum.
1374        assert_eq!(
1375            discriminant_of(StateError::ContractModerationAbilityNotGrantedError(
1376                ContractModerationAbilityNotGrantedError::new(
1377                    group_id,
1378                    ModerationAbility::DeleteDocuments,
1379                    Some("post".to_string()),
1380                )
1381            )),
1382            147
1383        );
1384        assert_eq!(
1385            discriminant_of(
1386                StateError::ModerationCharterAddedModeratorLimitReachedError(
1387                    ModerationCharterAddedModeratorLimitReachedError::new(group_id, identity_id, 2)
1388                )
1389            ),
1390            148
1391        );
1392        assert_eq!(
1393            discriminant_of(StateError::DocumentActionFeeModeratorsShareMismatchError(
1394                DocumentActionFeeModeratorsShareMismatchError::new(
1395                    "post".to_string(),
1396                    "create".to_string(),
1397                    100,
1398                    50,
1399                    Some(60),
1400                )
1401            )),
1402            149
1403        );
1404
1405        // A seated moderation team's action names a reason its proposal lists (protocol
1406        // version 14).
1407        assert_eq!(
1408            discriminant_of(StateError::ModerationReasonNotListedError(
1409                ModerationReasonNotListedError::new(group_id, identity_id, None)
1410            )),
1411            150
1412        );
1413        // A document changed or restored after its time to live passed (protocol version
1414        // 14).
1415        assert_eq!(
1416            discriminant_of(StateError::DocumentExpiredError(DocumentExpiredError::new(
1417                group_id,
1418                "note".to_string(),
1419                identity_id,
1420                1_000,
1421                2_000,
1422            ))),
1423            151
1424        );
1425        // A contest holding the most contenders a contest accepts refuses another (protocol
1426        // version 14).
1427        assert_eq!(
1428            discriminant_of(StateError::DocumentContestMaximumContendersReachedError(
1429                DocumentContestMaximumContendersReachedError::new(
1430                    ContestedDocumentResourceVotePoll::default(),
1431                    1_000,
1432                )
1433            )),
1434            152
1435        );
1436        // Fields only the contract's moderators write (protocol version 14).
1437        assert_eq!(
1438            discriminant_of(StateError::DocumentFieldNotChangeableByModeratorsError(
1439                DocumentFieldNotChangeableByModeratorsError::new(
1440                    group_id,
1441                    "report".to_string(),
1442                    "status".to_string(),
1443                )
1444            )),
1445            153
1446        );
1447        assert_eq!(
1448            discriminant_of(StateError::DocumentModeratorFieldNotWritableError(
1449                DocumentModeratorFieldNotWritableError::new(
1450                    group_id,
1451                    "report".to_string(),
1452                    identity_id,
1453                    "status".to_string(),
1454                    identity_id,
1455                )
1456            )),
1457            154
1458        );
1459        // A commitment a `findBy` function found that does not meet the reference's
1460        // `minimumAgeSeconds` (protocol version 14).
1461        assert_eq!(
1462            discriminant_of(StateError::ReferencedDocumentRequirementNotMetError(
1463                ReferencedDocumentRequirementNotMetError::new(
1464                    identity_id,
1465                    "minimumAgeSeconds".to_string(),
1466                    "60".to_string(),
1467                    "$creatorId".to_string(),
1468                )
1469            )),
1470            155
1471        );
1472        // The third kind of document reference, `moderatedDocument` (protocol version 14).
1473        assert_eq!(
1474            discriminant_of(StateError::ReferencedDocumentTypeNotModeratedError(
1475                ReferencedDocumentTypeNotModeratedError::new(
1476                    identity_id,
1477                    "post".to_string(),
1478                    "replyTo".to_string(),
1479                )
1480            )),
1481            156
1482        );
1483        assert_eq!(
1484            discriminant_of(StateError::ReferencedDocumentTypeModeratedError(
1485                ReferencedDocumentTypeModeratedError::new(
1486                    identity_id,
1487                    "post".to_string(),
1488                    "replyTo".to_string(),
1489                )
1490            )),
1491            157
1492        );
1493        assert_eq!(
1494            discriminant_of(StateError::ReferencedDocumentRemovedError(
1495                ReferencedDocumentRemovedError::new(
1496                    identity_id,
1497                    "replyTo".to_string(),
1498                    "threadId".to_string(),
1499                )
1500            )),
1501            158
1502        );
1503        // The deletion of a settled document by the approvals of a seated moderation team
1504        // (protocol version 14): the tail of the enum.
1505        assert_eq!(
1506            discriminant_of(StateError::DocumentTypeNotDeletableOnceSettledError(
1507                DocumentTypeNotDeletableOnceSettledError::new(group_id, "post".to_string())
1508            )),
1509            159
1510        );
1511        assert_eq!(
1512            discriminant_of(StateError::ContractModerationTeamNotSeatedError(
1513                ContractModerationTeamNotSeatedError::new(group_id)
1514            )),
1515            160
1516        );
1517        assert_eq!(
1518            discriminant_of(StateError::DocumentNotSettledError(
1519                DocumentNotSettledError::new(group_id, identity_id, 1_000, 60, 2_000)
1520            )),
1521            161
1522        );
1523        assert_eq!(
1524            discriminant_of(StateError::ContractTeamActionDoesNotExistError(
1525                ContractTeamActionDoesNotExistError::new(group_id, identity_id)
1526            )),
1527            162
1528        );
1529        assert_eq!(
1530            discriminant_of(StateError::ContractTeamActionAlreadySignedError(
1531                ContractTeamActionAlreadySignedError::new(group_id, identity_id, identity_id)
1532            )),
1533            163
1534        );
1535        assert_eq!(
1536            discriminant_of(StateError::SettledDeletionNotRestorableError(
1537                SettledDeletionNotRestorableError::new(group_id, identity_id, 1_000)
1538            )),
1539            164
1540        );
1541        assert_eq!(
1542            discriminant_of(StateError::ContractTeamActionAlreadyCompletedError(
1543                ContractTeamActionAlreadyCompletedError::new(group_id, identity_id)
1544            )),
1545            165
1546        );
1547        assert_eq!(
1548            discriminant_of(StateError::ContractTeamActionDocumentChangedError(
1549                ContractTeamActionDocumentChangedError::new(group_id, identity_id, identity_id)
1550            )),
1551            166
1552        );
1553        // Token shielded pools (protocol version 14).
1554        assert_eq!(
1555            discriminant_of(StateError::TokenShieldedPoolNotEnabledError(
1556                TokenShieldedPoolNotEnabledError::new(Identifier::from([1; 32]))
1557            )),
1558            167
1559        );
1560        assert_eq!(
1561            discriminant_of(StateError::TokenShieldedPaymentAmountMismatchError(
1562                TokenShieldedPaymentAmountMismatchError::new(
1563                    Identifier::from([1; 32]),
1564                    10,
1565                    9,
1566                    "create".to_string(),
1567                )
1568            )),
1569            168
1570        );
1571        assert_eq!(
1572            discriminant_of(StateError::TokenShieldedPaymentNotRequiredError(
1573                TokenShieldedPaymentNotRequiredError::new(
1574                    Identifier::from([1; 32]),
1575                    "create".to_string(),
1576                )
1577            )),
1578            169
1579        );
1580        // The deletion of settled documents again (protocol version 14): who approves it.
1581        assert_eq!(
1582            discriminant_of(StateError::ContractTeamMemberAddedAfterDocumentError(
1583                ContractTeamMemberAddedAfterDocumentError::new(
1584                    group_id,
1585                    identity_id,
1586                    2_000,
1587                    identity_id,
1588                    1_000
1589                )
1590            )),
1591            170
1592        );
1593        // A document reference by id to an indexOnly document type (protocol version 14).
1594        assert_eq!(
1595            discriminant_of(StateError::ReferencedDocumentTypeIndexOnlyError(
1596                ReferencedDocumentTypeIndexOnlyError::new(
1597                    identity_id,
1598                    "like".to_string(),
1599                    "replyTo".to_string(),
1600                )
1601            )),
1602            171
1603        );
1604        // The owner's delete of a document a deleteConstraints rule refuses (protocol
1605        // version 14).
1606        assert_eq!(
1607            discriminant_of(StateError::DocumentDeleteConstraintViolatedError(
1608                DocumentDeleteConstraintViolatedError::new(
1609                    identity_id,
1610                    "poll".to_string(),
1611                    "noVotes".to_string(),
1612                    PropertyConstraintViolation::NotMet,
1613                )
1614            )),
1615            172
1616        );
1617    }
1618}
dpp/errors/consensus/state/state_error.rs

dpp/errors/consensus/state/
state_error.rs
