Skip to main content

dpp/errors/consensus/basic/
basic_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::basic::contract_group::{
9    ContractGroupMemberNotInContractError, ContractGroupMembershipsOverLimitError,
10    DuplicateContractGroupMembershipError, InvalidContractGroupAdminsError,
11    InvalidContractGroupDescriptionLengthError, InvalidContractGroupNameLengthError,
12    RedundantContractGroupMembershipError,
13};
14use crate::consensus::basic::contract_moderation::{
15    ContractModerationReasonTooLongError, ContractModerationSelfTargetError,
16    DocumentActionFeesWithoutModerationError, InvalidContractModerationConfigError,
17    InvalidContractModerationDocumentFieldsError, InvalidContractModerationReasonDocumentsError,
18};
19use crate::consensus::basic::data_contract::data_contract_max_depth_exceed_error::DataContractMaxDepthExceedError;
20use crate::consensus::basic::data_contract::{
21    ContestedUniqueIndexOnMutableDocumentTypeError, ContestedUniqueIndexWithUniqueIndexError,
22    DataContractHaveNewUniqueIndexError, DataContractImmutablePropertiesUpdateError,
23    DataContractInvalidIndexDefinitionUpdateError, DataContractInvalidRequiredFieldsUpdateError,
24    DataContractTokenConfigurationUpdateError, DataContractUniqueIndicesChangedError,
25    DecimalsOverLimitError, DuplicateIndexError, DuplicateIndexNameError,
26    GroupExceedsMaxMembersError, GroupHasTooFewMembersError, GroupMemberHasPowerOfZeroError,
27    GroupMemberHasPowerOverLimitError, GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError,
28    GroupPositionDoesNotExistError, GroupRequiredPowerIsInvalidError,
29    GroupTotalPowerLessThanRequiredError, IncompatibleDataContractSchemaError,
30    IncompatibleDocumentTypeSchemaError, IncompatibleRe2PatternError, InvalidCompoundIndexError,
31    InvalidDataContractIdError, InvalidDataContractVersionError, InvalidDocumentTypeNameError,
32    InvalidDocumentTypeRequiredSecurityLevelError, InvalidIndexPropertyTypeError,
33    InvalidIndexedPropertyConstraintError, InvalidKeywordCharacterError,
34    InvalidTokenBaseSupplyError, InvalidTokenDistributionFunctionDivideByZeroError,
35    InvalidTokenDistributionFunctionIncoherenceError,
36    InvalidTokenDistributionFunctionInvalidParameterError,
37    InvalidTokenDistributionFunctionInvalidParameterTupleError, InvalidTokenLanguageCodeError,
38    InvalidTokenNameCharacterError, InvalidTokenNameLengthError, MainGroupIsNotDefinedError,
39    NewTokensDestinationIdentityOptionRequiredError, NonContiguousContractGroupPositionsError,
40    NonContiguousContractTokenPositionsError, NonTransferableTokenPaymentMustBurnError,
41    NonTransferableTokenShieldedPoolError, PreProgrammedDistributionAmountOverLimitError,
42    RedundantDocumentPaidForByTokenWithContractId, SystemPropertyIndexAlreadyPresentError,
43    TokenShieldedPoolIncompatibleRulesError, UndefinedIndexPropertyError,
44    UniqueIndicesLimitReachedError, UnknownDocumentCreationRestrictionModeError,
45    UnknownGasFeesPaidByError, UnknownSecurityLevelError, UnknownStorageKeyRequirementsError,
46    UnknownTradeModeError, UnknownTransferableTypeError,
47};
48use crate::consensus::basic::data_contract::{
49    InvalidJsonSchemaRefError, TokenPaymentByBurningOnlyAllowedOnInternalTokenError,
50    UnknownDocumentActionTokenEffectError,
51};
52use crate::consensus::basic::decode::{
53    ProtocolVersionParsingError, SerializedObjectParsingError, VersionError,
54};
55use crate::consensus::basic::document::{
56    ContestedDocumentsTemporarilyNotAllowedError, DataContractNotPresentError,
57    DocumentCreationNotAllowedError, DocumentFieldMaxSizeExceededError,
58    DocumentPropertyConstraintViolatedError, DocumentPropertyMaxBytesExceededError,
59    DocumentPropertyNotDistinctError, DocumentPropertyNotGeneratedError,
60    DocumentReferencePreimageInvalidError, DocumentTransitionsAreAbsentError,
61    DuplicateDocumentTransitionsWithIdsError, DuplicateDocumentTransitionsWithIndicesError,
62    InconsistentCompoundIndexDataError, InvalidDocumentTransitionActionError,
63    InvalidDocumentTransitionIdError, InvalidDocumentTypeError, InvalidEncryptedPropertyShapeError,
64    MaxDocumentsTransitionsExceededError, MissingDataContractIdBasicError,
65    MissingDocumentTransitionActionError, MissingDocumentTransitionTypeError,
66    MissingDocumentTypeError, MissingPositionsInDocumentTypePropertiesError, NonceOutOfBoundsError,
67};
68use crate::consensus::basic::identity::ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationError;
69use crate::consensus::basic::identity::IdentityKeyLimitsUpdateEmptyError;
70use crate::consensus::basic::identity::IdentityPublicKeyLimitsNotAllowedInShieldedIdentityCreationError;
71use crate::consensus::basic::identity::{
72    DataContractBoundsNotPresentError, DisablingKeyIdAlsoBeingAddedInSameTransitionError,
73    DuplicatedIdentityPublicKeyBasicError, DuplicatedIdentityPublicKeyIdBasicError,
74    IdentityAssetLockProofLockedTransactionMismatchError,
75    IdentityAssetLockStateTransitionReplayError, IdentityAssetLockTransactionIsNotFoundError,
76    IdentityAssetLockTransactionOutPointAlreadyConsumedError,
77    IdentityAssetLockTransactionOutPointNotEnoughBalanceError,
78    IdentityAssetLockTransactionOutputNotFoundError,
79    IdentityAssetLockTransactionTooManyInputsError, IdentityCreditTransferToSelfError,
80    IdentityPublicKeyLimitsNotAllowedError, InvalidAssetLockProofCoreChainHeightError,
81    InvalidAssetLockProofTransactionHeightError, InvalidAssetLockTransactionOutputReturnSizeError,
82    InvalidCreditWithdrawalTransitionCoreFeeError,
83    InvalidCreditWithdrawalTransitionOutputScriptError,
84    InvalidIdentityAssetLockProofChainLockValidationError,
85    InvalidIdentityAssetLockTransactionError, InvalidIdentityAssetLockTransactionOutputError,
86    InvalidIdentityCreditTransferAmountError, InvalidIdentityCreditWithdrawalTransitionAmountError,
87    InvalidIdentityKeySignatureError, InvalidIdentityPublicKeyBudgetError,
88    InvalidIdentityPublicKeyDataError, InvalidIdentityPublicKeySecurityLevelError,
89    InvalidIdentityUpdateTransitionDisableKeysError, InvalidIdentityUpdateTransitionEmptyError,
90    InvalidInstantAssetLockProofError, InvalidInstantAssetLockProofSignatureError,
91    InvalidKeyPurposeForContractBoundsError, MissingMasterPublicKeyError,
92    NotImplementedCreditWithdrawalTransitionPoolingError, TooManyMasterPublicKeyError,
93    WithdrawalOutputScriptNotAllowedWhenSigningWithOwnerKeyError,
94};
95use crate::consensus::basic::invalid_identifier_error::InvalidIdentifierError;
96use crate::consensus::basic::moderation_charter::{
97    ModerationCharterMalformedFieldError, ModerationCharterRewardSplitNotOneHundredError,
98};
99use crate::consensus::basic::state_transition::{
100    FeeStrategyDuplicateError, FeeStrategyEmptyError, FeeStrategyIndexOutOfBoundsError,
101    FeeStrategyTooManyStepsError, InputBelowMinimumError, InputOutputBalanceMismatchError,
102    InputWitnessCountMismatchError, InputsNotLessThanOutputsError, InsufficientFundingAmountError,
103    InvalidRemainderOutputCountError, InvalidStateTransitionTypeError,
104    MissingStateTransitionTypeError, OutputAddressAlsoInputError, OutputBelowMinimumError,
105    OutputsNotGreaterThanInputsError, ShieldedEmptyProofError,
106    ShieldedEncryptedNoteSizeMismatchError, ShieldedImplicitFeeCapExceededError,
107    ShieldedInvalidDenominationError, ShieldedInvalidValueBalanceError, ShieldedNoActionsError,
108    ShieldedTooManyActionsError, ShieldedZeroAnchorError, StateTransitionMaxSizeExceededError,
109    StateTransitionNotActiveError, TransitionNoInputsError, TransitionNoOutputsError,
110    TransitionOverMaxInputsError, TransitionOverMaxOutputsError, WithdrawalBalanceMismatchError,
111    WithdrawalBelowMinAmountError,
112};
113use crate::consensus::basic::{
114    IncompatibleProtocolVersionError, UnsupportedFeatureError, UnsupportedProtocolVersionError,
115};
116use crate::consensus::ConsensusError;
117
118use super::data_contract::{
119    DuplicateKeywordsError, InvalidDescriptionLengthError, InvalidKeywordLengthError,
120    TooManyKeywordsError,
121};
122use crate::consensus::basic::group::GroupActionNotAllowedOnTransitionError;
123use crate::consensus::basic::overflow_error::OverflowError;
124use crate::consensus::basic::token::{
125    ChoosingTokenMintRecipientNotAllowedError, ContractHasNoTokensError,
126    DestinationIdentityForTokenMintingNotSetError, InvalidActionIdError, InvalidTokenAmountError,
127    InvalidTokenConfigUpdateNoChangeError, InvalidTokenDistributionBlockIntervalTooShortError,
128    InvalidTokenDistributionEpochIntervalTooShortError,
129    InvalidTokenDistributionTimeIntervalNotMinuteAlignedError,
130    InvalidTokenDistributionTimeIntervalTooShortError, InvalidTokenIdError,
131    InvalidTokenNoteTooBigError, InvalidTokenOncePerIdentityDistributionAmountError,
132    InvalidTokenPositionError, MissingDefaultLocalizationError,
133    TokenNoteOnlyAllowedWhenProposerError, TokenPricingScheduleEmptyError,
134    TokenTransferToOurselfError,
135};
136use crate::consensus::basic::unsupported_version_error::UnsupportedVersionError;
137use crate::consensus::basic::value_error::ValueError;
138use crate::consensus::basic::{
139    json_schema_compilation_error::JsonSchemaCompilationError, json_schema_error::JsonSchemaError,
140};
141use crate::consensus::state::identity::master_public_key_update_error::MasterPublicKeyUpdateError;
142use crate::data_contract::errors::DataContractError;
143
144#[allow(clippy::large_enum_variant)]
145#[derive(
146    Error,
147    Debug,
148    PlatformSerialize,
149    PlatformDeserializeTrusted,
150    PlatformDeserializeUntrusted,
151    Encode,
152    Decode,
153    PartialEq,
154    Clone,
155    DecodeUntrusted,
156)]
157pub enum BasicError {
158    /*
159
160    DO NOT CHANGE ORDER OF VARIANTS WITHOUT INTRODUCING OF NEW VERSION
161
162    */
163    // Decoding
164    #[error(transparent)]
165    ProtocolVersionParsingError(ProtocolVersionParsingError),
166
167    #[error(transparent)]
168    VersionError(VersionError),
169
170    #[error(transparent)]
171    ContractError(DataContractError),
172
173    #[error(transparent)]
174    UnknownSecurityLevelError(UnknownSecurityLevelError),
175
176    #[error(transparent)]
177    UnknownStorageKeyRequirementsError(UnknownStorageKeyRequirementsError),
178
179    #[error(transparent)]
180    UnknownTransferableTypeError(UnknownTransferableTypeError),
181
182    #[error(transparent)]
183    UnknownTradeModeError(UnknownTradeModeError),
184
185    #[error(transparent)]
186    UnknownDocumentCreationRestrictionModeError(UnknownDocumentCreationRestrictionModeError),
187
188    #[error(transparent)]
189    SerializedObjectParsingError(SerializedObjectParsingError),
190
191    #[error(transparent)]
192    UnsupportedProtocolVersionError(UnsupportedProtocolVersionError),
193
194    #[error(transparent)]
195    UnsupportedVersionError(UnsupportedVersionError),
196
197    #[error(transparent)]
198    IncompatibleProtocolVersionError(IncompatibleProtocolVersionError),
199
200    // Structure error
201    #[error(transparent)]
202    JsonSchemaCompilationError(JsonSchemaCompilationError),
203
204    #[error(transparent)]
205    JsonSchemaError(JsonSchemaError),
206
207    #[error(transparent)]
208    InvalidIdentifierError(InvalidIdentifierError),
209
210    #[error(transparent)]
211    ValueError(ValueError),
212
213    // DataContract
214    #[error(transparent)]
215    DataContractMaxDepthExceedError(DataContractMaxDepthExceedError),
216
217    #[error(transparent)]
218    DuplicateIndexError(DuplicateIndexError),
219
220    #[error(transparent)]
221    IncompatibleRe2PatternError(IncompatibleRe2PatternError),
222
223    #[error(transparent)]
224    InvalidCompoundIndexError(InvalidCompoundIndexError),
225
226    #[error(transparent)]
227    InvalidDataContractIdError(InvalidDataContractIdError),
228
229    #[error(transparent)]
230    InvalidIndexedPropertyConstraintError(InvalidIndexedPropertyConstraintError),
231
232    #[error(transparent)]
233    InvalidIndexPropertyTypeError(InvalidIndexPropertyTypeError),
234
235    #[error(transparent)]
236    InvalidJsonSchemaRefError(InvalidJsonSchemaRefError),
237
238    #[error(transparent)]
239    SystemPropertyIndexAlreadyPresentError(SystemPropertyIndexAlreadyPresentError),
240
241    #[error(transparent)]
242    UndefinedIndexPropertyError(UndefinedIndexPropertyError),
243
244    #[error(transparent)]
245    UniqueIndicesLimitReachedError(UniqueIndicesLimitReachedError),
246
247    #[error(transparent)]
248    DuplicateIndexNameError(DuplicateIndexNameError),
249
250    #[error(transparent)]
251    InvalidDataContractVersionError(InvalidDataContractVersionError),
252
253    #[error(transparent)]
254    IncompatibleDataContractSchemaError(IncompatibleDataContractSchemaError),
255
256    #[error(transparent)]
257    DataContractImmutablePropertiesUpdateError(DataContractImmutablePropertiesUpdateError),
258
259    #[error(transparent)]
260    DataContractUniqueIndicesChangedError(DataContractUniqueIndicesChangedError),
261
262    #[error(transparent)]
263    DataContractInvalidIndexDefinitionUpdateError(DataContractInvalidIndexDefinitionUpdateError),
264
265    #[error(transparent)]
266    DataContractHaveNewUniqueIndexError(DataContractHaveNewUniqueIndexError),
267
268    // Document
269    #[error(transparent)]
270    DataContractNotPresentError(DataContractNotPresentError),
271
272    #[error(transparent)]
273    DocumentCreationNotAllowedError(DocumentCreationNotAllowedError),
274
275    #[error(transparent)]
276    DataContractBoundsNotPresentError(DataContractBoundsNotPresentError),
277
278    #[error(transparent)]
279    DuplicateDocumentTransitionsWithIdsError(DuplicateDocumentTransitionsWithIdsError),
280
281    #[error(transparent)]
282    DuplicateDocumentTransitionsWithIndicesError(DuplicateDocumentTransitionsWithIndicesError),
283
284    #[error(transparent)]
285    NonceOutOfBoundsError(NonceOutOfBoundsError),
286
287    #[error(transparent)]
288    InconsistentCompoundIndexDataError(InconsistentCompoundIndexDataError),
289
290    #[error(transparent)]
291    InvalidDocumentTransitionActionError(InvalidDocumentTransitionActionError),
292
293    #[error(transparent)]
294    InvalidDocumentTransitionIdError(InvalidDocumentTransitionIdError),
295
296    #[error(transparent)]
297    InvalidDocumentTypeError(InvalidDocumentTypeError),
298
299    #[error(transparent)]
300    MissingPositionsInDocumentTypePropertiesError(MissingPositionsInDocumentTypePropertiesError),
301
302    #[error(transparent)]
303    MissingDataContractIdBasicError(MissingDataContractIdBasicError),
304
305    #[error(transparent)]
306    MissingDocumentTransitionActionError(MissingDocumentTransitionActionError),
307
308    #[error(transparent)]
309    MissingDocumentTransitionTypeError(MissingDocumentTransitionTypeError),
310
311    #[error(transparent)]
312    MissingDocumentTypeError(MissingDocumentTypeError),
313
314    #[error(transparent)]
315    MaxDocumentsTransitionsExceededError(MaxDocumentsTransitionsExceededError),
316
317    // Identity
318    #[error(transparent)]
319    DuplicatedIdentityPublicKeyBasicError(DuplicatedIdentityPublicKeyBasicError),
320
321    #[error(transparent)]
322    DuplicatedIdentityPublicKeyIdBasicError(DuplicatedIdentityPublicKeyIdBasicError),
323
324    #[error(transparent)]
325    DisablingKeyIdAlsoBeingAddedInSameTransitionError(
326        DisablingKeyIdAlsoBeingAddedInSameTransitionError,
327    ),
328
329    #[error(transparent)]
330    IdentityAssetLockProofLockedTransactionMismatchError(
331        IdentityAssetLockProofLockedTransactionMismatchError,
332    ),
333
334    #[error(transparent)]
335    IdentityAssetLockTransactionIsNotFoundError(IdentityAssetLockTransactionIsNotFoundError),
336
337    #[error(transparent)]
338    IdentityAssetLockTransactionOutPointAlreadyConsumedError(
339        IdentityAssetLockTransactionOutPointAlreadyConsumedError,
340    ),
341
342    #[error(transparent)]
343    IdentityAssetLockTransactionOutPointNotEnoughBalanceError(
344        IdentityAssetLockTransactionOutPointNotEnoughBalanceError,
345    ),
346
347    #[error(transparent)]
348    IdentityAssetLockStateTransitionReplayError(IdentityAssetLockStateTransitionReplayError),
349
350    #[error(transparent)]
351    IdentityAssetLockTransactionOutputNotFoundError(
352        IdentityAssetLockTransactionOutputNotFoundError,
353    ),
354
355    #[error(transparent)]
356    InvalidAssetLockProofCoreChainHeightError(InvalidAssetLockProofCoreChainHeightError),
357
358    #[error(transparent)]
359    InvalidIdentityAssetLockProofChainLockValidationError(
360        InvalidIdentityAssetLockProofChainLockValidationError,
361    ),
362
363    #[error(transparent)]
364    InvalidAssetLockProofTransactionHeightError(InvalidAssetLockProofTransactionHeightError),
365
366    #[error(transparent)]
367    InvalidAssetLockTransactionOutputReturnSizeError(
368        InvalidAssetLockTransactionOutputReturnSizeError,
369    ),
370
371    #[error(transparent)]
372    InvalidIdentityAssetLockTransactionError(InvalidIdentityAssetLockTransactionError),
373
374    #[error(transparent)]
375    InvalidIdentityAssetLockTransactionOutputError(InvalidIdentityAssetLockTransactionOutputError),
376
377    #[error(transparent)]
378    InvalidIdentityPublicKeyDataError(InvalidIdentityPublicKeyDataError),
379
380    #[error(transparent)]
381    InvalidInstantAssetLockProofError(InvalidInstantAssetLockProofError),
382
383    #[error(transparent)]
384    InvalidInstantAssetLockProofSignatureError(InvalidInstantAssetLockProofSignatureError),
385
386    #[error(transparent)]
387    MissingMasterPublicKeyError(MissingMasterPublicKeyError),
388
389    #[error(transparent)]
390    TooManyMasterPublicKeyError(TooManyMasterPublicKeyError),
391
392    #[error(transparent)]
393    MasterPublicKeyUpdateError(MasterPublicKeyUpdateError),
394
395    #[error(transparent)]
396    InvalidDocumentTypeRequiredSecurityLevelError(InvalidDocumentTypeRequiredSecurityLevelError),
397
398    #[error(transparent)]
399    InvalidIdentityPublicKeySecurityLevelError(InvalidIdentityPublicKeySecurityLevelError),
400
401    #[error(transparent)]
402    InvalidIdentityKeySignatureError(InvalidIdentityKeySignatureError),
403
404    #[error(transparent)]
405    InvalidIdentityCreditTransferAmountError(InvalidIdentityCreditTransferAmountError),
406
407    #[error(transparent)]
408    InvalidCreditWithdrawalTransitionOutputScriptError(
409        InvalidCreditWithdrawalTransitionOutputScriptError,
410    ),
411
412    #[error(transparent)]
413    WithdrawalOutputScriptNotAllowedWhenSigningWithOwnerKeyError(
414        WithdrawalOutputScriptNotAllowedWhenSigningWithOwnerKeyError,
415    ),
416
417    #[error(transparent)]
418    InvalidCreditWithdrawalTransitionCoreFeeError(InvalidCreditWithdrawalTransitionCoreFeeError),
419
420    #[error(transparent)]
421    InvalidIdentityCreditWithdrawalTransitionAmountError(
422        InvalidIdentityCreditWithdrawalTransitionAmountError,
423    ),
424
425    #[error(transparent)]
426    InvalidIdentityUpdateTransitionEmptyError(InvalidIdentityUpdateTransitionEmptyError),
427
428    #[error(transparent)]
429    InvalidIdentityUpdateTransitionDisableKeysError(
430        InvalidIdentityUpdateTransitionDisableKeysError,
431    ),
432
433    #[error(transparent)]
434    NotImplementedCreditWithdrawalTransitionPoolingError(
435        NotImplementedCreditWithdrawalTransitionPoolingError,
436    ),
437
438    // State Transition
439    #[error(transparent)]
440    InvalidStateTransitionTypeError(InvalidStateTransitionTypeError),
441
442    #[error(transparent)]
443    MissingStateTransitionTypeError(MissingStateTransitionTypeError),
444
445    #[error(transparent)]
446    DocumentFieldMaxSizeExceededError(DocumentFieldMaxSizeExceededError),
447
448    #[error(transparent)]
449    StateTransitionMaxSizeExceededError(StateTransitionMaxSizeExceededError),
450
451    #[error(transparent)]
452    DocumentTransitionsAreAbsentError(DocumentTransitionsAreAbsentError),
453
454    #[error(transparent)]
455    IdentityCreditTransferToSelfError(IdentityCreditTransferToSelfError),
456
457    #[error(transparent)]
458    InvalidDocumentTypeNameError(InvalidDocumentTypeNameError),
459
460    #[error(transparent)]
461    IncompatibleDocumentTypeSchemaError(IncompatibleDocumentTypeSchemaError),
462
463    #[error(transparent)]
464    ContestedUniqueIndexOnMutableDocumentTypeError(ContestedUniqueIndexOnMutableDocumentTypeError),
465
466    #[error(transparent)]
467    ContestedUniqueIndexWithUniqueIndexError(ContestedUniqueIndexWithUniqueIndexError),
468
469    #[error(transparent)]
470    OverflowError(OverflowError),
471
472    #[error(transparent)]
473    UnsupportedFeatureError(UnsupportedFeatureError),
474
475    #[error(transparent)]
476    ContestedDocumentsTemporarilyNotAllowedError(ContestedDocumentsTemporarilyNotAllowedError),
477
478    #[error(transparent)]
479    DataContractTokenConfigurationUpdateError(DataContractTokenConfigurationUpdateError),
480
481    #[error(transparent)]
482    NonContiguousContractTokenPositionsError(NonContiguousContractTokenPositionsError),
483
484    #[error(transparent)]
485    NonContiguousContractGroupPositionsError(NonContiguousContractGroupPositionsError),
486
487    #[error(transparent)]
488    InvalidTokenBaseSupplyError(InvalidTokenBaseSupplyError),
489
490    #[error(transparent)]
491    InvalidTokenIdError(InvalidTokenIdError),
492
493    #[error(transparent)]
494    InvalidTokenAmountError(InvalidTokenAmountError),
495
496    #[error(transparent)]
497    InvalidTokenPositionError(InvalidTokenPositionError),
498
499    #[error(transparent)]
500    InvalidTokenConfigUpdateNoChangeError(InvalidTokenConfigUpdateNoChangeError),
501
502    #[error(transparent)]
503    InvalidTokenDistributionFunctionDivideByZeroError(
504        InvalidTokenDistributionFunctionDivideByZeroError,
505    ),
506
507    #[error(transparent)]
508    InvalidTokenDistributionFunctionInvalidParameterError(
509        InvalidTokenDistributionFunctionInvalidParameterError,
510    ),
511
512    #[error(transparent)]
513    InvalidTokenDistributionFunctionInvalidParameterTupleError(
514        InvalidTokenDistributionFunctionInvalidParameterTupleError,
515    ),
516
517    #[error(transparent)]
518    InvalidTokenDistributionFunctionIncoherenceError(
519        InvalidTokenDistributionFunctionIncoherenceError,
520    ),
521
522    #[error(transparent)]
523    TokenTransferToOurselfError(TokenTransferToOurselfError),
524
525    #[error(transparent)]
526    InvalidTokenNoteTooBigError(InvalidTokenNoteTooBigError),
527
528    #[error(transparent)]
529    ContractHasNoTokensError(ContractHasNoTokensError),
530
531    #[error(transparent)]
532    GroupPositionDoesNotExistError(GroupPositionDoesNotExistError),
533
534    #[error(transparent)]
535    InvalidActionIdError(InvalidActionIdError),
536
537    #[error(transparent)]
538    DestinationIdentityForTokenMintingNotSetError(DestinationIdentityForTokenMintingNotSetError),
539
540    #[error(transparent)]
541    ChoosingTokenMintRecipientNotAllowedError(ChoosingTokenMintRecipientNotAllowedError),
542
543    #[error(transparent)]
544    GroupActionNotAllowedOnTransitionError(GroupActionNotAllowedOnTransitionError),
545
546    #[error(transparent)]
547    GroupExceedsMaxMembersError(GroupExceedsMaxMembersError),
548
549    #[error(transparent)]
550    GroupMemberHasPowerOfZeroError(GroupMemberHasPowerOfZeroError),
551
552    #[error(transparent)]
553    GroupMemberHasPowerOverLimitError(GroupMemberHasPowerOverLimitError),
554
555    #[error(transparent)]
556    GroupTotalPowerLessThanRequiredError(GroupTotalPowerLessThanRequiredError),
557
558    #[error(transparent)]
559    GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError(
560        GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError,
561    ),
562
563    #[error(transparent)]
564    MissingDefaultLocalizationError(MissingDefaultLocalizationError),
565
566    #[error(transparent)]
567    UnknownGasFeesPaidByError(UnknownGasFeesPaidByError),
568
569    #[error(transparent)]
570    UnknownDocumentActionTokenEffectError(UnknownDocumentActionTokenEffectError),
571
572    #[error(transparent)]
573    TokenPaymentByBurningOnlyAllowedOnInternalTokenError(
574        TokenPaymentByBurningOnlyAllowedOnInternalTokenError,
575    ),
576
577    #[error(transparent)]
578    TooManyKeywordsError(TooManyKeywordsError),
579
580    #[error(transparent)]
581    DuplicateKeywordsError(DuplicateKeywordsError),
582
583    #[error(transparent)]
584    InvalidKeywordLengthError(InvalidKeywordLengthError),
585
586    #[error(transparent)]
587    InvalidDescriptionLengthError(InvalidDescriptionLengthError),
588
589    #[error(transparent)]
590    NewTokensDestinationIdentityOptionRequiredError(
591        NewTokensDestinationIdentityOptionRequiredError,
592    ),
593
594    #[error(transparent)]
595    InvalidKeywordCharacterError(InvalidKeywordCharacterError),
596
597    #[error(transparent)]
598    InvalidTokenNameCharacterError(InvalidTokenNameCharacterError),
599
600    #[error(transparent)]
601    DecimalsOverLimitError(DecimalsOverLimitError),
602
603    #[error(transparent)]
604    InvalidTokenNameLengthError(InvalidTokenNameLengthError),
605
606    #[error(transparent)]
607    InvalidTokenLanguageCodeError(InvalidTokenLanguageCodeError),
608
609    #[error(transparent)]
610    MainGroupIsNotDefinedError(MainGroupIsNotDefinedError),
611
612    #[error(transparent)]
613    GroupRequiredPowerIsInvalidError(GroupRequiredPowerIsInvalidError),
614
615    #[error(transparent)]
616    TokenNoteOnlyAllowedWhenProposerError(TokenNoteOnlyAllowedWhenProposerError),
617
618    #[error(transparent)]
619    InvalidTokenDistributionBlockIntervalTooShortError(
620        InvalidTokenDistributionBlockIntervalTooShortError,
621    ),
622
623    #[error(transparent)]
624    InvalidTokenDistributionTimeIntervalTooShortError(
625        InvalidTokenDistributionTimeIntervalTooShortError,
626    ),
627
628    #[error(transparent)]
629    InvalidTokenDistributionTimeIntervalNotMinuteAlignedError(
630        InvalidTokenDistributionTimeIntervalNotMinuteAlignedError,
631    ),
632
633    #[error(transparent)]
634    RedundantDocumentPaidForByTokenWithContractId(RedundantDocumentPaidForByTokenWithContractId),
635
636    #[error(transparent)]
637    GroupHasTooFewMembersError(GroupHasTooFewMembersError),
638
639    #[error(transparent)]
640    InvalidKeyPurposeForContractBoundsError(InvalidKeyPurposeForContractBoundsError),
641
642    #[error(transparent)]
643    StateTransitionNotActiveError(StateTransitionNotActiveError),
644
645    #[error(transparent)]
646    TransitionOverMaxInputsError(TransitionOverMaxInputsError),
647
648    #[error(transparent)]
649    TransitionOverMaxOutputsError(TransitionOverMaxOutputsError),
650
651    #[error(transparent)]
652    InputWitnessCountMismatchError(InputWitnessCountMismatchError),
653
654    #[error(transparent)]
655    TransitionNoInputsError(TransitionNoInputsError),
656
657    #[error(transparent)]
658    TransitionNoOutputsError(TransitionNoOutputsError),
659
660    #[error(transparent)]
661    InvalidRemainderOutputCountError(InvalidRemainderOutputCountError),
662
663    #[error(transparent)]
664    FeeStrategyEmptyError(FeeStrategyEmptyError),
665
666    #[error(transparent)]
667    FeeStrategyDuplicateError(FeeStrategyDuplicateError),
668
669    #[error(transparent)]
670    FeeStrategyIndexOutOfBoundsError(FeeStrategyIndexOutOfBoundsError),
671
672    #[error(transparent)]
673    FeeStrategyTooManyStepsError(FeeStrategyTooManyStepsError),
674
675    #[error(transparent)]
676    InputBelowMinimumError(InputBelowMinimumError),
677
678    #[error(transparent)]
679    OutputBelowMinimumError(OutputBelowMinimumError),
680
681    #[error(transparent)]
682    InputOutputBalanceMismatchError(InputOutputBalanceMismatchError),
683
684    #[error(transparent)]
685    OutputsNotGreaterThanInputsError(OutputsNotGreaterThanInputsError),
686
687    #[error(transparent)]
688    WithdrawalBalanceMismatchError(WithdrawalBalanceMismatchError),
689
690    #[error(transparent)]
691    WithdrawalBelowMinAmountError(WithdrawalBelowMinAmountError),
692
693    #[error(transparent)]
694    InsufficientFundingAmountError(InsufficientFundingAmountError),
695
696    #[error(transparent)]
697    InputsNotLessThanOutputsError(InputsNotLessThanOutputsError),
698
699    #[error(transparent)]
700    OutputAddressAlsoInputError(OutputAddressAlsoInputError),
701
702    #[error(transparent)]
703    ShieldedNoActionsError(ShieldedNoActionsError),
704
705    #[error(transparent)]
706    ShieldedTooManyActionsError(ShieldedTooManyActionsError),
707
708    #[error(transparent)]
709    ShieldedEmptyProofError(ShieldedEmptyProofError),
710
711    #[error(transparent)]
712    ShieldedZeroAnchorError(ShieldedZeroAnchorError),
713
714    #[error(transparent)]
715    ShieldedInvalidValueBalanceError(ShieldedInvalidValueBalanceError),
716
717    #[error(transparent)]
718    ShieldedEncryptedNoteSizeMismatchError(ShieldedEncryptedNoteSizeMismatchError),
719
720    #[error(transparent)]
721    IdentityAssetLockTransactionTooManyInputsError(IdentityAssetLockTransactionTooManyInputsError),
722
723    // NOTE: `BasicError` is bincode-encoded positionally (no explicit discriminants), so new
724    // variants MUST be appended at the tail — inserting mid-enum would shift the wire discriminants
725    // of every following variant and mis-decode previously-encoded errors. The error-code integer
726    // (codes.rs) is independent of variant order.
727    #[error(transparent)]
728    ShieldedImplicitFeeCapExceededError(ShieldedImplicitFeeCapExceededError),
729
730    #[error(transparent)]
731    ShieldedInvalidDenominationError(ShieldedInvalidDenominationError),
732
733    #[error(transparent)]
734    TokenPricingScheduleEmptyError(TokenPricingScheduleEmptyError),
735
736    #[error(transparent)]
737    DataContractInvalidRequiredFieldsUpdateError(DataContractInvalidRequiredFieldsUpdateError),
738
739    // Contract groups (protocol version 14).
740    #[error(transparent)]
741    ContractGroupMembershipsOverLimitError(ContractGroupMembershipsOverLimitError),
742
743    #[error(transparent)]
744    DuplicateContractGroupMembershipError(DuplicateContractGroupMembershipError),
745
746    #[error(transparent)]
747    RedundantContractGroupMembershipError(RedundantContractGroupMembershipError),
748
749    #[error(transparent)]
750    ContractGroupMemberNotInContractError(ContractGroupMemberNotInContractError),
751
752    #[error(transparent)]
753    InvalidContractGroupAdminsError(InvalidContractGroupAdminsError),
754
755    #[error(transparent)]
756    InvalidContractGroupNameLengthError(InvalidContractGroupNameLengthError),
757
758    #[error(transparent)]
759    InvalidContractGroupDescriptionLengthError(InvalidContractGroupDescriptionLengthError),
760
761    // Contract group bounds on identity keys (protocol version 14).
762    #[error(transparent)]
763    ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationError(
764        ContractGroupBoundKeyNotAllowedInShieldedIdentityCreationError,
765    ),
766
767    // Authentication key limits (protocol version 14).
768    #[error(transparent)]
769    IdentityPublicKeyLimitsNotAllowedError(IdentityPublicKeyLimitsNotAllowedError),
770
771    #[error(transparent)]
772    InvalidIdentityPublicKeyBudgetError(InvalidIdentityPublicKeyBudgetError),
773
774    #[error(transparent)]
775    IdentityPublicKeyLimitsNotAllowedInShieldedIdentityCreationError(
776        IdentityPublicKeyLimitsNotAllowedInShieldedIdentityCreationError,
777    ),
778
779    // Identity key limits update (protocol version 14).
780    #[error(transparent)]
781    IdentityKeyLimitsUpdateEmptyError(IdentityKeyLimitsUpdateEmptyError),
782
783    // Once-per-identity token distribution (protocol version 14).
784    #[error(transparent)]
785    InvalidTokenOncePerIdentityDistributionAmountError(
786        InvalidTokenOncePerIdentityDistributionAmountError,
787    ),
788
789    // Pre-programmed distribution amounts (protocol version 14).
790    #[error(transparent)]
791    PreProgrammedDistributionAmountOverLimitError(PreProgrammedDistributionAmountOverLimitError),
792
793    // Contract moderation (protocol version 14).
794    #[error(transparent)]
795    InvalidContractModerationConfigError(InvalidContractModerationConfigError),
796
797    #[error(transparent)]
798    ContractModerationSelfTargetError(ContractModerationSelfTargetError),
799
800    #[error(transparent)]
801    ContractModerationReasonTooLongError(ContractModerationReasonTooLongError),
802
803    // Document action fees (protocol version 14).
804    #[error(transparent)]
805    DocumentActionFeesWithoutModerationError(DocumentActionFeesWithoutModerationError),
806
807    // Documents cited by a contract moderation reason (protocol version 14).
808    #[error(transparent)]
809    InvalidContractModerationReasonDocumentsError(InvalidContractModerationReasonDocumentsError),
810
811    #[error(transparent)]
812    DocumentPropertyNotDistinctError(DocumentPropertyNotDistinctError),
813
814    // The shape of an `encryptedFor` property's ciphertext (protocol version 14).
815    #[error(transparent)]
816    InvalidEncryptedPropertyShapeError(InvalidEncryptedPropertyShapeError),
817
818    // Moderation charters (protocol version 14).
819    #[error(transparent)]
820    ModerationCharterMalformedFieldError(ModerationCharterMalformedFieldError),
821
822    #[error(transparent)]
823    ModerationCharterRewardSplitNotOneHundredError(ModerationCharterRewardSplitNotOneHundredError),
824
825    // A string over the `maxBytes` its property declares (protocol version 14).
826    #[error(transparent)]
827    DocumentPropertyMaxBytesExceededError(DocumentPropertyMaxBytesExceededError),
828
829    // A document breaking a rule of its type's `propertyConstraints` (protocol version 14).
830    #[error(transparent)]
831    DocumentPropertyConstraintViolatedError(DocumentPropertyConstraintViolatedError),
832
833    // A perpetual distribution with a zero epoch interval (protocol version 14). Appended here:
834    // it was first inserted mid-enum, which shifted the discriminant of every variant shipped
835    // after it in 4.1.
836    #[error(transparent)]
837    InvalidTokenDistributionEpochIntervalTooShortError(
838        InvalidTokenDistributionEpochIntervalTooShortError,
839    ),
840
841    // A `generatedFrom` string property that is not what its function generates from its params
842    // (protocol version 14).
843    #[error(transparent)]
844    DocumentPropertyNotGeneratedError(DocumentPropertyNotGeneratedError),
845
846    // The fields a moderator's document change sets (protocol version 14).
847    #[error(transparent)]
848    InvalidContractModerationDocumentFieldsError(InvalidContractModerationDocumentFieldsError),
849
850    // A create that cannot assemble the preimage of a `refersTo` lookup key it reveals
851    // (protocol version 14).
852    #[error(transparent)]
853    DocumentReferencePreimageInvalidError(DocumentReferencePreimageInvalidError),
854
855    // A token opting into a shielded pool keeps no freeze rules (protocol version 14).
856    #[error(transparent)]
857    TokenShieldedPoolIncompatibleRulesError(TokenShieldedPoolIncompatibleRulesError),
858
859    // A non-transferable token cannot have a shielded pool (protocol version 14).
860    #[error(transparent)]
861    NonTransferableTokenShieldedPoolError(NonTransferableTokenShieldedPoolError),
862
863    // A document type pays its contract's own non-transferable token to the contract owner
864    // instead of burning it (protocol version 14).
865    #[error(transparent)]
866    NonTransferableTokenPaymentMustBurnError(NonTransferableTokenPaymentMustBurnError),
867}
868
869impl From<BasicError> for ConsensusError {
870    fn from(error: BasicError) -> Self {
871        Self::BasicError(error)
872    }
873}
874
875#[cfg(test)]
876mod tests {
877    use super::*;
878    use crate::consensus::basic::document::PropertyConstraintViolation;
879    use platform_value::Identifier;
880
881    /// `BasicError` is bincode-encoded positionally, so a variant inserted anywhere but the tail
882    /// shifts the wire discriminant of every variant after it. These are the frozen
883    /// discriminants of the last variants: a new variant goes after them, and gets its own
884    /// line here.
885    fn discriminant_of(error: BasicError) -> u32 {
886        let bytes = bincode::encode_to_vec(error, bincode::config::standard())
887            .expect("expected to encode the basic error");
888        let (discriminant, _): (u32, usize) =
889            bincode::decode_from_slice(&bytes, bincode::config::standard())
890                .expect("expected to decode the discriminant");
891        discriminant
892    }
893
894    #[test]
895    fn basic_error_tail_discriminants_are_frozen() {
896        // Identity key limits update (protocol version 14).
897        assert_eq!(
898            discriminant_of(BasicError::IdentityKeyLimitsUpdateEmptyError(
899                IdentityKeyLimitsUpdateEmptyError::new(1)
900            )),
901            185
902        );
903        // Once-per-identity token distribution (protocol version 14).
904        assert_eq!(
905            discriminant_of(
906                BasicError::InvalidTokenOncePerIdentityDistributionAmountError(
907                    InvalidTokenOncePerIdentityDistributionAmountError::new(0, 1)
908                )
909            ),
910            186
911        );
912        // Pre-programmed distribution amounts (protocol version 14).
913        assert_eq!(
914            discriminant_of(BasicError::PreProgrammedDistributionAmountOverLimitError(
915                PreProgrammedDistributionAmountOverLimitError::new(0, 100)
916            )),
917            187
918        );
919        // Contract moderation (protocol version 14).
920        assert_eq!(
921            discriminant_of(BasicError::InvalidContractModerationConfigError(
922                InvalidContractModerationConfigError::new("reason".to_string())
923            )),
924            188
925        );
926        assert_eq!(
927            discriminant_of(BasicError::ContractModerationSelfTargetError(
928                ContractModerationSelfTargetError::new(Identifier::from([1; 32]))
929            )),
930            189
931        );
932        assert_eq!(
933            discriminant_of(BasicError::ContractModerationReasonTooLongError(
934                ContractModerationReasonTooLongError::new(1025, 1024)
935            )),
936            190
937        );
938        // Document action fees (protocol version 14).
939        assert_eq!(
940            discriminant_of(BasicError::DocumentActionFeesWithoutModerationError(
941                DocumentActionFeesWithoutModerationError::new("post".to_string())
942            )),
943            191
944        );
945        // Documents cited by a contract moderation reason (protocol version 14).
946        assert_eq!(
947            discriminant_of(BasicError::InvalidContractModerationReasonDocumentsError(
948                InvalidContractModerationReasonDocumentsError::new("x".to_string())
949            )),
950            192
951        );
952        // A `distinctFrom` identifier property equal to what it must differ from (protocol
953        // version 14).
954        assert_eq!(
955            discriminant_of(BasicError::DocumentPropertyNotDistinctError(
956                DocumentPropertyNotDistinctError::new(
957                    "post".to_string(),
958                    "delegateId".to_string(),
959                    "$ownerId".to_string(),
960                )
961            )),
962            193
963        );
964        // The shape of an `encryptedFor` property's ciphertext (protocol version 14).
965        assert_eq!(
966            discriminant_of(BasicError::InvalidEncryptedPropertyShapeError(
967                InvalidEncryptedPropertyShapeError::new(
968                    "encryptedMessage".to_string(),
969                    "ecdh-secp256k1-aes256-cbc".to_string(),
970                    47,
971                    32,
972                    16
973                )
974            )),
975            194
976        );
977        // Moderation charters (protocol version 14).
978        assert_eq!(
979            discriminant_of(BasicError::ModerationCharterMalformedFieldError(
980                ModerationCharterMalformedFieldError::new(
981                    "rewardSplit".to_string(),
982                    "reason".to_string()
983                )
984            )),
985            195
986        );
987        assert_eq!(
988            discriminant_of(BasicError::ModerationCharterRewardSplitNotOneHundredError(
989                ModerationCharterRewardSplitNotOneHundredError::new(10, 40, 40)
990            )),
991            196
992        );
993        // A string over its property's `maxBytes` (protocol version 14).
994        assert_eq!(
995            discriminant_of(BasicError::DocumentPropertyMaxBytesExceededError(
996                DocumentPropertyMaxBytesExceededError::new("description".to_string(), 4097, 4096)
997            )),
998            197
999        );
1000        // A document breaking a rule of its type's `propertyConstraints` (protocol version 14).
1001        assert_eq!(
1002            discriminant_of(BasicError::DocumentPropertyConstraintViolatedError(
1003                DocumentPropertyConstraintViolatedError::new(
1004                    "order".to_string(),
1005                    "depositCoversOrder".to_string(),
1006                    PropertyConstraintViolation::NotMet,
1007                )
1008            )),
1009            198
1010        );
1011        // A perpetual distribution with a zero epoch interval (protocol version 14).
1012        assert_eq!(
1013            discriminant_of(
1014                BasicError::InvalidTokenDistributionEpochIntervalTooShortError(
1015                    InvalidTokenDistributionEpochIntervalTooShortError::new(0)
1016                )
1017            ),
1018            199
1019        );
1020        // A `generatedFrom` property that is not what its function generates (protocol
1021        // version 14).
1022        assert_eq!(
1023            discriminant_of(BasicError::DocumentPropertyNotGeneratedError(
1024                DocumentPropertyNotGeneratedError::new(
1025                    "domain".to_string(),
1026                    "normalizedLabel".to_string(),
1027                    "sys.stringTransformations.homographSafeASCII".to_string(),
1028                    vec!["label".to_string()],
1029                )
1030            )),
1031            200
1032        );
1033        // The fields a moderator's document change sets (protocol version 14).
1034        assert_eq!(
1035            discriminant_of(BasicError::InvalidContractModerationDocumentFieldsError(
1036                InvalidContractModerationDocumentFieldsError::new("no field".to_string())
1037            )),
1038            201
1039        );
1040        // A create that cannot assemble the preimage of a `refersTo` lookup key it reveals
1041        // (protocol version 14).
1042        assert_eq!(
1043            discriminant_of(BasicError::DocumentReferencePreimageInvalidError(
1044                DocumentReferencePreimageInvalidError::new(
1045                    "domain".to_string(),
1046                    "$creatorId".to_string(),
1047                    "normalizedLabel".to_string(),
1048                    "reason".to_string(),
1049                )
1050            )),
1051            202
1052        );
1053        // A token opting into a shielded pool keeps no freeze rules (protocol version 14).
1054        assert_eq!(
1055            discriminant_of(BasicError::TokenShieldedPoolIncompatibleRulesError(
1056                TokenShieldedPoolIncompatibleRulesError::new(0, "freezeRules".to_string())
1057            )),
1058            203
1059        );
1060        // A non-transferable token with a shielded pool (protocol version 14).
1061        assert_eq!(
1062            discriminant_of(BasicError::NonTransferableTokenShieldedPoolError(
1063                NonTransferableTokenShieldedPoolError::new(0)
1064            )),
1065            204
1066        );
1067        // A document type paying its own non-transferable token to the contract owner
1068        // (protocol version 14): the tail of the enum.
1069        assert_eq!(
1070            discriminant_of(BasicError::NonTransferableTokenPaymentMustBurnError(
1071                NonTransferableTokenPaymentMustBurnError::new(0, "create".to_string())
1072            )),
1073            205
1074        );
1075    }
1076
1077    /// The variants that shipped in 4.1 keep the discriminants they were released with, so an
1078    /// SDK built against 4.1 decodes the errors of a newer node as the same variants. A variant
1079    /// inserted anywhere before the tail moves these and fails this test.
1080    #[test]
1081    fn should_keep_the_discriminants_shipped_in_4_1() {
1082        assert_eq!(
1083            discriminant_of(BasicError::RedundantDocumentPaidForByTokenWithContractId(
1084                RedundantDocumentPaidForByTokenWithContractId::new(Identifier::from([1; 32]))
1085            )),
1086            140
1087        );
1088        // The last variant released in 4.1.
1089        assert_eq!(
1090            discriminant_of(BasicError::TokenPricingScheduleEmptyError(
1091                TokenPricingScheduleEmptyError::new(Identifier::from([1; 32]))
1092            )),
1093            172
1094        );
1095    }
1096}