diff --git a/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs b/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs index 943f61990d4..afb5c44312c 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs @@ -61,13 +61,13 @@ use crate::consensus::basic::identity::{ InvalidIdentityAssetLockProofChainLockValidationError, InvalidIdentityAssetLockTransactionError, InvalidIdentityAssetLockTransactionOutputError, InvalidIdentityCreditTransferAmountError, InvalidIdentityCreditWithdrawalTransitionAmountError, - InvalidIdentityCreditWithdrawalTransitionCoreFeeError, - InvalidIdentityCreditWithdrawalTransitionOutputScriptError, InvalidIdentityKeySignatureError, + InvalidCreditWithdrawalTransitionCoreFeeError, + InvalidCreditWithdrawalTransitionOutputScriptError, InvalidIdentityKeySignatureError, InvalidIdentityPublicKeyDataError, InvalidIdentityPublicKeySecurityLevelError, InvalidIdentityUpdateTransitionDisableKeysError, InvalidIdentityUpdateTransitionEmptyError, InvalidInstantAssetLockProofError, InvalidInstantAssetLockProofSignatureError, InvalidKeyPurposeForContractBoundsError, MissingMasterPublicKeyError, - NotImplementedIdentityCreditWithdrawalTransitionPoolingError, TooManyMasterPublicKeyError, + NotImplementedCreditWithdrawalTransitionPoolingError, TooManyMasterPublicKeyError, WithdrawalOutputScriptNotAllowedWhenSigningWithOwnerKeyError, }; use crate::consensus::basic::invalid_identifier_error::InvalidIdentifierError; @@ -364,8 +364,8 @@ pub enum BasicError { InvalidIdentityCreditTransferAmountError(InvalidIdentityCreditTransferAmountError), #[error(transparent)] - InvalidIdentityCreditWithdrawalTransitionOutputScriptError( - InvalidIdentityCreditWithdrawalTransitionOutputScriptError, + InvalidCreditWithdrawalTransitionOutputScriptError( + InvalidCreditWithdrawalTransitionOutputScriptError, ), #[error(transparent)] @@ -374,8 +374,8 @@ pub enum BasicError { ), #[error(transparent)] - InvalidIdentityCreditWithdrawalTransitionCoreFeeError( - InvalidIdentityCreditWithdrawalTransitionCoreFeeError, + InvalidCreditWithdrawalTransitionCoreFeeError( + InvalidCreditWithdrawalTransitionCoreFeeError, ), #[error(transparent)] @@ -392,8 +392,8 @@ pub enum BasicError { ), #[error(transparent)] - NotImplementedIdentityCreditWithdrawalTransitionPoolingError( - NotImplementedIdentityCreditWithdrawalTransitionPoolingError, + NotImplementedCreditWithdrawalTransitionPoolingError( + NotImplementedCreditWithdrawalTransitionPoolingError, ), // State Transition diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_core_fee_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_core_fee_error.rs similarity index 72% rename from packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_core_fee_error.rs rename to packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_core_fee_error.rs index 2c3be767a38..3610843d8ea 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_core_fee_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_core_fee_error.rs @@ -12,7 +12,7 @@ use bincode::{Decode, Encode}; )] #[error("Core fee per byte {core_fee_per_byte:?} must be part of fibonacci sequence and not less than {min_core_fee_per_byte:?}")] #[platform_serialize(unversioned)] -pub struct InvalidIdentityCreditWithdrawalTransitionCoreFeeError { +pub struct InvalidCreditWithdrawalTransitionCoreFeeError { /* DO NOT CHANGE ORDER OF FIELDS WITHOUT INTRODUCING OF NEW VERSION @@ -22,7 +22,7 @@ pub struct InvalidIdentityCreditWithdrawalTransitionCoreFeeError { min_core_fee_per_byte: u32, } -impl InvalidIdentityCreditWithdrawalTransitionCoreFeeError { +impl InvalidCreditWithdrawalTransitionCoreFeeError { pub fn new(core_fee_per_byte: u32, min_core_fee_per_byte: u32) -> Self { Self { core_fee_per_byte, @@ -38,8 +38,8 @@ impl InvalidIdentityCreditWithdrawalTransitionCoreFeeError { } } -impl From for ConsensusError { - fn from(err: InvalidIdentityCreditWithdrawalTransitionCoreFeeError) -> Self { - Self::BasicError(BasicError::InvalidIdentityCreditWithdrawalTransitionCoreFeeError(err)) +impl From for ConsensusError { + fn from(err: InvalidCreditWithdrawalTransitionCoreFeeError) -> Self { + Self::BasicError(BasicError::InvalidCreditWithdrawalTransitionCoreFeeError(err)) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_output_script_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_output_script_error.rs similarity index 68% rename from packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_output_script_error.rs rename to packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_output_script_error.rs index 9af57eb8be4..c6d84b64f74 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_output_script_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_output_script_error.rs @@ -13,7 +13,7 @@ use bincode::{Decode, Encode}; )] #[error("Output script must be either p2pkh or p2sh")] #[platform_serialize(unversioned)] -pub struct InvalidIdentityCreditWithdrawalTransitionOutputScriptError { +pub struct InvalidCreditWithdrawalTransitionOutputScriptError { output_script: CoreScript, } @@ -23,7 +23,7 @@ DO NOT CHANGE ORDER OF FIELDS WITHOUT INTRODUCING OF NEW VERSION */ -impl InvalidIdentityCreditWithdrawalTransitionOutputScriptError { +impl InvalidCreditWithdrawalTransitionOutputScriptError { pub fn new(output_script: CoreScript) -> Self { Self { output_script } } @@ -33,10 +33,10 @@ impl InvalidIdentityCreditWithdrawalTransitionOutputScriptError { self.output_script.clone() } } -impl From for ConsensusError { - fn from(err: InvalidIdentityCreditWithdrawalTransitionOutputScriptError) -> Self { +impl From for ConsensusError { + fn from(err: InvalidCreditWithdrawalTransitionOutputScriptError) -> Self { Self::BasicError( - BasicError::InvalidIdentityCreditWithdrawalTransitionOutputScriptError(err), + BasicError::InvalidCreditWithdrawalTransitionOutputScriptError(err), ) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/mod.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/mod.rs index 953a31a65e9..1a2c3b8d8cc 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/mod.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/mod.rs @@ -17,8 +17,8 @@ pub use invalid_identity_asset_lock_transaction_error::*; pub use invalid_identity_asset_lock_transaction_output_error::*; pub use invalid_identity_credit_transfer_amount_error::*; pub use invalid_identity_credit_withdrawal_transition_amount_error::*; -pub use invalid_identity_credit_withdrawal_transition_core_fee_error::*; -pub use invalid_identity_credit_withdrawal_transition_output_script_error::*; +pub use invalid_credit_withdrawal_transition_core_fee_error::*; +pub use invalid_credit_withdrawal_transition_output_script_error::*; pub use invalid_identity_key_signature_error::*; pub use invalid_identity_public_key_data_error::*; pub use invalid_identity_public_key_security_level_error::*; @@ -28,7 +28,7 @@ pub use invalid_instant_asset_lock_proof_error::*; pub use invalid_instant_asset_lock_proof_signature_error::*; pub use invalid_key_purpose_for_contract_bounds_error::*; pub use missing_master_public_key_error::*; -pub use not_implemented_identity_credit_withdrawal_transition_pooling_error::*; +pub use not_implemented_credit_withdrawal_transition_pooling_error::*; pub use too_many_master_public_key_error::*; pub use withdrawal_output_script_not_allowed_when_signing_with_owner_key::*; @@ -52,8 +52,8 @@ mod invalid_identity_asset_lock_transaction_error; mod invalid_identity_asset_lock_transaction_output_error; mod invalid_identity_credit_transfer_amount_error; mod invalid_identity_credit_withdrawal_transition_amount_error; -mod invalid_identity_credit_withdrawal_transition_core_fee_error; -mod invalid_identity_credit_withdrawal_transition_output_script_error; +mod invalid_credit_withdrawal_transition_core_fee_error; +mod invalid_credit_withdrawal_transition_output_script_error; mod invalid_identity_key_signature_error; mod invalid_identity_public_key_data_error; mod invalid_identity_public_key_security_level_error; @@ -63,6 +63,6 @@ mod invalid_instant_asset_lock_proof_error; mod invalid_instant_asset_lock_proof_signature_error; mod invalid_key_purpose_for_contract_bounds_error; mod missing_master_public_key_error; -mod not_implemented_identity_credit_withdrawal_transition_pooling_error; +mod not_implemented_credit_withdrawal_transition_pooling_error; mod too_many_master_public_key_error; mod withdrawal_output_script_not_allowed_when_signing_with_owner_key; diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/not_implemented_identity_credit_withdrawal_transition_pooling_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/not_implemented_credit_withdrawal_transition_pooling_error.rs similarity index 65% rename from packages/rs-dpp/src/errors/consensus/basic/identity/not_implemented_identity_credit_withdrawal_transition_pooling_error.rs rename to packages/rs-dpp/src/errors/consensus/basic/identity/not_implemented_credit_withdrawal_transition_pooling_error.rs index bd3b92d5301..7a80e58175c 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/not_implemented_identity_credit_withdrawal_transition_pooling_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/not_implemented_credit_withdrawal_transition_pooling_error.rs @@ -14,7 +14,7 @@ use bincode::{Decode, Encode}; "pooling {pooling:?} should be equal to 0. Other pooling mechanism are not implemented yet" )] #[platform_serialize(unversioned)] -pub struct NotImplementedIdentityCreditWithdrawalTransitionPoolingError { +pub struct NotImplementedCreditWithdrawalTransitionPoolingError { /* DO NOT CHANGE ORDER OF FIELDS WITHOUT INTRODUCING OF NEW VERSION @@ -23,7 +23,7 @@ pub struct NotImplementedIdentityCreditWithdrawalTransitionPoolingError { pooling: u8, } -impl NotImplementedIdentityCreditWithdrawalTransitionPoolingError { +impl NotImplementedCreditWithdrawalTransitionPoolingError { pub fn new(pooling: u8) -> Self { Self { pooling } } @@ -33,10 +33,10 @@ impl NotImplementedIdentityCreditWithdrawalTransitionPoolingError { } } -impl From for ConsensusError { - fn from(err: NotImplementedIdentityCreditWithdrawalTransitionPoolingError) -> Self { +impl From for ConsensusError { + fn from(err: NotImplementedCreditWithdrawalTransitionPoolingError) -> Self { Self::BasicError( - BasicError::NotImplementedIdentityCreditWithdrawalTransitionPoolingError(err), + BasicError::NotImplementedCreditWithdrawalTransitionPoolingError(err), ) } } diff --git a/packages/rs-dpp/src/errors/consensus/codes.rs b/packages/rs-dpp/src/errors/consensus/codes.rs index 3f8aa4449d6..ff7c6b5a561 100644 --- a/packages/rs-dpp/src/errors/consensus/codes.rs +++ b/packages/rs-dpp/src/errors/consensus/codes.rs @@ -189,9 +189,9 @@ impl ErrorWithCode for BasicError { Self::TooManyMasterPublicKeyError(_) => 10518, Self::InvalidIdentityPublicKeySecurityLevelError(_) => 10519, Self::InvalidIdentityKeySignatureError { .. } => 10520, - Self::InvalidIdentityCreditWithdrawalTransitionOutputScriptError(_) => 10521, - Self::InvalidIdentityCreditWithdrawalTransitionCoreFeeError(_) => 10522, - Self::NotImplementedIdentityCreditWithdrawalTransitionPoolingError(_) => 10523, + Self::InvalidCreditWithdrawalTransitionOutputScriptError(_) => 10521, + Self::InvalidCreditWithdrawalTransitionCoreFeeError(_) => 10522, + Self::NotImplementedCreditWithdrawalTransitionPoolingError(_) => 10523, Self::InvalidIdentityCreditTransferAmountError(_) => 10524, Self::InvalidIdentityCreditWithdrawalTransitionAmountError(_) => 10525, Self::InvalidIdentityUpdateTransitionEmptyError(_) => 10526, diff --git a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/v0/state_transition_validation.rs b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/v0/state_transition_validation.rs index b7de3b25711..4dfb8270fe6 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/v0/state_transition_validation.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/v0/state_transition_validation.rs @@ -1,4 +1,9 @@ use crate::address_funds::AddressFundsFeeStrategyStep; +use crate::consensus::basic::identity::{ + InvalidCreditWithdrawalTransitionCoreFeeError, + InvalidCreditWithdrawalTransitionOutputScriptError, + NotImplementedCreditWithdrawalTransitionPoolingError, +}; use crate::consensus::basic::overflow_error::OverflowError; use crate::consensus::basic::state_transition::{ FeeStrategyDuplicateError, FeeStrategyEmptyError, FeeStrategyIndexOutOfBoundsError, @@ -8,8 +13,11 @@ use crate::consensus::basic::state_transition::{ }; use crate::consensus::basic::BasicError; use crate::state_transition::address_credit_withdrawal_transition::v0::AddressCreditWithdrawalTransitionV0; +use crate::state_transition::address_credit_withdrawal_transition::MIN_CORE_FEE_PER_BYTE; use crate::state_transition::StateTransitionStructureValidation; +use crate::util::is_fibonacci_number::is_fibonacci_number; use crate::validation::SimpleConsensusValidationResult; +use crate::withdrawal::Pooling; use platform_version::version::PlatformVersion; use std::collections::HashSet; @@ -166,6 +174,36 @@ impl StateTransitionStructureValidation for AddressCreditWithdrawalTransitionV0 // Note: The withdrawal amount is implicitly input_sum - output_sum // No explicit balance check needed here as the withdrawal amount is computed, not specified + // Validate pooling - currently we do not support pooling, so we must validate that pooling is `Never` + if self.pooling != Pooling::Never { + return SimpleConsensusValidationResult::new_with_error( + NotImplementedCreditWithdrawalTransitionPoolingError::new( + self.pooling as u8, + ) + .into(), + ); + } + + // Validate core_fee_per_byte is a Fibonacci number + if !is_fibonacci_number(self.core_fee_per_byte as u64) { + return SimpleConsensusValidationResult::new_with_error( + InvalidCreditWithdrawalTransitionCoreFeeError::new( + self.core_fee_per_byte, + MIN_CORE_FEE_PER_BYTE, + ) + .into(), + ); + } + + // Validate output_script is P2PKH or P2SH + if !self.output_script.is_p2pkh() && !self.output_script.is_p2sh() { + return SimpleConsensusValidationResult::new_with_error( + InvalidCreditWithdrawalTransitionOutputScriptError::new( + self.output_script.clone(), + ) + .into(), + ); + } // Validate input sum doesn't overflow let input_sum = self .inputs diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_credit_withdrawal/tests.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_credit_withdrawal/tests.rs index d76123ea52b..df66642a66d 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_credit_withdrawal/tests.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_credit_withdrawal/tests.rs @@ -600,6 +600,297 @@ mod tests { error ); } + + // ========================================== + // Withdrawal-specific validation tests + // ========================================== + + #[test] + fn test_pooling_not_never_returns_error() { + use dpp::state_transition::StateTransitionStructureValidation; + + let platform_version = PlatformVersion::latest(); + + let mut rng = StdRng::seed_from_u64(567); + + let mut inputs = BTreeMap::new(); + inputs.insert( + create_platform_address(1), + (1 as AddressNonce, dash_to_credits!(1.0)), + ); + + // Pooling set to Standard instead of Never + let transition = AddressCreditWithdrawalTransitionV0 { + inputs, + output: None, + fee_strategy: AddressFundsFeeStrategy::from(vec![ + AddressFundsFeeStrategyStep::DeductFromInput(0), + ]), + core_fee_per_byte: 1, + pooling: Pooling::Standard, + output_script: create_random_output_script(&mut rng), + user_fee_increase: 0, + input_witnesses: vec![create_dummy_witness()], + }; + + let result = transition.validate_structure(platform_version); + assert!(!result.is_valid()); + let error = result.first_error().unwrap(); + assert!( + matches!( + error, + ConsensusError::BasicError( + BasicError::NotImplementedCreditWithdrawalTransitionPoolingError(_) + ) + ), + "Expected NotImplementedCreditWithdrawalTransitionPoolingError, got {:?}", + error + ); + } + + #[test] + fn test_core_fee_per_byte_not_fibonacci_returns_error() { + use dpp::state_transition::StateTransitionStructureValidation; + + let platform_version = PlatformVersion::latest(); + + let mut rng = StdRng::seed_from_u64(567); + + let mut inputs = BTreeMap::new(); + inputs.insert( + create_platform_address(1), + (1 as AddressNonce, dash_to_credits!(1.0)), + ); + + // core_fee_per_byte set to 4 which is not a Fibonacci number (1, 1, 2, 3, 5, 8, ...) + let transition = AddressCreditWithdrawalTransitionV0 { + inputs, + output: None, + fee_strategy: AddressFundsFeeStrategy::from(vec![ + AddressFundsFeeStrategyStep::DeductFromInput(0), + ]), + core_fee_per_byte: 4, // Not a Fibonacci number + pooling: Pooling::Never, + output_script: create_random_output_script(&mut rng), + user_fee_increase: 0, + input_witnesses: vec![create_dummy_witness()], + }; + + let result = transition.validate_structure(platform_version); + assert!(!result.is_valid()); + let error = result.first_error().unwrap(); + assert!( + matches!( + error, + ConsensusError::BasicError( + BasicError::InvalidCreditWithdrawalTransitionCoreFeeError(_) + ) + ), + "Expected InvalidCreditWithdrawalTransitionCoreFeeError, got {:?}", + error + ); + } + + #[test] + fn test_core_fee_per_byte_zero_returns_error() { + use dpp::state_transition::StateTransitionStructureValidation; + + let platform_version = PlatformVersion::latest(); + + let mut rng = StdRng::seed_from_u64(567); + + let mut inputs = BTreeMap::new(); + inputs.insert( + create_platform_address(1), + (1 as AddressNonce, dash_to_credits!(1.0)), + ); + + // core_fee_per_byte set to 0 + let transition = AddressCreditWithdrawalTransitionV0 { + inputs, + output: None, + fee_strategy: AddressFundsFeeStrategy::from(vec![ + AddressFundsFeeStrategyStep::DeductFromInput(0), + ]), + core_fee_per_byte: 0, // Invalid - 0 is not Fibonacci + pooling: Pooling::Never, + output_script: create_random_output_script(&mut rng), + user_fee_increase: 0, + input_witnesses: vec![create_dummy_witness()], + }; + + let result = transition.validate_structure(platform_version); + assert!(!result.is_valid()); + let error = result.first_error().unwrap(); + assert!( + matches!( + error, + ConsensusError::BasicError( + BasicError::InvalidCreditWithdrawalTransitionCoreFeeError(_) + ) + ), + "Expected InvalidCreditWithdrawalTransitionCoreFeeError, got {:?}", + error + ); + } + + #[test] + fn test_output_script_not_p2pkh_or_p2sh_returns_error() { + use dpp::state_transition::StateTransitionStructureValidation; + + let platform_version = PlatformVersion::latest(); + + let mut inputs = BTreeMap::new(); + inputs.insert( + create_platform_address(1), + (1 as AddressNonce, dash_to_credits!(1.0)), + ); + + // Create an invalid output script (empty script is not P2PKH or P2SH) + let invalid_output_script = CoreScript::new(ScriptBuf::new()); + + let transition = AddressCreditWithdrawalTransitionV0 { + inputs, + output: None, + fee_strategy: AddressFundsFeeStrategy::from(vec![ + AddressFundsFeeStrategyStep::DeductFromInput(0), + ]), + core_fee_per_byte: 1, + pooling: Pooling::Never, + output_script: invalid_output_script, + user_fee_increase: 0, + input_witnesses: vec![create_dummy_witness()], + }; + + let result = transition.validate_structure(platform_version); + assert!(!result.is_valid()); + let error = result.first_error().unwrap(); + assert!( + matches!( + error, + ConsensusError::BasicError( + BasicError::InvalidCreditWithdrawalTransitionOutputScriptError(_) + ) + ), + "Expected InvalidCreditWithdrawalTransitionOutputScriptError, got {:?}", + error + ); + } + + #[test] + fn test_output_script_op_return_returns_error() { + use dpp::state_transition::StateTransitionStructureValidation; + + let platform_version = PlatformVersion::latest(); + + let mut inputs = BTreeMap::new(); + inputs.insert( + create_platform_address(1), + (1 as AddressNonce, dash_to_credits!(1.0)), + ); + + // Create an OP_RETURN script (not P2PKH or P2SH) + let op_return_script = CoreScript::new(ScriptBuf::from(vec![OP_RETURN, 0x04, 0x01, 0x02, 0x03, 0x04])); + + let transition = AddressCreditWithdrawalTransitionV0 { + inputs, + output: None, + fee_strategy: AddressFundsFeeStrategy::from(vec![ + AddressFundsFeeStrategyStep::DeductFromInput(0), + ]), + core_fee_per_byte: 1, + pooling: Pooling::Never, + output_script: op_return_script, + user_fee_increase: 0, + input_witnesses: vec![create_dummy_witness()], + }; + + let result = transition.validate_structure(platform_version); + assert!(!result.is_valid()); + let error = result.first_error().unwrap(); + assert!( + matches!( + error, + ConsensusError::BasicError( + BasicError::InvalidCreditWithdrawalTransitionOutputScriptError(_) + ) + ), + "Expected InvalidCreditWithdrawalTransitionOutputScriptError, got {:?}", + error + ); + } + + #[test] + fn test_valid_withdrawal_passes_structure_validation() { + use dpp::state_transition::StateTransitionStructureValidation; + + let platform_version = PlatformVersion::latest(); + + let mut rng = StdRng::seed_from_u64(567); + + let mut inputs = BTreeMap::new(); + inputs.insert( + create_platform_address(1), + (1 as AddressNonce, dash_to_credits!(1.0)), + ); + + let transition = AddressCreditWithdrawalTransitionV0 { + inputs, + output: None, + fee_strategy: AddressFundsFeeStrategy::from(vec![ + AddressFundsFeeStrategyStep::DeductFromInput(0), + ]), + core_fee_per_byte: 1, // Valid Fibonacci number + pooling: Pooling::Never, + output_script: create_random_output_script(&mut rng), // P2PKH script + user_fee_increase: 0, + input_witnesses: vec![create_dummy_witness()], + }; + + let result = transition.validate_structure(platform_version); + assert!(result.is_valid(), "Expected valid result, got errors: {:?}", result.errors); + } + + #[test] + fn test_valid_fibonacci_core_fees_pass_validation() { + use dpp::state_transition::StateTransitionStructureValidation; + + let platform_version = PlatformVersion::latest(); + + let mut rng = StdRng::seed_from_u64(567); + + // Test various valid Fibonacci numbers: 1, 2, 3, 5, 8, 13, 21 + let fibonacci_numbers = vec![1u32, 2, 3, 5, 8, 13, 21]; + + for fib in fibonacci_numbers { + let mut inputs = BTreeMap::new(); + inputs.insert( + create_platform_address(1), + (1 as AddressNonce, dash_to_credits!(1.0)), + ); + + let transition = AddressCreditWithdrawalTransitionV0 { + inputs, + output: None, + fee_strategy: AddressFundsFeeStrategy::from(vec![ + AddressFundsFeeStrategyStep::DeductFromInput(0), + ]), + core_fee_per_byte: fib, + pooling: Pooling::Never, + output_script: create_random_output_script(&mut rng), + user_fee_increase: 0, + input_witnesses: vec![create_dummy_witness()], + }; + + let result = transition.validate_structure(platform_version); + assert!( + result.is_valid(), + "Expected valid result for Fibonacci number {}, got errors: {:?}", + fib, + result.errors + ); + } + } } // ========================================== diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/mod.rs index 90d7f68499d..57e7db27fe7 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/mod.rs @@ -2,8 +2,6 @@ mod advanced_structure; mod basic_structure; pub(crate) mod public_key_signatures; mod state; -#[cfg(test)] -mod tests; use crate::error::execution::ExecutionError; use crate::error::Error; diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_credit_withdrawal/structure/v1/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_credit_withdrawal/structure/v1/mod.rs index f3898d0b0dd..d8f721e3774 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_credit_withdrawal/structure/v1/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_credit_withdrawal/structure/v1/mod.rs @@ -1,8 +1,8 @@ use dpp::consensus::basic::identity::{ + InvalidCreditWithdrawalTransitionCoreFeeError, + InvalidCreditWithdrawalTransitionOutputScriptError, InvalidIdentityCreditWithdrawalTransitionAmountError, - InvalidIdentityCreditWithdrawalTransitionCoreFeeError, - InvalidIdentityCreditWithdrawalTransitionOutputScriptError, - NotImplementedIdentityCreditWithdrawalTransitionPoolingError, + NotImplementedCreditWithdrawalTransitionPoolingError, }; use dpp::consensus::ConsensusError; @@ -46,7 +46,7 @@ impl IdentityCreditWithdrawalStateTransitionStructureValidationV1 if self.pooling() != Pooling::Never { result.add_error( - NotImplementedIdentityCreditWithdrawalTransitionPoolingError::new( + NotImplementedCreditWithdrawalTransitionPoolingError::new( self.pooling() as u8 ), ); @@ -56,7 +56,7 @@ impl IdentityCreditWithdrawalStateTransitionStructureValidationV1 // validate core_fee is in fibonacci sequence if !is_fibonacci_number(self.core_fee_per_byte() as u64) { - result.add_error(InvalidIdentityCreditWithdrawalTransitionCoreFeeError::new( + result.add_error(InvalidCreditWithdrawalTransitionCoreFeeError::new( self.core_fee_per_byte(), MIN_CORE_FEE_PER_BYTE, )); @@ -68,7 +68,7 @@ impl IdentityCreditWithdrawalStateTransitionStructureValidationV1 // validate output_script types if !output_script.is_p2pkh() && !output_script.is_p2sh() { result.add_error( - InvalidIdentityCreditWithdrawalTransitionOutputScriptError::new( + InvalidCreditWithdrawalTransitionOutputScriptError::new( output_script.clone(), ), ); @@ -193,7 +193,7 @@ mod tests { assert_matches!( result.errors.as_slice(), [ConsensusError::BasicError( - BasicError::NotImplementedIdentityCreditWithdrawalTransitionPoolingError(err), + BasicError::NotImplementedCreditWithdrawalTransitionPoolingError(err), )] if err.pooling() == Pooling::Standard as u8 ); } @@ -222,7 +222,7 @@ mod tests { assert_matches!( result.errors.as_slice(), [ConsensusError::BasicError( - BasicError::InvalidIdentityCreditWithdrawalTransitionCoreFeeError(err) + BasicError::InvalidCreditWithdrawalTransitionCoreFeeError(err) )] if err.min_core_fee_per_byte() == 1 && err.core_fee_per_byte() == 0 ); } @@ -253,7 +253,7 @@ mod tests { assert_matches!( result.errors.as_slice(), [ConsensusError::BasicError( - BasicError::InvalidIdentityCreditWithdrawalTransitionOutputScriptError(err) + BasicError::InvalidCreditWithdrawalTransitionOutputScriptError(err) )] if err.output_script() == output_script ); } diff --git a/packages/wasm-dpp/lib/errors/patchConsensusErrors.ts b/packages/wasm-dpp/lib/errors/patchConsensusErrors.ts index f9b2445b1bf..f65ea6969c9 100644 --- a/packages/wasm-dpp/lib/errors/patchConsensusErrors.ts +++ b/packages/wasm-dpp/lib/errors/patchConsensusErrors.ts @@ -92,9 +92,9 @@ export function patchConsensusErrors() { // extend(dpp_module.DuplicatedIdentityPublicKeyError, AbstractConsensusError); // extend(dpp_module.DuplicatedIdentityPublicKeyIdError, AbstractConsensusError); // extend(dpp_module.IdentityInsufficientBalanceError, AbstractConsensusError); - // extend(dpp_module.InvalidIdentityCreditWithdrawalTransitionCoreFeeError, AbstractConsensusError); - // extend(dpp_module.InvalidIdentityCreditWithdrawalTransitionOutputScriptError, AbstractConsensusError); - // extend(dpp_module.NotImplementedIdentityCreditWithdrawalTransitionPoolingError, AbstractConsensusError); + // extend(dpp_module.InvalidCreditWithdrawalTransitionCoreFeeError, AbstractConsensusError); + // extend(dpp_module.InvalidCreditWithdrawalTransitionOutputScriptError, AbstractConsensusError); + // extend(dpp_module.NotImplementedCreditWithdrawalTransitionPoolingError, AbstractConsensusError); // extend(dpp_module.DuplicatedIdentityPublicKeyIdStateError, AbstractConsensusError); // extend(dpp_module.DuplicatedIdentityPublicKeyStateError, AbstractConsensusError); } diff --git a/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_core_fee_error.rs b/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_core_fee_error.rs new file mode 100644 index 00000000000..02d3fd5b6a9 --- /dev/null +++ b/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_core_fee_error.rs @@ -0,0 +1,36 @@ +use dpp::consensus::basic::identity::InvalidCreditWithdrawalTransitionCoreFeeError; +use dpp::consensus::codes::ErrorWithCode; +use dpp::consensus::ConsensusError; + +use wasm_bindgen::prelude::*; + +#[wasm_bindgen(js_name=InvalidCreditWithdrawalTransitionCoreFeeError)] +pub struct InvalidCreditWithdrawalTransitionCoreFeeErrorWasm { + inner: InvalidCreditWithdrawalTransitionCoreFeeError, +} + +impl From<&InvalidCreditWithdrawalTransitionCoreFeeError> + for InvalidCreditWithdrawalTransitionCoreFeeErrorWasm +{ + fn from(e: &InvalidCreditWithdrawalTransitionCoreFeeError) -> Self { + Self { inner: e.clone() } + } +} + +#[wasm_bindgen(js_class=InvalidCreditWithdrawalTransitionCoreFeeError)] +impl InvalidCreditWithdrawalTransitionCoreFeeErrorWasm { + #[wasm_bindgen(js_name=getCoreFee)] + pub fn core_fee_per_byte(&self) -> u32 { + self.inner.core_fee_per_byte() + } + + #[wasm_bindgen(js_name=getCode)] + pub fn get_code(&self) -> u32 { + ConsensusError::from(self.inner.clone()).code() + } + + #[wasm_bindgen(getter)] + pub fn message(&self) -> String { + self.inner.to_string() + } +} diff --git a/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_output_script_error.rs b/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_output_script_error.rs new file mode 100644 index 00000000000..1615ab34a62 --- /dev/null +++ b/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_output_script_error.rs @@ -0,0 +1,31 @@ +use dpp::consensus::basic::identity::InvalidCreditWithdrawalTransitionOutputScriptError; +use dpp::consensus::codes::ErrorWithCode; +use dpp::consensus::ConsensusError; + +use wasm_bindgen::prelude::*; + +#[wasm_bindgen(js_name=InvalidCreditWithdrawalTransitionOutputScriptError)] +pub struct InvalidCreditWithdrawalTransitionOutputScriptErrorWasm { + inner: InvalidCreditWithdrawalTransitionOutputScriptError, +} + +impl From<&InvalidCreditWithdrawalTransitionOutputScriptError> + for InvalidCreditWithdrawalTransitionOutputScriptErrorWasm +{ + fn from(e: &InvalidCreditWithdrawalTransitionOutputScriptError) -> Self { + Self { inner: e.clone() } + } +} + +#[wasm_bindgen(js_class=InvalidCreditWithdrawalTransitionOutputScriptError)] +impl InvalidCreditWithdrawalTransitionOutputScriptErrorWasm { + #[wasm_bindgen(js_name=getCode)] + pub fn code(&self) -> u32 { + ConsensusError::from(self.inner.clone()).code() + } + + #[wasm_bindgen(getter)] + pub fn message(&self) -> String { + self.inner.to_string() + } +} diff --git a/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_core_fee_error.rs b/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_core_fee_error.rs deleted file mode 100644 index fa0a40a52f2..00000000000 --- a/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_core_fee_error.rs +++ /dev/null @@ -1,36 +0,0 @@ -use dpp::consensus::basic::identity::InvalidIdentityCreditWithdrawalTransitionCoreFeeError; -use dpp::consensus::codes::ErrorWithCode; -use dpp::consensus::ConsensusError; - -use wasm_bindgen::prelude::*; - -#[wasm_bindgen(js_name=InvalidIdentityCreditWithdrawalTransitionCoreFeeError)] -pub struct InvalidIdentityCreditWithdrawalTransitionCoreFeeErrorWasm { - inner: InvalidIdentityCreditWithdrawalTransitionCoreFeeError, -} - -impl From<&InvalidIdentityCreditWithdrawalTransitionCoreFeeError> - for InvalidIdentityCreditWithdrawalTransitionCoreFeeErrorWasm -{ - fn from(e: &InvalidIdentityCreditWithdrawalTransitionCoreFeeError) -> Self { - Self { inner: e.clone() } - } -} - -#[wasm_bindgen(js_class=InvalidIdentityCreditWithdrawalTransitionCoreFeeError)] -impl InvalidIdentityCreditWithdrawalTransitionCoreFeeErrorWasm { - #[wasm_bindgen(js_name=getCoreFee)] - pub fn core_fee_per_byte(&self) -> u32 { - self.inner.core_fee_per_byte() - } - - #[wasm_bindgen(js_name=getCode)] - pub fn get_code(&self) -> u32 { - ConsensusError::from(self.inner.clone()).code() - } - - #[wasm_bindgen(getter)] - pub fn message(&self) -> String { - self.inner.to_string() - } -} diff --git a/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_output_script_error.rs b/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_output_script_error.rs deleted file mode 100644 index 055c644d085..00000000000 --- a/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_output_script_error.rs +++ /dev/null @@ -1,31 +0,0 @@ -use dpp::consensus::basic::identity::InvalidIdentityCreditWithdrawalTransitionOutputScriptError; -use dpp::consensus::codes::ErrorWithCode; -use dpp::consensus::ConsensusError; - -use wasm_bindgen::prelude::*; - -#[wasm_bindgen(js_name=InvalidIdentityCreditWithdrawalTransitionOutputScriptError)] -pub struct InvalidIdentityCreditWithdrawalTransitionOutputScriptErrorWasm { - inner: InvalidIdentityCreditWithdrawalTransitionOutputScriptError, -} - -impl From<&InvalidIdentityCreditWithdrawalTransitionOutputScriptError> - for InvalidIdentityCreditWithdrawalTransitionOutputScriptErrorWasm -{ - fn from(e: &InvalidIdentityCreditWithdrawalTransitionOutputScriptError) -> Self { - Self { inner: e.clone() } - } -} - -#[wasm_bindgen(js_class=InvalidIdentityCreditWithdrawalTransitionOutputScriptError)] -impl InvalidIdentityCreditWithdrawalTransitionOutputScriptErrorWasm { - #[wasm_bindgen(js_name=getCode)] - pub fn code(&self) -> u32 { - ConsensusError::from(self.inner.clone()).code() - } - - #[wasm_bindgen(getter)] - pub fn message(&self) -> String { - self.inner.to_string() - } -} diff --git a/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_pooling_error.rs b/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_pooling_error.rs deleted file mode 100644 index 2fed16a2b97..00000000000 --- a/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_pooling_error.rs +++ /dev/null @@ -1,36 +0,0 @@ -use dpp::consensus::basic::identity::NotImplementedIdentityCreditWithdrawalTransitionPoolingError; -use dpp::consensus::codes::ErrorWithCode; -use dpp::consensus::ConsensusError; - -use wasm_bindgen::prelude::*; - -#[wasm_bindgen(js_name=NotImplementedIdentityCreditWithdrawalTransitionPoolingError)] -pub struct NotImplementedIdentityCreditWithdrawalTransitionPoolingErrorWasm { - inner: NotImplementedIdentityCreditWithdrawalTransitionPoolingError, -} - -impl From<&NotImplementedIdentityCreditWithdrawalTransitionPoolingError> - for NotImplementedIdentityCreditWithdrawalTransitionPoolingErrorWasm -{ - fn from(e: &NotImplementedIdentityCreditWithdrawalTransitionPoolingError) -> Self { - Self { inner: e.clone() } - } -} - -#[wasm_bindgen(js_class=NotImplementedIdentityCreditWithdrawalTransitionPoolingError)] -impl NotImplementedIdentityCreditWithdrawalTransitionPoolingErrorWasm { - #[wasm_bindgen(js_name=getPooling)] - pub fn pooling(&self) -> u8 { - self.inner.pooling() - } - - #[wasm_bindgen(js_name=getCode)] - pub fn code(&self) -> u32 { - ConsensusError::from(self.inner.clone()).code() - } - - #[wasm_bindgen(getter)] - pub fn message(&self) -> String { - self.inner.to_string() - } -} diff --git a/packages/wasm-dpp/src/errors/consensus/basic/identity/mod.rs b/packages/wasm-dpp/src/errors/consensus/basic/identity/mod.rs index 7508eccc970..52991f9d939 100644 --- a/packages/wasm-dpp/src/errors/consensus/basic/identity/mod.rs +++ b/packages/wasm-dpp/src/errors/consensus/basic/identity/mod.rs @@ -15,9 +15,9 @@ mod invalid_identity_asset_lock_proof_chain_lock_validation_error; mod invalid_identity_asset_lock_transaction_error; mod invalid_identity_asset_lock_transaction_output_error; mod invalid_identity_credit_transfer_amount_error; -mod invalid_identity_credit_withdrawal_transition_core_fee_error; -mod invalid_identity_credit_withdrawal_transition_output_script_error; -mod invalid_identity_credit_withdrawal_transition_pooling_error; +mod invalid_credit_withdrawal_transition_core_fee_error; +mod invalid_credit_withdrawal_transition_output_script_error; +mod not_implemented_credit_withdrawal_transition_pooling_error; pub mod invalid_identity_key_signature_error; mod invalid_identity_public_key_data_error; mod invalid_identity_public_key_security_level_error; @@ -44,9 +44,9 @@ pub use invalid_identity_asset_lock_proof_chain_lock_validation_error::*; pub use invalid_identity_asset_lock_transaction_error::*; pub use invalid_identity_asset_lock_transaction_output_error::*; pub use invalid_identity_credit_transfer_amount_error::*; -pub use invalid_identity_credit_withdrawal_transition_core_fee_error::*; -pub use invalid_identity_credit_withdrawal_transition_output_script_error::*; -pub use invalid_identity_credit_withdrawal_transition_pooling_error::*; +pub use invalid_credit_withdrawal_transition_core_fee_error::*; +pub use invalid_credit_withdrawal_transition_output_script_error::*; +pub use not_implemented_credit_withdrawal_transition_pooling_error::*; pub use invalid_identity_key_signature_error::*; pub use invalid_identity_public_key_data_error::*; pub use invalid_identity_public_key_security_level_error::*; diff --git a/packages/wasm-dpp/src/errors/consensus/basic/identity/not_implemented_credit_withdrawal_transition_pooling_error.rs b/packages/wasm-dpp/src/errors/consensus/basic/identity/not_implemented_credit_withdrawal_transition_pooling_error.rs new file mode 100644 index 00000000000..a9b1afcd725 --- /dev/null +++ b/packages/wasm-dpp/src/errors/consensus/basic/identity/not_implemented_credit_withdrawal_transition_pooling_error.rs @@ -0,0 +1,36 @@ +use dpp::consensus::basic::identity::NotImplementedCreditWithdrawalTransitionPoolingError; +use dpp::consensus::codes::ErrorWithCode; +use dpp::consensus::ConsensusError; + +use wasm_bindgen::prelude::*; + +#[wasm_bindgen(js_name=NotImplementedCreditWithdrawalTransitionPoolingError)] +pub struct NotImplementedCreditWithdrawalTransitionPoolingErrorWasm { + inner: NotImplementedCreditWithdrawalTransitionPoolingError, +} + +impl From<&NotImplementedCreditWithdrawalTransitionPoolingError> + for NotImplementedCreditWithdrawalTransitionPoolingErrorWasm +{ + fn from(e: &NotImplementedCreditWithdrawalTransitionPoolingError) -> Self { + Self { inner: e.clone() } + } +} + +#[wasm_bindgen(js_class=NotImplementedCreditWithdrawalTransitionPoolingError)] +impl NotImplementedCreditWithdrawalTransitionPoolingErrorWasm { + #[wasm_bindgen(js_name=getPooling)] + pub fn pooling(&self) -> u8 { + self.inner.pooling() + } + + #[wasm_bindgen(js_name=getCode)] + pub fn code(&self) -> u32 { + ConsensusError::from(self.inner.clone()).code() + } + + #[wasm_bindgen(getter)] + pub fn message(&self) -> String { + self.inner.to_string() + } +} diff --git a/packages/wasm-dpp/src/errors/consensus/consensus_error.rs b/packages/wasm-dpp/src/errors/consensus/consensus_error.rs index 1625934f208..25ddbad6fb7 100644 --- a/packages/wasm-dpp/src/errors/consensus/consensus_error.rs +++ b/packages/wasm-dpp/src/errors/consensus/consensus_error.rs @@ -20,12 +20,12 @@ use crate::errors::consensus::basic::identity::{ InvalidIdentityAssetLockTransactionErrorWasm, InvalidIdentityAssetLockTransactionOutputErrorWasm, InvalidIdentityCreditTransferAmountErrorWasm, - InvalidIdentityCreditWithdrawalTransitionCoreFeeErrorWasm, - InvalidIdentityCreditWithdrawalTransitionOutputScriptErrorWasm, + InvalidCreditWithdrawalTransitionCoreFeeErrorWasm, + InvalidCreditWithdrawalTransitionOutputScriptErrorWasm, InvalidIdentityKeySignatureErrorWasm, InvalidIdentityPublicKeyDataErrorWasm, InvalidIdentityPublicKeySecurityLevelErrorWasm, InvalidInstantAssetLockProofErrorWasm, InvalidInstantAssetLockProofSignatureErrorWasm, MissingMasterPublicKeyErrorWasm, - NotImplementedIdentityCreditWithdrawalTransitionPoolingErrorWasm, + NotImplementedCreditWithdrawalTransitionPoolingErrorWasm, }; use crate::errors::consensus::state::identity::{ @@ -45,11 +45,11 @@ use dpp::consensus::basic::BasicError::{ InvalidIdentityAssetLockProofChainLockValidationError, InvalidIdentityAssetLockTransactionError, InvalidIdentityAssetLockTransactionOutputError, InvalidIdentityCreditTransferAmountError, - InvalidIdentityCreditWithdrawalTransitionCoreFeeError, - InvalidIdentityCreditWithdrawalTransitionOutputScriptError, InvalidIdentityPublicKeyDataError, + InvalidCreditWithdrawalTransitionCoreFeeError, + InvalidCreditWithdrawalTransitionOutputScriptError, InvalidIdentityPublicKeyDataError, InvalidIdentityPublicKeySecurityLevelError, InvalidInstantAssetLockProofError, InvalidInstantAssetLockProofSignatureError, MissingMasterPublicKeyError, - NotImplementedIdentityCreditWithdrawalTransitionPoolingError, ProtocolVersionParsingError, + NotImplementedCreditWithdrawalTransitionPoolingError, ProtocolVersionParsingError, UnsupportedProtocolVersionError, UnsupportedVersionError, }; use dpp::consensus::basic::{BasicError, UnsupportedFeatureError}; @@ -621,14 +621,14 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue { InvalidIdentityCreditTransferAmountError(e) => { InvalidIdentityCreditTransferAmountErrorWasm::from(e).into() } - InvalidIdentityCreditWithdrawalTransitionCoreFeeError(e) => { - InvalidIdentityCreditWithdrawalTransitionCoreFeeErrorWasm::from(e).into() + InvalidCreditWithdrawalTransitionCoreFeeError(e) => { + InvalidCreditWithdrawalTransitionCoreFeeErrorWasm::from(e).into() } - InvalidIdentityCreditWithdrawalTransitionOutputScriptError(e) => { - InvalidIdentityCreditWithdrawalTransitionOutputScriptErrorWasm::from(e).into() + InvalidCreditWithdrawalTransitionOutputScriptError(e) => { + InvalidCreditWithdrawalTransitionOutputScriptErrorWasm::from(e).into() } - NotImplementedIdentityCreditWithdrawalTransitionPoolingError(e) => { - NotImplementedIdentityCreditWithdrawalTransitionPoolingErrorWasm::from(e).into() + NotImplementedCreditWithdrawalTransitionPoolingError(e) => { + NotImplementedCreditWithdrawalTransitionPoolingErrorWasm::from(e).into() } IncompatibleRe2PatternError(err) => IncompatibleRe2PatternErrorWasm::from(err).into(), BasicError::VersionError(err) => generic_consensus_error!(VersionError, err).into(),