From 3d541d6f9c421089056933e8d9eb19b7a0bf80f0 Mon Sep 17 00:00:00 2001 From: "markin.io" Date: Thu, 11 Jan 2024 17:27:30 +0000 Subject: [PATCH 01/13] feat(drive): validate asset lock proof minimal value --- .../test/functional/platform/Identity.spec.js | 18 ++++++++ .../src/errors/consensus/basic/basic_error.rs | 5 ++- .../invalid_asset_lock_proof_value.rs | 43 +++++++++++++++++++ .../errors/consensus/basic/identity/mod.rs | 2 + packages/rs-dpp/src/errors/consensus/codes.rs | 1 + .../v0/mod.rs | 24 ++++++++++- .../invalid_asset_lock_proof_value_error.rs | 39 +++++++++++++++++ .../errors/consensus/basic/identity/mod.rs | 2 + .../src/errors/consensus/consensus_error.rs | 6 ++- 9 files changed, 136 insertions(+), 4 deletions(-) create mode 100644 packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value.rs create mode 100644 packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value_error.rs diff --git a/packages/platform-test-suite/test/functional/platform/Identity.spec.js b/packages/platform-test-suite/test/functional/platform/Identity.spec.js index 3a1bf18e5af..aee90e0dfdd 100644 --- a/packages/platform-test-suite/test/functional/platform/Identity.spec.js +++ b/packages/platform-test-suite/test/functional/platform/Identity.spec.js @@ -22,6 +22,7 @@ const { Identifier, IdentityPublicKey, InvalidInstantAssetLockProofSignatureError, + InvalidAssetLockProofValueError, IdentityAssetLockTransactionOutPointAlreadyExistsError, BasicECDSAError, IdentityPublicKeyWithWitness, @@ -55,6 +56,23 @@ describe('Platform', () => { expect(identity).to.exist(); }); + // TODO: add test for chain asset lock proof as well + it('should fail to create an identity if asset lock amount is less than minimal', async () => { + let broadcastError; + + try { + await client.platform.identities.register(117000); + } catch (e) { + broadcastError = e; + } + + expect(broadcastError).to.be.an.instanceOf(StateTransitionBroadcastError); + expect(broadcastError.getCause().getCode()).to.equal(1049); + expect(broadcastError.getCause()).to.be.an.instanceOf( + InvalidAssetLockProofValueError, + ); + }); + it('should fail to create an identity if instantLock is not valid', async () => { await client.platform.initialize(); 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 f6c463b555f..2d9ebb7447b 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs @@ -33,7 +33,7 @@ use crate::consensus::basic::identity::{ IdentityAssetLockTransactionOutPointAlreadyExistsError, IdentityAssetLockTransactionOutputNotFoundError, IdentityCreditTransferToSelfError, InvalidAssetLockProofCoreChainHeightError, InvalidAssetLockProofTransactionHeightError, - InvalidAssetLockTransactionOutputReturnSizeError, + InvalidAssetLockProofValueError, InvalidAssetLockTransactionOutputReturnSizeError, InvalidIdentityAssetLockProofChainLockValidationError, InvalidIdentityAssetLockTransactionError, InvalidIdentityAssetLockTransactionOutputError, InvalidIdentityCreditTransferAmountError, InvalidIdentityCreditWithdrawalTransitionAmountError, @@ -230,6 +230,9 @@ pub enum BasicError { #[error(transparent)] InvalidAssetLockProofTransactionHeightError(InvalidAssetLockProofTransactionHeightError), + #[error(transparent)] + InvalidAssetLockProofValueError(InvalidAssetLockProofValueError), + #[error(transparent)] InvalidAssetLockTransactionOutputReturnSizeError( InvalidAssetLockTransactionOutputReturnSizeError, diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value.rs new file mode 100644 index 00000000000..305ffc7cf17 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value.rs @@ -0,0 +1,43 @@ +use crate::consensus::basic::BasicError; +use crate::errors::ProtocolError; +use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use thiserror::Error; + +use crate::consensus::ConsensusError; + +use bincode::{Decode, Encode}; + +#[derive( + Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, +)] +#[error("Asset lock value {value:?} must be higher than minimal value of {min_value:?}")] +#[platform_serialize(unversioned)] +pub struct InvalidAssetLockProofValueError { + /* + + DO NOT CHANGE ORDER OF FIELDS WITHOUT INTRODUCING OF NEW VERSION + + */ + value: u64, + min_value: u64, +} + +impl InvalidAssetLockProofValueError { + pub fn new(value: u64, min_value: u64) -> Self { + Self { value, min_value } + } + + pub fn value(&self) -> u64 { + self.value + } + + pub fn min_value(&self) -> u64 { + self.min_value + } +} + +impl From for ConsensusError { + fn from(err: InvalidAssetLockProofValueError) -> Self { + Self::BasicError(BasicError::InvalidAssetLockProofValueError(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 fc70b59971f..8cc995002da 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/mod.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/mod.rs @@ -8,6 +8,7 @@ pub use identity_asset_lock_transaction_output_not_found_error::*; pub use identity_credit_transfer_to_self_error::*; pub use invalid_asset_lock_proof_core_chain_height_error::*; pub use invalid_asset_lock_proof_transaction_height_error::*; +pub use invalid_asset_lock_proof_value::*; pub use invalid_asset_lock_transaction_output_return_size::*; pub use invalid_identity_asset_lock_proof_chain_lock_validation_error::*; pub use invalid_identity_asset_lock_transaction_error::*; @@ -36,6 +37,7 @@ mod identity_asset_lock_transaction_output_not_found_error; mod identity_credit_transfer_to_self_error; mod invalid_asset_lock_proof_core_chain_height_error; mod invalid_asset_lock_proof_transaction_height_error; +mod invalid_asset_lock_proof_value; mod invalid_asset_lock_transaction_output_return_size; mod invalid_identity_asset_lock_proof_chain_lock_validation_error; mod invalid_identity_asset_lock_transaction_error; diff --git a/packages/rs-dpp/src/errors/consensus/codes.rs b/packages/rs-dpp/src/errors/consensus/codes.rs index ea032c311bc..24c7e29f4bd 100644 --- a/packages/rs-dpp/src/errors/consensus/codes.rs +++ b/packages/rs-dpp/src/errors/consensus/codes.rs @@ -89,6 +89,7 @@ impl ErrorWithCode for BasicError { Self::IdentityAssetLockTransactionOutputNotFoundError(_) => 1034, Self::InvalidAssetLockProofCoreChainHeightError(_) => 1035, Self::InvalidAssetLockProofTransactionHeightError(_) => 1036, + Self::InvalidAssetLockProofValueError(_) => 1049, Self::InvalidAssetLockTransactionOutputReturnSizeError(_) => 1037, Self::InvalidIdentityAssetLockTransactionError(_) => 1038, Self::InvalidIdentityAssetLockTransactionOutputError(_) => 1039, diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/common/asset_lock/transaction/fetch_asset_lock_transaction_output_sync/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/common/asset_lock/transaction/fetch_asset_lock_transaction_output_sync/v0/mod.rs index d4e70a394e8..19b1f9579b9 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/common/asset_lock/transaction/fetch_asset_lock_transaction_output_sync/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/common/asset_lock/transaction/fetch_asset_lock_transaction_output_sync/v0/mod.rs @@ -3,7 +3,7 @@ use crate::error::Error; use crate::rpc::core::CoreRPCLike; use dpp::consensus::basic::identity::{ IdentityAssetLockTransactionIsNotFoundError, IdentityAssetLockTransactionOutputNotFoundError, - InvalidAssetLockProofTransactionHeightError, + InvalidAssetLockProofTransactionHeightError, InvalidAssetLockProofValueError, }; use dpp::dashcore::secp256k1::ThirtyTwoByteHash; use dpp::dashcore::transaction::special_transaction::TransactionPayload; @@ -13,6 +13,8 @@ use dpp::prelude::{AssetLockProof, ConsensusValidationResult}; use dpp::validation::ValidationResult; use dpp::version::PlatformVersion; +const MINIMAL_ASSET_LOCK_VALUE: u64 = 120000; + /// This fetches the asset lock transaction output from core pub fn fetch_asset_lock_transaction_output_sync_v0( core_rpc: &C, @@ -22,6 +24,16 @@ pub fn fetch_asset_lock_transaction_output_sync_v0( match asset_lock_proof { AssetLockProof::Instant(proof) => { if let Some(output) = proof.output() { + if output.value < MINIMAL_ASSET_LOCK_VALUE { + return Ok(ConsensusValidationResult::new_with_error( + InvalidAssetLockProofValueError::new( + output.value, + MINIMAL_ASSET_LOCK_VALUE, + ) + .into(), + )); + } + Ok(ValidationResult::new_with_data(output.clone())) } else { Ok(ValidationResult::new_with_error( @@ -115,6 +127,16 @@ pub fn fetch_asset_lock_transaction_output_sync_v0( if payload.credit_outputs.get(output_index as usize).is_some() { let output = payload.credit_outputs.remove(output_index as usize); + if output.value < MINIMAL_ASSET_LOCK_VALUE { + return Ok(ConsensusValidationResult::new_with_error( + InvalidAssetLockProofValueError::new( + output.value, + MINIMAL_ASSET_LOCK_VALUE, + ) + .into(), + )); + } + return Ok(ValidationResult::new_with_data(output)); } } diff --git a/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value_error.rs b/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value_error.rs new file mode 100644 index 00000000000..a48b251deca --- /dev/null +++ b/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value_error.rs @@ -0,0 +1,39 @@ +use dpp::consensus::basic::identity::InvalidAssetLockProofValueError; +use dpp::consensus::codes::ErrorWithCode; +use dpp::consensus::ConsensusError; + +use wasm_bindgen::prelude::*; + +#[wasm_bindgen(js_name=InvalidAssetLockProofValueError)] +pub struct InvalidAssetLockProofValueErrorWasm { + inner: InvalidAssetLockProofValueError, +} + +impl From<&InvalidAssetLockProofValueError> for InvalidAssetLockProofValueErrorWasm { + fn from(e: &InvalidAssetLockProofValueError) -> Self { + Self { inner: e.clone() } + } +} + +#[wasm_bindgen(js_class=InvalidAssetLockProofValueError)] +impl InvalidAssetLockProofValueErrorWasm { + #[wasm_bindgen(js_name=getValue)] + pub fn value(&self) -> u64 { + self.inner.value() + } + + #[wasm_bindgen(js_name=getMinValue)] + pub fn min_value(&self) -> u64 { + self.inner.min_value() + } + + #[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/mod.rs b/packages/wasm-dpp/src/errors/consensus/basic/identity/mod.rs index 87dfbdc1ba6..dc1a57edc2a 100644 --- a/packages/wasm-dpp/src/errors/consensus/basic/identity/mod.rs +++ b/packages/wasm-dpp/src/errors/consensus/basic/identity/mod.rs @@ -8,6 +8,7 @@ mod identity_credit_transfer_to_self_error; mod identity_insufficient_balance_error; mod invalid_asset_lock_proof_core_chain_height_error; mod invalid_asset_lock_proof_transaction_height_error; +mod invalid_asset_lock_proof_value_error; mod invalid_asset_lock_transaction_output_return_size_error; mod invalid_identity_asset_lock_proof_chain_lock_validation_error; mod invalid_identity_asset_lock_transaction_error; @@ -34,6 +35,7 @@ pub use identity_credit_transfer_to_self_error::*; pub use identity_insufficient_balance_error::*; pub use invalid_asset_lock_proof_core_chain_height_error::*; pub use invalid_asset_lock_proof_transaction_height_error::*; +pub use invalid_asset_lock_proof_value_error::*; pub use invalid_asset_lock_transaction_output_return_size_error::*; pub use invalid_identity_asset_lock_proof_chain_lock_validation_error::*; pub use invalid_identity_asset_lock_transaction_error::*; diff --git a/packages/wasm-dpp/src/errors/consensus/consensus_error.rs b/packages/wasm-dpp/src/errors/consensus/consensus_error.rs index 2e88186f207..0c1ddebd324 100644 --- a/packages/wasm-dpp/src/errors/consensus/consensus_error.rs +++ b/packages/wasm-dpp/src/errors/consensus/consensus_error.rs @@ -12,7 +12,7 @@ use crate::errors::consensus::basic::identity::{ IdentityAssetLockTransactionOutPointAlreadyExistsErrorWasm, IdentityAssetLockTransactionOutputNotFoundErrorWasm, IdentityCreditTransferToSelfErrorWasm, IdentityInsufficientBalanceErrorWasm, InvalidAssetLockProofCoreChainHeightErrorWasm, - InvalidAssetLockProofTransactionHeightErrorWasm, + InvalidAssetLockProofTransactionHeightErrorWasm, InvalidAssetLockProofValueErrorWasm, InvalidAssetLockTransactionOutputReturnSizeErrorWasm, InvalidIdentityAssetLockProofChainLockValidationErrorWasm, InvalidIdentityAssetLockTransactionErrorWasm, @@ -37,7 +37,8 @@ use dpp::consensus::basic::BasicError::{ IdentityAssetLockTransactionOutPointAlreadyExistsError, IdentityAssetLockTransactionOutputNotFoundError, IncompatibleProtocolVersionError, IncompatibleRe2PatternError, InvalidAssetLockProofCoreChainHeightError, - InvalidAssetLockProofTransactionHeightError, InvalidAssetLockTransactionOutputReturnSizeError, + InvalidAssetLockProofTransactionHeightError, InvalidAssetLockProofValueError, + InvalidAssetLockTransactionOutputReturnSizeError, InvalidIdentityAssetLockProofChainLockValidationError, InvalidIdentityAssetLockTransactionError, InvalidIdentityAssetLockTransactionOutputError, InvalidIdentityCreditWithdrawalTransitionCoreFeeError, @@ -374,6 +375,7 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue { InvalidAssetLockProofTransactionHeightError(e) => { InvalidAssetLockProofTransactionHeightErrorWasm::from(e).into() } + InvalidAssetLockProofValueError(e) => InvalidAssetLockProofValueErrorWasm::from(e).into(), InvalidIdentityCreditWithdrawalTransitionCoreFeeError(e) => { InvalidIdentityCreditWithdrawalTransitionCoreFeeErrorWasm::from(e).into() } From 4aef04729e41d1e3fc5c61aa3383a3bab713aa86 Mon Sep 17 00:00:00 2001 From: "markin.io" Date: Tue, 16 Jan 2024 19:16:51 +0000 Subject: [PATCH 02/13] feat(drive): versioned minimal amount and provided different values for top up and create --- .../v0/mod.rs | 23 ---------------- .../identity_create/state/v0/mod.rs | 27 +++++++++++++++++++ .../identity_top_up/state/v0/mod.rs | 27 +++++++++++++++++++ 3 files changed, 54 insertions(+), 23 deletions(-) diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/common/asset_lock/transaction/fetch_asset_lock_transaction_output_sync/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/common/asset_lock/transaction/fetch_asset_lock_transaction_output_sync/v0/mod.rs index 19b1f9579b9..c3f023ac2f4 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/common/asset_lock/transaction/fetch_asset_lock_transaction_output_sync/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/common/asset_lock/transaction/fetch_asset_lock_transaction_output_sync/v0/mod.rs @@ -13,8 +13,6 @@ use dpp::prelude::{AssetLockProof, ConsensusValidationResult}; use dpp::validation::ValidationResult; use dpp::version::PlatformVersion; -const MINIMAL_ASSET_LOCK_VALUE: u64 = 120000; - /// This fetches the asset lock transaction output from core pub fn fetch_asset_lock_transaction_output_sync_v0( core_rpc: &C, @@ -24,16 +22,6 @@ pub fn fetch_asset_lock_transaction_output_sync_v0( match asset_lock_proof { AssetLockProof::Instant(proof) => { if let Some(output) = proof.output() { - if output.value < MINIMAL_ASSET_LOCK_VALUE { - return Ok(ConsensusValidationResult::new_with_error( - InvalidAssetLockProofValueError::new( - output.value, - MINIMAL_ASSET_LOCK_VALUE, - ) - .into(), - )); - } - Ok(ValidationResult::new_with_data(output.clone())) } else { Ok(ValidationResult::new_with_error( @@ -126,17 +114,6 @@ pub fn fetch_asset_lock_transaction_output_sync_v0( // We are dealing with old Rust edition so we can't use optional remove if payload.credit_outputs.get(output_index as usize).is_some() { let output = payload.credit_outputs.remove(output_index as usize); - - if output.value < MINIMAL_ASSET_LOCK_VALUE { - return Ok(ConsensusValidationResult::new_with_error( - InvalidAssetLockProofValueError::new( - output.value, - MINIMAL_ASSET_LOCK_VALUE, - ) - .into(), - )); - } - return Ok(ValidationResult::new_with_data(output)); } } diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs index ef090ac682b..5d2496154c8 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs @@ -1,6 +1,7 @@ use crate::error::Error; use crate::platform_types::platform::PlatformRef; use crate::rpc::core::CoreRPCLike; +use dpp::consensus::basic::identity::InvalidAssetLockProofValueError; use dpp::consensus::signature::{BasicECDSAError, SignatureError}; use dpp::consensus::state::identity::IdentityAlreadyExistsError; @@ -32,6 +33,26 @@ use drive::grovedb::TransactionArg; use crate::execution::validation::state_transition::common::asset_lock::transaction::fetch_asset_lock_transaction_output_sync::fetch_asset_lock_transaction_output_sync; use crate::execution::validation::state_transition::common::validate_unique_identity_public_key_hashes_in_state::validate_unique_identity_public_key_hashes_in_state; +#[repr(u64)] +enum MinimalAssetLockValue { + V1 = 120000, +} + +fn minimal_asset_lock_value(platform_version: &PlatformVersion) -> Result { + match platform_version + .drive_abci + .validation_and_processing + .process_state_transition + { + 0 => Ok(MinimalAssetLockValue::V1 as u64), + version => Err(Error::Execution(ExecutionError::UnknownVersionMismatch { + method: "minimal_asset_lock_value".to_string(), + known_versions: vec![0], + received: version, + })), + } +} + pub(in crate::execution::validation::state_transition::state_transitions::identity_create) trait IdentityCreateStateTransitionStateValidationV0 { fn validate_state_v0( @@ -125,6 +146,12 @@ impl IdentityCreateStateTransitionStateValidationV0 for IdentityCreateTransition } let tx_out = tx_out_validation.into_data()?; + let min_value = minimal_asset_lock_value(platform_version)?; + if tx_out.value < min_value { + return Ok(ConsensusValidationResult::new_with_error( + InvalidAssetLockProofValueError::new(tx_out.value, min_value).into(), + )); + } // Verify one time signature diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/state/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/state/v0/mod.rs index 66ece6b365d..7b877a982c8 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/state/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/state/v0/mod.rs @@ -1,6 +1,7 @@ use crate::error::Error; use crate::platform_types::platform::PlatformRef; use crate::rpc::core::CoreRPCLike; +use dpp::consensus::basic::identity::InvalidAssetLockProofValueError; use dpp::consensus::signature::{BasicECDSAError, SignatureError}; use dpp::dashcore::signer; @@ -26,6 +27,26 @@ use crate::execution::types::state_transition_execution_context::{StateTransitio use crate::execution::validation::state_transition::common::asset_lock::proof::validate::AssetLockProofValidation; use crate::execution::validation::state_transition::common::asset_lock::transaction::fetch_asset_lock_transaction_output_sync::fetch_asset_lock_transaction_output_sync; +#[repr(u64)] +enum MinimalAssetLockValue { + V1 = 1000, +} + +fn minimal_asset_lock_value(platform_version: &PlatformVersion) -> Result { + match platform_version + .drive_abci + .validation_and_processing + .process_state_transition + { + 0 => Ok(MinimalAssetLockValue::V1 as u64), + version => Err(Error::Execution(ExecutionError::UnknownVersionMismatch { + method: "minimal_asset_lock_value".to_string(), + known_versions: vec![0], + received: version, + })), + } +} + pub(in crate::execution::validation::state_transition::state_transitions::identity_top_up) trait IdentityTopUpStateTransitionStateValidationV0 { fn validate_state_v0( @@ -88,6 +109,12 @@ impl IdentityTopUpStateTransitionStateValidationV0 for IdentityTopUpTransition { } let tx_out = tx_out_validation.into_data()?; + let min_value = minimal_asset_lock_value(platform_version)?; + if tx_out.value < min_value { + return Ok(ConsensusValidationResult::new_with_error( + InvalidAssetLockProofValueError::new(tx_out.value, min_value).into(), + )); + } // Verify one time signature From 093547264a5d6f45111d6cacb463e29482982d5c Mon Sep 17 00:00:00 2001 From: "markin.io" Date: Tue, 16 Jan 2024 20:04:51 +0000 Subject: [PATCH 03/13] fix(platform-test-suite): asset lock tests --- .../platform-test-suite/test/e2e/dpns.spec.js | 2 +- .../test/functional/platform/Identity.spec.js | 62 ++++++++++++++++++- 2 files changed, 62 insertions(+), 2 deletions(-) diff --git a/packages/platform-test-suite/test/e2e/dpns.spec.js b/packages/platform-test-suite/test/e2e/dpns.spec.js index e8cc3218a48..f5146dfc554 100644 --- a/packages/platform-test-suite/test/e2e/dpns.spec.js +++ b/packages/platform-test-suite/test/e2e/dpns.spec.js @@ -67,7 +67,7 @@ describe('DPNS', () => { identity = await ownerClient.platform.identities.get(dpnsOwnerId); expect(identity).to.exist(); - await ownerClient.platform.identities.topUp(dpnsOwnerId, 500); + await ownerClient.platform.identities.topUp(dpnsOwnerId, 1000); }); after(async () => { diff --git a/packages/platform-test-suite/test/functional/platform/Identity.spec.js b/packages/platform-test-suite/test/functional/platform/Identity.spec.js index aee90e0dfdd..58ecc3db8e6 100644 --- a/packages/platform-test-suite/test/functional/platform/Identity.spec.js +++ b/packages/platform-test-suite/test/functional/platform/Identity.spec.js @@ -255,6 +255,66 @@ describe('Platform', () => { this.timeout(850000); + it('should fail to create an identity if asset lock amount is less than minimal', async () => { + await client.platform.initialize(); + + // Broadcast Asset Lock transaction + const { + transaction, + privateKey, + outputIndex, + } = await client.platform.identities.utils.createAssetLockTransaction(117000); + + const account = await client.getWalletAccount(); + + await account.broadcastTransaction(transaction); + + // Wait for transaction to be mined and chain locked + const { promise: metadataPromise } = walletAccount.waitForTxMetadata(transaction.id); + + const { height: transactionHeight } = await metadataPromise; + + const assetLockProof = await client.platform.dpp.identity.createChainAssetLockProof( + transactionHeight, + transaction.getOutPointBuffer(outputIndex), + ); + + // Wait for platform chain to sync core height up to transaction height + const { + promise: coreHeightPromise, + } = await client.platform.identities.utils + .waitForCoreChainLockedHeight(transactionHeight); + + await coreHeightPromise; + + const identityCreateTransitionData = await client.platform.identities.utils + .createIdentityCreateTransition(assetLockProof, privateKey); + + const { + identityCreateTransition, + } = identityCreateTransitionData; + + ({ identity: chainLockIdentity } = identityCreateTransitionData); + + let broadcastError; + try { + await client.platform.broadcastStateTransition( + identityCreateTransition, + ); + } catch (e) { + broadcastError = e; + } + + expect(broadcastError).to.be.an.instanceOf(StateTransitionBroadcastError); + expect(broadcastError.getCause().getCode()).to.equal(1049); + expect(broadcastError.getCause()).to.be.an.instanceOf( + InvalidAssetLockProofValueError, + ); + + // Additional wait time to mitigate testnet latency + await waitForSTPropagated(); + }); + it('should create identity using chainLock', async () => { await client.platform.initialize(); @@ -458,7 +518,7 @@ describe('Platform', () => { transaction, privateKey, outputIndex, - } = await client.platform.identities.utils.createAssetLockTransaction(1); + } = await client.platform.identities.utils.createAssetLockTransaction(1000); const account = await client.getWalletAccount(); From 5d732a3a7e7d1415258ef554af6e65cac711ae2f Mon Sep 17 00:00:00 2001 From: "markin.io" Date: Tue, 16 Jan 2024 20:05:27 +0000 Subject: [PATCH 04/13] fix(platform-test-suite): asset lock tests --- .../test/functional/platform/Identity.spec.js | 1 - 1 file changed, 1 deletion(-) diff --git a/packages/platform-test-suite/test/functional/platform/Identity.spec.js b/packages/platform-test-suite/test/functional/platform/Identity.spec.js index 58ecc3db8e6..d7770d3f476 100644 --- a/packages/platform-test-suite/test/functional/platform/Identity.spec.js +++ b/packages/platform-test-suite/test/functional/platform/Identity.spec.js @@ -56,7 +56,6 @@ describe('Platform', () => { expect(identity).to.exist(); }); - // TODO: add test for chain asset lock proof as well it('should fail to create an identity if asset lock amount is less than minimal', async () => { let broadcastError; From 70f3c696c3e807de4ae51b9511651913a8c31694 Mon Sep 17 00:00:00 2001 From: "markin.io" Date: Thu, 18 Jan 2024 15:15:10 +0000 Subject: [PATCH 05/13] refactor(dpp): make asset lock value error to be state error --- .../test/functional/platform/Identity.spec.js | 4 ++-- packages/rs-dpp/src/errors/consensus/basic/basic_error.rs | 5 +---- packages/rs-dpp/src/errors/consensus/basic/identity/mod.rs | 2 -- packages/rs-dpp/src/errors/consensus/codes.rs | 2 +- .../identity/invalid_asset_lock_proof_value.rs | 4 ++-- packages/rs-dpp/src/errors/consensus/state/identity/mod.rs | 1 + packages/rs-dpp/src/errors/consensus/state/state_error.rs | 4 ++++ .../fetch_asset_lock_transaction_output_sync/v0/mod.rs | 2 +- .../state_transitions/identity_create/state/v0/mod.rs | 2 +- .../state_transitions/identity_top_up/state/v0/mod.rs | 2 +- 10 files changed, 14 insertions(+), 14 deletions(-) rename packages/rs-dpp/src/errors/consensus/{basic => state}/identity/invalid_asset_lock_proof_value.rs (89%) diff --git a/packages/platform-test-suite/test/functional/platform/Identity.spec.js b/packages/platform-test-suite/test/functional/platform/Identity.spec.js index d7770d3f476..6995ad7d502 100644 --- a/packages/platform-test-suite/test/functional/platform/Identity.spec.js +++ b/packages/platform-test-suite/test/functional/platform/Identity.spec.js @@ -66,7 +66,7 @@ describe('Platform', () => { } expect(broadcastError).to.be.an.instanceOf(StateTransitionBroadcastError); - expect(broadcastError.getCause().getCode()).to.equal(1049); + expect(broadcastError.getCause().getCode()).to.equal(4028); expect(broadcastError.getCause()).to.be.an.instanceOf( InvalidAssetLockProofValueError, ); @@ -305,7 +305,7 @@ describe('Platform', () => { } expect(broadcastError).to.be.an.instanceOf(StateTransitionBroadcastError); - expect(broadcastError.getCause().getCode()).to.equal(1049); + expect(broadcastError.getCause().getCode()).to.equal(4028); expect(broadcastError.getCause()).to.be.an.instanceOf( InvalidAssetLockProofValueError, ); 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 2d9ebb7447b..f6c463b555f 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs @@ -33,7 +33,7 @@ use crate::consensus::basic::identity::{ IdentityAssetLockTransactionOutPointAlreadyExistsError, IdentityAssetLockTransactionOutputNotFoundError, IdentityCreditTransferToSelfError, InvalidAssetLockProofCoreChainHeightError, InvalidAssetLockProofTransactionHeightError, - InvalidAssetLockProofValueError, InvalidAssetLockTransactionOutputReturnSizeError, + InvalidAssetLockTransactionOutputReturnSizeError, InvalidIdentityAssetLockProofChainLockValidationError, InvalidIdentityAssetLockTransactionError, InvalidIdentityAssetLockTransactionOutputError, InvalidIdentityCreditTransferAmountError, InvalidIdentityCreditWithdrawalTransitionAmountError, @@ -230,9 +230,6 @@ pub enum BasicError { #[error(transparent)] InvalidAssetLockProofTransactionHeightError(InvalidAssetLockProofTransactionHeightError), - #[error(transparent)] - InvalidAssetLockProofValueError(InvalidAssetLockProofValueError), - #[error(transparent)] InvalidAssetLockTransactionOutputReturnSizeError( InvalidAssetLockTransactionOutputReturnSizeError, 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 8cc995002da..fc70b59971f 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/mod.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/mod.rs @@ -8,7 +8,6 @@ pub use identity_asset_lock_transaction_output_not_found_error::*; pub use identity_credit_transfer_to_self_error::*; pub use invalid_asset_lock_proof_core_chain_height_error::*; pub use invalid_asset_lock_proof_transaction_height_error::*; -pub use invalid_asset_lock_proof_value::*; pub use invalid_asset_lock_transaction_output_return_size::*; pub use invalid_identity_asset_lock_proof_chain_lock_validation_error::*; pub use invalid_identity_asset_lock_transaction_error::*; @@ -37,7 +36,6 @@ mod identity_asset_lock_transaction_output_not_found_error; mod identity_credit_transfer_to_self_error; mod invalid_asset_lock_proof_core_chain_height_error; mod invalid_asset_lock_proof_transaction_height_error; -mod invalid_asset_lock_proof_value; mod invalid_asset_lock_transaction_output_return_size; mod invalid_identity_asset_lock_proof_chain_lock_validation_error; mod invalid_identity_asset_lock_transaction_error; diff --git a/packages/rs-dpp/src/errors/consensus/codes.rs b/packages/rs-dpp/src/errors/consensus/codes.rs index 24c7e29f4bd..16ba3bd8622 100644 --- a/packages/rs-dpp/src/errors/consensus/codes.rs +++ b/packages/rs-dpp/src/errors/consensus/codes.rs @@ -89,7 +89,6 @@ impl ErrorWithCode for BasicError { Self::IdentityAssetLockTransactionOutputNotFoundError(_) => 1034, Self::InvalidAssetLockProofCoreChainHeightError(_) => 1035, Self::InvalidAssetLockProofTransactionHeightError(_) => 1036, - Self::InvalidAssetLockProofValueError(_) => 1049, Self::InvalidAssetLockTransactionOutputReturnSizeError(_) => 1037, Self::InvalidIdentityAssetLockTransactionError(_) => 1038, Self::InvalidIdentityAssetLockTransactionOutputError(_) => 1039, @@ -178,6 +177,7 @@ impl ErrorWithCode for StateError { Self::MissingIdentityPublicKeyIdsError { .. } => 4024, Self::IdentityInsufficientBalanceError(_) => 4026, Self::IdentityPublicKeyAlreadyExistsForUniqueContractBoundsError(_) => 4027, + Self::InvalidAssetLockProofValueError(_) => 4028, } } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value.rs b/packages/rs-dpp/src/errors/consensus/state/identity/invalid_asset_lock_proof_value.rs similarity index 89% rename from packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value.rs rename to packages/rs-dpp/src/errors/consensus/state/identity/invalid_asset_lock_proof_value.rs index 305ffc7cf17..9e4326620b3 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/invalid_asset_lock_proof_value.rs @@ -1,10 +1,10 @@ -use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; use thiserror::Error; use crate::consensus::ConsensusError; +use crate::consensus::state::state_error::StateError; use bincode::{Decode, Encode}; #[derive( @@ -38,6 +38,6 @@ impl InvalidAssetLockProofValueError { impl From for ConsensusError { fn from(err: InvalidAssetLockProofValueError) -> Self { - Self::BasicError(BasicError::InvalidAssetLockProofValueError(err)) + Self::StateError(StateError::InvalidAssetLockProofValueError(err)) } } diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/mod.rs b/packages/rs-dpp/src/errors/consensus/state/identity/mod.rs index 01ec04bb52a..0aaa101f6c8 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/mod.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/mod.rs @@ -9,6 +9,7 @@ pub mod identity_public_key_already_exists_for_unique_contract_bounds_error; pub mod identity_public_key_disabled_at_window_violation_error; pub mod identity_public_key_is_disabled_error; pub mod identity_public_key_is_read_only_error; +pub mod invalid_asset_lock_proof_value; pub mod invalid_identity_public_key_id_error; pub mod invalid_identity_revision_error; pub mod max_identity_public_key_limit_reached_error; diff --git a/packages/rs-dpp/src/errors/consensus/state/state_error.rs b/packages/rs-dpp/src/errors/consensus/state/state_error.rs index 4098b85042d..d79f5656e89 100644 --- a/packages/rs-dpp/src/errors/consensus/state/state_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/state_error.rs @@ -29,6 +29,7 @@ use crate::consensus::state::identity::{ }; use crate::consensus::ConsensusError; use crate::consensus::state::identity::identity_public_key_already_exists_for_unique_contract_bounds_error::IdentityPublicKeyAlreadyExistsForUniqueContractBoundsError; +use crate::consensus::state::identity::invalid_asset_lock_proof_value::InvalidAssetLockProofValueError; use super::document::document_timestamps_are_equal_error::DocumentTimestampsAreEqualError; @@ -85,6 +86,9 @@ pub enum StateError { #[error(transparent)] IdentityPublicKeyIsReadOnlyError(IdentityPublicKeyIsReadOnlyError), + #[error(transparent)] + InvalidAssetLockProofValueError(InvalidAssetLockProofValueError), + #[error(transparent)] MissingIdentityPublicKeyIdsError(MissingIdentityPublicKeyIdsError), diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/common/asset_lock/transaction/fetch_asset_lock_transaction_output_sync/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/common/asset_lock/transaction/fetch_asset_lock_transaction_output_sync/v0/mod.rs index c3f023ac2f4..2e3e1de1f19 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/common/asset_lock/transaction/fetch_asset_lock_transaction_output_sync/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/common/asset_lock/transaction/fetch_asset_lock_transaction_output_sync/v0/mod.rs @@ -3,7 +3,7 @@ use crate::error::Error; use crate::rpc::core::CoreRPCLike; use dpp::consensus::basic::identity::{ IdentityAssetLockTransactionIsNotFoundError, IdentityAssetLockTransactionOutputNotFoundError, - InvalidAssetLockProofTransactionHeightError, InvalidAssetLockProofValueError, + InvalidAssetLockProofTransactionHeightError, }; use dpp::dashcore::secp256k1::ThirtyTwoByteHash; use dpp::dashcore::transaction::special_transaction::TransactionPayload; diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs index 5d2496154c8..9cb6c9c3fd0 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs @@ -1,9 +1,9 @@ use crate::error::Error; use crate::platform_types::platform::PlatformRef; use crate::rpc::core::CoreRPCLike; -use dpp::consensus::basic::identity::InvalidAssetLockProofValueError; use dpp::consensus::signature::{BasicECDSAError, SignatureError}; +use dpp::consensus::state::identity::invalid_asset_lock_proof_value::InvalidAssetLockProofValueError; use dpp::consensus::state::identity::IdentityAlreadyExistsError; use dpp::dashcore::signer; use dpp::dashcore::signer::double_sha; diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/state/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/state/v0/mod.rs index 7b877a982c8..9cac36f33d8 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/state/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/state/v0/mod.rs @@ -1,9 +1,9 @@ use crate::error::Error; use crate::platform_types::platform::PlatformRef; use crate::rpc::core::CoreRPCLike; -use dpp::consensus::basic::identity::InvalidAssetLockProofValueError; use dpp::consensus::signature::{BasicECDSAError, SignatureError}; +use dpp::consensus::state::identity::invalid_asset_lock_proof_value::InvalidAssetLockProofValueError; use dpp::dashcore::signer; use dpp::dashcore::signer::double_sha; use dpp::identity::state_transition::AssetLockProved; From cb98942bb9a64c46963a24bbe60b45649ce19421 Mon Sep 17 00:00:00 2001 From: "markin.io" Date: Thu, 18 Jan 2024 15:24:10 +0000 Subject: [PATCH 06/13] fix(wasm-dpp): build error --- .../basic/identity/invalid_asset_lock_proof_value_error.rs | 2 +- packages/wasm-dpp/src/errors/consensus/consensus_error.rs | 7 ++++--- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value_error.rs b/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value_error.rs index a48b251deca..18fbfb14368 100644 --- a/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value_error.rs +++ b/packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_value_error.rs @@ -1,7 +1,7 @@ -use dpp::consensus::basic::identity::InvalidAssetLockProofValueError; use dpp::consensus::codes::ErrorWithCode; use dpp::consensus::ConsensusError; +use dpp::consensus::state::identity::invalid_asset_lock_proof_value::InvalidAssetLockProofValueError; use wasm_bindgen::prelude::*; #[wasm_bindgen(js_name=InvalidAssetLockProofValueError)] diff --git a/packages/wasm-dpp/src/errors/consensus/consensus_error.rs b/packages/wasm-dpp/src/errors/consensus/consensus_error.rs index 0c1ddebd324..b2e514a2947 100644 --- a/packages/wasm-dpp/src/errors/consensus/consensus_error.rs +++ b/packages/wasm-dpp/src/errors/consensus/consensus_error.rs @@ -37,8 +37,7 @@ use dpp::consensus::basic::BasicError::{ IdentityAssetLockTransactionOutPointAlreadyExistsError, IdentityAssetLockTransactionOutputNotFoundError, IncompatibleProtocolVersionError, IncompatibleRe2PatternError, InvalidAssetLockProofCoreChainHeightError, - InvalidAssetLockProofTransactionHeightError, InvalidAssetLockProofValueError, - InvalidAssetLockTransactionOutputReturnSizeError, + InvalidAssetLockProofTransactionHeightError, InvalidAssetLockTransactionOutputReturnSizeError, InvalidIdentityAssetLockProofChainLockValidationError, InvalidIdentityAssetLockTransactionError, InvalidIdentityAssetLockTransactionOutputError, InvalidIdentityCreditWithdrawalTransitionCoreFeeError, @@ -216,6 +215,9 @@ pub fn from_state_error(state_error: &StateError) -> JsValue { StateError::DataContractConfigUpdateError(e) => { DataContractConfigUpdateErrorWasm::from(e).into() } + StateError::InvalidAssetLockProofValueError(e) => { + InvalidAssetLockProofValueErrorWasm::from(e).into() + } // TODO(versioning): restore _ => todo!(), } @@ -375,7 +377,6 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue { InvalidAssetLockProofTransactionHeightError(e) => { InvalidAssetLockProofTransactionHeightErrorWasm::from(e).into() } - InvalidAssetLockProofValueError(e) => InvalidAssetLockProofValueErrorWasm::from(e).into(), InvalidIdentityCreditWithdrawalTransitionCoreFeeError(e) => { InvalidIdentityCreditWithdrawalTransitionCoreFeeErrorWasm::from(e).into() } From 71ecfb03d2d6660098728db201464ce71cbf2564 Mon Sep 17 00:00:00 2001 From: Igor Markin Date: Thu, 18 Jan 2024 21:03:16 +0300 Subject: [PATCH 07/13] test: remove extra test for chain asset lock proof --- .../test/functional/platform/Identity.spec.js | 62 +------------------ 1 file changed, 1 insertion(+), 61 deletions(-) diff --git a/packages/platform-test-suite/test/functional/platform/Identity.spec.js b/packages/platform-test-suite/test/functional/platform/Identity.spec.js index 6995ad7d502..c05b76ed3c4 100644 --- a/packages/platform-test-suite/test/functional/platform/Identity.spec.js +++ b/packages/platform-test-suite/test/functional/platform/Identity.spec.js @@ -110,7 +110,7 @@ describe('Platform', () => { ); }); - it('should fail to create an identity with already used asset lock output', async () => { + it(' to create an identity with already used asset lock output', async () => { // Create new identity const sourceIdentity = await client.platform.identities.register(400000); @@ -254,66 +254,6 @@ describe('Platform', () => { this.timeout(850000); - it('should fail to create an identity if asset lock amount is less than minimal', async () => { - await client.platform.initialize(); - - // Broadcast Asset Lock transaction - const { - transaction, - privateKey, - outputIndex, - } = await client.platform.identities.utils.createAssetLockTransaction(117000); - - const account = await client.getWalletAccount(); - - await account.broadcastTransaction(transaction); - - // Wait for transaction to be mined and chain locked - const { promise: metadataPromise } = walletAccount.waitForTxMetadata(transaction.id); - - const { height: transactionHeight } = await metadataPromise; - - const assetLockProof = await client.platform.dpp.identity.createChainAssetLockProof( - transactionHeight, - transaction.getOutPointBuffer(outputIndex), - ); - - // Wait for platform chain to sync core height up to transaction height - const { - promise: coreHeightPromise, - } = await client.platform.identities.utils - .waitForCoreChainLockedHeight(transactionHeight); - - await coreHeightPromise; - - const identityCreateTransitionData = await client.platform.identities.utils - .createIdentityCreateTransition(assetLockProof, privateKey); - - const { - identityCreateTransition, - } = identityCreateTransitionData; - - ({ identity: chainLockIdentity } = identityCreateTransitionData); - - let broadcastError; - try { - await client.platform.broadcastStateTransition( - identityCreateTransition, - ); - } catch (e) { - broadcastError = e; - } - - expect(broadcastError).to.be.an.instanceOf(StateTransitionBroadcastError); - expect(broadcastError.getCause().getCode()).to.equal(4028); - expect(broadcastError.getCause()).to.be.an.instanceOf( - InvalidAssetLockProofValueError, - ); - - // Additional wait time to mitigate testnet latency - await waitForSTPropagated(); - }); - it('should create identity using chainLock', async () => { await client.platform.initialize(); From 1ca998516d62ce3a6c1e7e89557e526b4af2d13d Mon Sep 17 00:00:00 2001 From: Igor Markin Date: Thu, 18 Jan 2024 21:04:19 +0300 Subject: [PATCH 08/13] Update Identity.spec.js --- .../test/functional/platform/Identity.spec.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/platform-test-suite/test/functional/platform/Identity.spec.js b/packages/platform-test-suite/test/functional/platform/Identity.spec.js index c05b76ed3c4..d3c4c4378ff 100644 --- a/packages/platform-test-suite/test/functional/platform/Identity.spec.js +++ b/packages/platform-test-suite/test/functional/platform/Identity.spec.js @@ -110,7 +110,7 @@ describe('Platform', () => { ); }); - it(' to create an identity with already used asset lock output', async () => { + it('should fail to create an identity with already used asset lock output', async () => { // Create new identity const sourceIdentity = await client.platform.identities.register(400000); From c12629e182f81b84b8deb8c6c2a459dd14c3076d Mon Sep 17 00:00:00 2001 From: "markin.io" Date: Tue, 23 Jan 2024 12:54:28 +0000 Subject: [PATCH 09/13] refactor: move asset lock min value versioning to dpp --- .../identity_create_transition/methods/mod.rs | 15 ++++++++++++ .../methods/v0/mod.rs | 4 ++++ .../identity_create_transition/mod.rs | 5 ++++ .../v0/v0_methods.rs | 8 +++++++ .../identity_topup_transition/methods/mod.rs | 16 +++++++++++++ .../methods/v0/mod.rs | 5 ++++ .../identity/identity_topup_transition/mod.rs | 5 ++++ .../v0/v0_methods.rs | 7 ++++++ .../identity_create/state/v0/mod.rs | 23 ++----------------- .../identity_top_up/state/v0/mod.rs | 23 ++----------------- 10 files changed, 69 insertions(+), 42 deletions(-) diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/mod.rs index 0128b6ce3d8..71aed2e6cff 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/mod.rs @@ -44,4 +44,19 @@ impl IdentityCreateTransitionMethodsV0 for IdentityCreateTransition { fn get_type() -> StateTransitionType { StateTransitionType::IdentityCreate } + + fn get_minimal_asset_lock_value( + platform_version: &PlatformVersion, + ) -> Result { + match platform_version + .drive_abci + .validation_and_processing + .process_state_transition + { + 0 => IdentityCreateTransitionV0::get_minimal_asset_lock_value(platform_version), + v => Err(ProtocolError::UnknownVersionError(format!( + "Unknown IdentityCreateTransition version for minimal_asset_lock_value {v}" + ))), + } + } } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/v0/mod.rs index 65343d67c57..7915f0941f4 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/v0/mod.rs @@ -17,4 +17,8 @@ pub trait IdentityCreateTransitionMethodsV0 { ) -> Result; /// Get State Transition type fn get_type() -> StateTransitionType; + /// Get asset lock minimal value + fn get_minimal_asset_lock_value( + platform_version: &PlatformVersion, + ) -> Result; } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/mod.rs index 91aab6d4997..c0f6e55b335 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/mod.rs @@ -83,3 +83,8 @@ impl StateTransitionFieldTypes for IdentityCreateTransition { vec![] } } + +#[repr(u64)] +pub enum MinimalAssetLockValue { + V0 = 120000, +} diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/v0_methods.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/v0_methods.rs index df2025506e7..3ee5ed95368 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/v0_methods.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/v0_methods.rs @@ -10,6 +10,7 @@ use crate::prelude::AssetLockProof; use crate::serialization::Signable; use crate::state_transition::identity_create_transition::accessors::IdentityCreateTransitionAccessorsV0; use crate::state_transition::identity_create_transition::methods::IdentityCreateTransitionMethodsV0; +use crate::state_transition::identity_create_transition::MinimalAssetLockValue; use crate::state_transition::public_key_in_creation::accessors::IdentityPublicKeyInCreationV0Setters; use crate::state_transition::identity_create_transition::v0::IdentityCreateTransitionV0; @@ -67,6 +68,13 @@ impl IdentityCreateTransitionMethodsV0 for IdentityCreateTransitionV0 { fn get_type() -> StateTransitionType { StateTransitionType::IdentityCreate } + + /// Get minimal asset lock value + fn get_minimal_asset_lock_value( + _platform_version: &PlatformVersion, + ) -> Result { + Ok(MinimalAssetLockValue::V0 as u64) + } } impl IdentityCreateTransitionAccessorsV0 for IdentityCreateTransitionV0 { diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/mod.rs index 43e807d321d..a3ce0e48d60 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/mod.rs @@ -10,6 +10,7 @@ use crate::state_transition::StateTransition; use crate::version::FeatureVersion; use crate::{BlsModule, ProtocolError}; +use crate::state_transition::identity_create_transition::methods::IdentityCreateTransitionMethodsV0; use platform_version::version::PlatformVersion; impl IdentityTopUpTransitionMethodsV0 for IdentityTopUpTransition { @@ -42,4 +43,19 @@ impl IdentityTopUpTransitionMethodsV0 for IdentityTopUpTransition { ))), } } + + fn get_minimal_asset_lock_value( + platform_version: &PlatformVersion, + ) -> Result { + match platform_version + .drive_abci + .validation_and_processing + .process_state_transition + { + 0 => IdentityTopUpTransitionV0::get_minimal_asset_lock_value(platform_version), + v => Err(ProtocolError::UnknownVersionError(format!( + "Unknown IdentityCreateTransition version for minimal_asset_lock_value {v}" + ))), + } + } } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/v0/mod.rs index 65328f50721..ca767080025 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/v0/mod.rs @@ -19,4 +19,9 @@ pub trait IdentityTopUpTransitionMethodsV0 { fn get_type() -> StateTransitionType { StateTransitionType::IdentityTopUp } + + /// Get asset lock minimal value + fn get_minimal_asset_lock_value( + platform_version: &PlatformVersion, + ) -> Result; } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs index 21f72678d8a..8c8239cfa74 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs @@ -82,3 +82,8 @@ impl StateTransitionFieldTypes for IdentityTopUpTransition { vec![] } } + +#[repr(u64)] +enum MinimalAssetLockValue { + V0 = 1000, +} diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/v0_methods.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/v0_methods.rs index fb69de73202..65fef9a7cbc 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/v0_methods.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/v0_methods.rs @@ -8,6 +8,7 @@ use crate::prelude::AssetLockProof; use crate::state_transition::identity_topup_transition::accessors::IdentityTopUpTransitionAccessorsV0; use crate::state_transition::identity_topup_transition::methods::IdentityTopUpTransitionMethodsV0; +use crate::state_transition::identity_topup_transition::MinimalAssetLockValue; use platform_version::version::PlatformVersion; use crate::state_transition::identity_topup_transition::v0::IdentityTopUpTransitionV0; @@ -36,6 +37,12 @@ impl IdentityTopUpTransitionMethodsV0 for IdentityTopUpTransitionV0 { Ok(state_transition) } + + fn get_minimal_asset_lock_value( + _platform_version: &PlatformVersion, + ) -> Result { + Ok(MinimalAssetLockValue::V0 as u64) + } } impl IdentityTopUpTransitionAccessorsV0 for IdentityTopUpTransitionV0 { diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs index 9cb6c9c3fd0..04e89cb3675 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create/state/v0/mod.rs @@ -13,6 +13,7 @@ use dpp::identity::state_transition::AssetLockProved; use dpp::prelude::ConsensusValidationResult; use dpp::serialization::Signable; use dpp::state_transition::identity_create_transition::accessors::IdentityCreateTransitionAccessorsV0; +use dpp::state_transition::identity_create_transition::methods::IdentityCreateTransitionMethodsV0; use dpp::state_transition::identity_create_transition::IdentityCreateTransition; use dpp::state_transition::{StateTransition, StateTransitionLike}; @@ -33,26 +34,6 @@ use drive::grovedb::TransactionArg; use crate::execution::validation::state_transition::common::asset_lock::transaction::fetch_asset_lock_transaction_output_sync::fetch_asset_lock_transaction_output_sync; use crate::execution::validation::state_transition::common::validate_unique_identity_public_key_hashes_in_state::validate_unique_identity_public_key_hashes_in_state; -#[repr(u64)] -enum MinimalAssetLockValue { - V1 = 120000, -} - -fn minimal_asset_lock_value(platform_version: &PlatformVersion) -> Result { - match platform_version - .drive_abci - .validation_and_processing - .process_state_transition - { - 0 => Ok(MinimalAssetLockValue::V1 as u64), - version => Err(Error::Execution(ExecutionError::UnknownVersionMismatch { - method: "minimal_asset_lock_value".to_string(), - known_versions: vec![0], - received: version, - })), - } -} - pub(in crate::execution::validation::state_transition::state_transitions::identity_create) trait IdentityCreateStateTransitionStateValidationV0 { fn validate_state_v0( @@ -146,7 +127,7 @@ impl IdentityCreateStateTransitionStateValidationV0 for IdentityCreateTransition } let tx_out = tx_out_validation.into_data()?; - let min_value = minimal_asset_lock_value(platform_version)?; + let min_value = IdentityCreateTransition::get_minimal_asset_lock_value(platform_version)?; if tx_out.value < min_value { return Ok(ConsensusValidationResult::new_with_error( InvalidAssetLockProofValueError::new(tx_out.value, min_value).into(), diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/state/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/state/v0/mod.rs index 9cac36f33d8..a78c0724656 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/state/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_top_up/state/v0/mod.rs @@ -11,6 +11,7 @@ use dpp::identity::KeyType; use dpp::prelude::ConsensusValidationResult; use dpp::serialization::Signable; +use dpp::state_transition::identity_topup_transition::methods::IdentityTopUpTransitionMethodsV0; use dpp::state_transition::identity_topup_transition::IdentityTopUpTransition; use dpp::state_transition::{StateTransition, StateTransitionLike}; @@ -27,26 +28,6 @@ use crate::execution::types::state_transition_execution_context::{StateTransitio use crate::execution::validation::state_transition::common::asset_lock::proof::validate::AssetLockProofValidation; use crate::execution::validation::state_transition::common::asset_lock::transaction::fetch_asset_lock_transaction_output_sync::fetch_asset_lock_transaction_output_sync; -#[repr(u64)] -enum MinimalAssetLockValue { - V1 = 1000, -} - -fn minimal_asset_lock_value(platform_version: &PlatformVersion) -> Result { - match platform_version - .drive_abci - .validation_and_processing - .process_state_transition - { - 0 => Ok(MinimalAssetLockValue::V1 as u64), - version => Err(Error::Execution(ExecutionError::UnknownVersionMismatch { - method: "minimal_asset_lock_value".to_string(), - known_versions: vec![0], - received: version, - })), - } -} - pub(in crate::execution::validation::state_transition::state_transitions::identity_top_up) trait IdentityTopUpStateTransitionStateValidationV0 { fn validate_state_v0( @@ -109,7 +90,7 @@ impl IdentityTopUpStateTransitionStateValidationV0 for IdentityTopUpTransition { } let tx_out = tx_out_validation.into_data()?; - let min_value = minimal_asset_lock_value(platform_version)?; + let min_value = IdentityTopUpTransition::get_minimal_asset_lock_value(platform_version)?; if tx_out.value < min_value { return Ok(ConsensusValidationResult::new_with_error( InvalidAssetLockProofValueError::new(tx_out.value, min_value).into(), From f4697b49a7b258433aa76cafad0cee4ee3393381 Mon Sep 17 00:00:00 2001 From: "markin.io" Date: Tue, 23 Jan 2024 13:35:40 +0000 Subject: [PATCH 10/13] refactor: min asset lock value versioned --- .../identity_create_transition/methods/mod.rs | 15 --------------- .../methods/v0/mod.rs | 4 ---- .../identity/identity_create_transition/mod.rs | 17 +++++++++++++++++ .../identity_create_transition/v0/v0_methods.rs | 7 ------- .../identity_topup_transition/methods/mod.rs | 15 --------------- .../identity_topup_transition/methods/v0/mod.rs | 5 ----- .../identity/identity_topup_transition/mod.rs | 15 +++++++++++++++ .../identity_topup_transition/v0/v0_methods.rs | 6 ------ .../src/version/dpp_versions.rs | 1 + .../src/version/mocks/v2_test.rs | 1 + .../src/version/mocks/v3_test.rs | 1 + packages/rs-platform-version/src/version/v1.rs | 1 + 12 files changed, 36 insertions(+), 52 deletions(-) diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/mod.rs index 71aed2e6cff..0128b6ce3d8 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/mod.rs @@ -44,19 +44,4 @@ impl IdentityCreateTransitionMethodsV0 for IdentityCreateTransition { fn get_type() -> StateTransitionType { StateTransitionType::IdentityCreate } - - fn get_minimal_asset_lock_value( - platform_version: &PlatformVersion, - ) -> Result { - match platform_version - .drive_abci - .validation_and_processing - .process_state_transition - { - 0 => IdentityCreateTransitionV0::get_minimal_asset_lock_value(platform_version), - v => Err(ProtocolError::UnknownVersionError(format!( - "Unknown IdentityCreateTransition version for minimal_asset_lock_value {v}" - ))), - } - } } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/v0/mod.rs index 7915f0941f4..65343d67c57 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/methods/v0/mod.rs @@ -17,8 +17,4 @@ pub trait IdentityCreateTransitionMethodsV0 { ) -> Result; /// Get State Transition type fn get_type() -> StateTransitionType; - /// Get asset lock minimal value - fn get_minimal_asset_lock_value( - platform_version: &PlatformVersion, - ) -> Result; } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/mod.rs index c0f6e55b335..15cd5a6ef49 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/mod.rs @@ -68,6 +68,23 @@ impl IdentityCreateTransition { }), } } + + pub fn get_minimal_asset_lock_value( + platform_version: &PlatformVersion, + ) -> Result { + match platform_version + .dpp + .state_transitions + .identities + .asset_locks + .minimal_asset_lock_value + { + 0 => Ok(MinimalAssetLockValue::V0 as u64), + v => Err(ProtocolError::UnknownVersionError(format!( + "Unknown IdentityCreateTransition version for minimal_asset_lock_value {v}" + ))), + } + } } impl StateTransitionFieldTypes for IdentityCreateTransition { diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/v0_methods.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/v0_methods.rs index 3ee5ed95368..16d4c29ed17 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/v0_methods.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/v0_methods.rs @@ -68,13 +68,6 @@ impl IdentityCreateTransitionMethodsV0 for IdentityCreateTransitionV0 { fn get_type() -> StateTransitionType { StateTransitionType::IdentityCreate } - - /// Get minimal asset lock value - fn get_minimal_asset_lock_value( - _platform_version: &PlatformVersion, - ) -> Result { - Ok(MinimalAssetLockValue::V0 as u64) - } } impl IdentityCreateTransitionAccessorsV0 for IdentityCreateTransitionV0 { diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/mod.rs index a3ce0e48d60..1bdc1220968 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/mod.rs @@ -43,19 +43,4 @@ impl IdentityTopUpTransitionMethodsV0 for IdentityTopUpTransition { ))), } } - - fn get_minimal_asset_lock_value( - platform_version: &PlatformVersion, - ) -> Result { - match platform_version - .drive_abci - .validation_and_processing - .process_state_transition - { - 0 => IdentityTopUpTransitionV0::get_minimal_asset_lock_value(platform_version), - v => Err(ProtocolError::UnknownVersionError(format!( - "Unknown IdentityCreateTransition version for minimal_asset_lock_value {v}" - ))), - } - } } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/v0/mod.rs index ca767080025..65328f50721 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/v0/mod.rs @@ -19,9 +19,4 @@ pub trait IdentityTopUpTransitionMethodsV0 { fn get_type() -> StateTransitionType { StateTransitionType::IdentityTopUp } - - /// Get asset lock minimal value - fn get_minimal_asset_lock_value( - platform_version: &PlatformVersion, - ) -> Result; } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs index 8c8239cfa74..fb4cefdfce8 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs @@ -67,6 +67,21 @@ impl IdentityTopUpTransition { }), } } + + pub fn get_minimal_asset_lock_value( + platform_version: &PlatformVersion, + ) -> Result { + match platform_version + .drive_abci + .validation_and_processing + .process_state_transition + { + 0 => Ok(MinimalAssetLockValue::V0 as u64), + v => Err(ProtocolError::UnknownVersionError(format!( + "Unknown IdentityCreateTransition version for minimal_asset_lock_value {v}" + ))), + } + } } impl StateTransitionFieldTypes for IdentityTopUpTransition { diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/v0_methods.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/v0_methods.rs index 65fef9a7cbc..b60215fcfdf 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/v0_methods.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/v0_methods.rs @@ -37,12 +37,6 @@ impl IdentityTopUpTransitionMethodsV0 for IdentityTopUpTransitionV0 { Ok(state_transition) } - - fn get_minimal_asset_lock_value( - _platform_version: &PlatformVersion, - ) -> Result { - Ok(MinimalAssetLockValue::V0 as u64) - } } impl IdentityTopUpTransitionAccessorsV0 for IdentityTopUpTransitionV0 { diff --git a/packages/rs-platform-version/src/version/dpp_versions.rs b/packages/rs-platform-version/src/version/dpp_versions.rs index 6c271f17f2e..dd3999be5c2 100644 --- a/packages/rs-platform-version/src/version/dpp_versions.rs +++ b/packages/rs-platform-version/src/version/dpp_versions.rs @@ -29,6 +29,7 @@ pub struct IdentityTransitionVersions { pub struct IdentityTransitionAssetLockVersions { pub validate_asset_lock_transaction_structure: FeatureVersion, pub validate_instant_asset_lock_proof_structure: FeatureVersion, + pub minimal_asset_lock_value: FeatureVersion, } #[derive(Clone, Debug, Default)] diff --git a/packages/rs-platform-version/src/version/mocks/v2_test.rs b/packages/rs-platform-version/src/version/mocks/v2_test.rs index a1a8d821439..3d9e442214f 100644 --- a/packages/rs-platform-version/src/version/mocks/v2_test.rs +++ b/packages/rs-platform-version/src/version/mocks/v2_test.rs @@ -827,6 +827,7 @@ pub(crate) const TEST_PLATFORM_V2: PlatformVersion = PlatformVersion { asset_locks: IdentityTransitionAssetLockVersions { validate_asset_lock_transaction_structure: 0, validate_instant_asset_lock_proof_structure: 0, + minimal_asset_lock_value: 0, }, }, }, diff --git a/packages/rs-platform-version/src/version/mocks/v3_test.rs b/packages/rs-platform-version/src/version/mocks/v3_test.rs index 4a87ecde428..da4bde11542 100644 --- a/packages/rs-platform-version/src/version/mocks/v3_test.rs +++ b/packages/rs-platform-version/src/version/mocks/v3_test.rs @@ -827,6 +827,7 @@ pub(crate) const TEST_PLATFORM_V3: PlatformVersion = PlatformVersion { asset_locks: IdentityTransitionAssetLockVersions { validate_asset_lock_transaction_structure: 0, validate_instant_asset_lock_proof_structure: 0, + minimal_asset_lock_value: 0, }, }, }, diff --git a/packages/rs-platform-version/src/version/v1.rs b/packages/rs-platform-version/src/version/v1.rs index cc0fc782c6a..8ffb8fddb1e 100644 --- a/packages/rs-platform-version/src/version/v1.rs +++ b/packages/rs-platform-version/src/version/v1.rs @@ -824,6 +824,7 @@ pub(super) const PLATFORM_V1: PlatformVersion = PlatformVersion { asset_locks: IdentityTransitionAssetLockVersions { validate_asset_lock_transaction_structure: 0, validate_instant_asset_lock_proof_structure: 0, + minimal_asset_lock_value: 0, }, }, }, From f6867719e6d98674408365faba0575adc285de93 Mon Sep 17 00:00:00 2001 From: "markin.io" Date: Tue, 23 Jan 2024 13:38:39 +0000 Subject: [PATCH 11/13] refactor: unused code --- .../identity/identity_create_transition/v0/v0_methods.rs | 1 - .../identity/identity_topup_transition/methods/mod.rs | 1 - .../identity/identity_topup_transition/v0/v0_methods.rs | 1 - 3 files changed, 3 deletions(-) diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/v0_methods.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/v0_methods.rs index 16d4c29ed17..df2025506e7 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/v0_methods.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/v0_methods.rs @@ -10,7 +10,6 @@ use crate::prelude::AssetLockProof; use crate::serialization::Signable; use crate::state_transition::identity_create_transition::accessors::IdentityCreateTransitionAccessorsV0; use crate::state_transition::identity_create_transition::methods::IdentityCreateTransitionMethodsV0; -use crate::state_transition::identity_create_transition::MinimalAssetLockValue; use crate::state_transition::public_key_in_creation::accessors::IdentityPublicKeyInCreationV0Setters; use crate::state_transition::identity_create_transition::v0::IdentityCreateTransitionV0; diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/mod.rs index 1bdc1220968..43e807d321d 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/methods/mod.rs @@ -10,7 +10,6 @@ use crate::state_transition::StateTransition; use crate::version::FeatureVersion; use crate::{BlsModule, ProtocolError}; -use crate::state_transition::identity_create_transition::methods::IdentityCreateTransitionMethodsV0; use platform_version::version::PlatformVersion; impl IdentityTopUpTransitionMethodsV0 for IdentityTopUpTransition { diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/v0_methods.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/v0_methods.rs index b60215fcfdf..fb69de73202 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/v0_methods.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/v0_methods.rs @@ -8,7 +8,6 @@ use crate::prelude::AssetLockProof; use crate::state_transition::identity_topup_transition::accessors::IdentityTopUpTransitionAccessorsV0; use crate::state_transition::identity_topup_transition::methods::IdentityTopUpTransitionMethodsV0; -use crate::state_transition::identity_topup_transition::MinimalAssetLockValue; use platform_version::version::PlatformVersion; use crate::state_transition::identity_topup_transition::v0::IdentityTopUpTransitionV0; From 5e5a130671a26b1929e51cf22d21776f9d2691ec Mon Sep 17 00:00:00 2001 From: "markin.io" Date: Tue, 23 Jan 2024 13:40:33 +0000 Subject: [PATCH 12/13] fix: wrong version target --- .../identity/identity_topup_transition/mod.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs index fb4cefdfce8..1cae7d95f96 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs @@ -72,9 +72,11 @@ impl IdentityTopUpTransition { platform_version: &PlatformVersion, ) -> Result { match platform_version - .drive_abci - .validation_and_processing - .process_state_transition + .dpp + .state_transitions + .identities + .asset_locks + .minimal_asset_lock_value { 0 => Ok(MinimalAssetLockValue::V0 as u64), v => Err(ProtocolError::UnknownVersionError(format!( From 1c5719feb888f09fe1a160c35beaa05ab4bc9669 Mon Sep 17 00:00:00 2001 From: "markin.io" Date: Tue, 23 Jan 2024 13:41:02 +0000 Subject: [PATCH 13/13] fix: error message --- .../state_transitions/identity/identity_topup_transition/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs index 1cae7d95f96..fb009a867e2 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs @@ -80,7 +80,7 @@ impl IdentityTopUpTransition { { 0 => Ok(MinimalAssetLockValue::V0 as u64), v => Err(ProtocolError::UnknownVersionError(format!( - "Unknown IdentityCreateTransition version for minimal_asset_lock_value {v}" + "Unknown IdentityTopUpTransition version for minimal_asset_lock_value {v}" ))), } }