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

dpp/errors/consensus/state/
state_error.rs
