diff --git a/.github/workflows/rs-checks.yml b/.github/workflows/rs-checks.yml index 50e379f7729..5188f9167a2 100644 --- a/.github/workflows/rs-checks.yml +++ b/.github/workflows/rs-checks.yml @@ -7,6 +7,10 @@ on: description: The package name to run tests for type: string required: true + clippy-fail: + description: Fail clippy checks if any warnings detected + type: boolean + required: false jobs: lint: @@ -26,10 +30,17 @@ jobs: - name: Enable Rust cache uses: Swatinem/rust-cache@v2 + - name: Clippy args + uses: actions/github-script@v6 + id: clippy-args + with: + result-encoding: string + script: "return core.getInput('clippy-fail') ? '--all-features -- -Dwarnings' : '--all-features';" + - uses: actions-rs/clippy-check@v1 with: token: ${{ secrets.GITHUB_TOKEN }} - args: --all-features + args: ${{ steps.clippy-args.output.result }} formatting: name: Formatting diff --git a/.github/workflows/rs-dpp.yml b/.github/workflows/rs-dpp.yml index a521b682ae9..47f0157484f 100644 --- a/.github/workflows/rs-dpp.yml +++ b/.github/workflows/rs-dpp.yml @@ -27,3 +27,4 @@ jobs: uses: ./.github/workflows/rs-checks.yml with: package: "dpp" + clippy-fail: true diff --git a/.github/workflows/wasm-dpp.yml b/.github/workflows/wasm-dpp.yml index ef343d819a4..d33505c898e 100644 --- a/.github/workflows/wasm-dpp.yml +++ b/.github/workflows/wasm-dpp.yml @@ -37,6 +37,7 @@ jobs: uses: ./.github/workflows/rs-checks.yml with: package: 'wasm-dpp' + clippy-fail: true wasm-errors: name: WASM compilation diff --git a/packages/rs-dpp/src/data_contract/data_contract_factory.rs b/packages/rs-dpp/src/data_contract/data_contract_factory.rs index c5f7aa3b835..762c398ac45 100644 --- a/packages/rs-dpp/src/data_contract/data_contract_factory.rs +++ b/packages/rs-dpp/src/data_contract/data_contract_factory.rs @@ -178,7 +178,7 @@ impl DataContractFactory { data_contract: DataContract, ) -> Result { //todo: is this right for entropy? - let entropy = data_contract.entropy.clone(); + let entropy = data_contract.entropy; Ok(DataContractCreateTransition { protocol_version: self.protocol_version, transition_type: StateTransitionType::DataContractCreate, diff --git a/packages/rs-dpp/src/data_trigger/dashpay_data_triggers/mod.rs b/packages/rs-dpp/src/data_trigger/dashpay_data_triggers/mod.rs index c8511fb4b24..b354702e305 100644 --- a/packages/rs-dpp/src/data_trigger/dashpay_data_triggers/mod.rs +++ b/packages/rs-dpp/src/data_trigger/dashpay_data_triggers/mod.rs @@ -98,7 +98,7 @@ where let identity = context .state_repository .fetch_identity( - &to_user_id.into(), + &to_user_id, Some(context.state_transition_execution_context), ) .await?; diff --git a/packages/rs-dpp/src/document/document.rs b/packages/rs-dpp/src/document/document.rs index 23af4ac3c9c..ba851a74bfe 100644 --- a/packages/rs-dpp/src/document/document.rs +++ b/packages/rs-dpp/src/document/document.rs @@ -94,8 +94,8 @@ pub struct Document { impl Document { /// Return a value given the path to its key for a document type. - pub fn get_raw_for_document_type<'a>( - &'a self, + pub fn get_raw_for_document_type( + &self, key_path: &str, document_type: &DocumentType, owner_id: Option<[u8; 32]>, @@ -130,8 +130,8 @@ impl Document { } /// Return a value given the path to its key and the document type for a contract. - pub fn get_raw_for_contract<'a>( - &'a self, + pub fn get_raw_for_contract( + &self, key: &str, document_type_name: &str, contract: &DataContract, diff --git a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/apply_documents_batch_transition_factory.rs b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/apply_documents_batch_transition_factory.rs index fb208fbe71f..3e95a297c01 100644 --- a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/apply_documents_batch_transition_factory.rs +++ b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/apply_documents_batch_transition_factory.rs @@ -45,7 +45,7 @@ pub async fn apply_documents_batch_transition( ) -> Result<(), ProtocolError> { let replace_transitions: Vec<_> = state_transition .get_transitions_slice() - .into_iter() + .iter() .filter(|dt| dt.base().action == Action::Replace) .collect(); diff --git a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/document_transition/document_create_transition_action.rs b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/document_transition/document_create_transition_action.rs index e9375e1c066..ee2db3b39b3 100644 --- a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/document_transition/document_create_transition_action.rs +++ b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/document_transition/document_create_transition_action.rs @@ -46,8 +46,8 @@ impl From<&DocumentCreateTransition> for DocumentCreateTransitionAction { } = value; DocumentCreateTransitionAction { base: base.into(), - created_at: created_at.clone(), - updated_at: updated_at.clone(), + created_at: *created_at, + updated_at: *updated_at, data: data.clone().unwrap_or_default(), } } diff --git a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/document_transition/document_replace_transition_action.rs b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/document_transition/document_replace_transition_action.rs index 13273508012..747daead833 100644 --- a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/document_transition/document_replace_transition_action.rs +++ b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/document_transition/document_replace_transition_action.rs @@ -35,7 +35,7 @@ impl DocumentReplaceTransitionAction { base: base.into(), revision: *revision, created_at: originally_created_at, - updated_at: updated_at.clone(), + updated_at: *updated_at, data: data.clone().unwrap_or_default(), } } diff --git a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/execute_data_triggers.rs b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/execute_data_triggers.rs index ba94443a68f..8d80dde4bec 100644 --- a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/execute_data_triggers.rs +++ b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/execute_data_triggers.rs @@ -32,7 +32,7 @@ where let data_triggers: Vec = data_triggers_list.into_iter().collect(); for dt in document_transitions { - let document_transition = dt.as_ref(); + let document_transition = dt; let document_type = &document_transition.base().document_type_name; let transition_action = document_transition.base().action; diff --git a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/validate_documents_uniqueness_by_indices.rs b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/validate_documents_uniqueness_by_indices.rs index 728651d7a30..5089ccade36 100644 --- a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/validate_documents_uniqueness_by_indices.rs +++ b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/validate_documents_uniqueness_by_indices.rs @@ -41,7 +41,7 @@ where // 1. Prepare fetchDocuments queries from indexed properties for t in document_transitions { - let transition = t.as_ref(); + let transition = t; let document_schema = data_contract.get_document_schema(&transition.base().document_type_name)?; let document_indices = document_schema.get_indices::>()?; diff --git a/packages/rs-dpp/src/identity/state_transition/identity_create_transition/validation/state/mod.rs b/packages/rs-dpp/src/identity/state_transition/identity_create_transition/validation/state/mod.rs index 5bf9b1c08a8..c6f0d65cea5 100644 --- a/packages/rs-dpp/src/identity/state_transition/identity_create_transition/validation/state/mod.rs +++ b/packages/rs-dpp/src/identity/state_transition/identity_create_transition/validation/state/mod.rs @@ -27,9 +27,7 @@ where &self, data: &IdentityCreateTransition, ) -> Result, ProtocolError> { - validate_identity_create_transition_state(&self.state_repository, data) - .await - .map_err(|err| err.into()) + validate_identity_create_transition_state(&self.state_repository, data).await } } @@ -65,7 +63,7 @@ pub async fn validate_identity_create_transition_state( .map_err(|e| { NonConsensusError::StateRepositoryFetchError(format!( "state repository fetch identity balance error: {}", - e.to_string() + e )) })?; @@ -86,9 +84,7 @@ pub async fn validate_identity_create_transition_state( ) .await .map_err(Into::::into)?; - return Ok( - IdentityCreateTransitionAction::from_borrowed(state_transition, tx_out.value).into(), - ); + Ok(IdentityCreateTransitionAction::from_borrowed(state_transition, tx_out.value).into()) } } diff --git a/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs b/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs index 34c769e98a7..bd65ede271e 100644 --- a/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs +++ b/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs @@ -55,7 +55,7 @@ where .map_err(|e| { NonConsensusError::StateRepositoryFetchError(format!( "state repository fetch identity for credit withdrawal verification error: {}", - e.to_string() + e )) })?; diff --git a/packages/rs-dpp/src/identity/state_transition/identity_topup_transition/validation/state/mod.rs b/packages/rs-dpp/src/identity/state_transition/identity_topup_transition/validation/state/mod.rs index 1de6aad3963..dbd91d6aaa5 100644 --- a/packages/rs-dpp/src/identity/state_transition/identity_topup_transition/validation/state/mod.rs +++ b/packages/rs-dpp/src/identity/state_transition/identity_topup_transition/validation/state/mod.rs @@ -28,7 +28,6 @@ where ) -> Result, ProtocolError> { validate_identity_topup_transition_state(&self.state_repository, data) .await - .map(|result| result.into()) .map_err(|err| err.into()) } } diff --git a/packages/rs-dpp/src/identity/state_transition/identity_update_transition/action.rs b/packages/rs-dpp/src/identity/state_transition/identity_update_transition/action.rs index 9822ba2da9d..552efad7fbe 100644 --- a/packages/rs-dpp/src/identity/state_transition/identity_update_transition/action.rs +++ b/packages/rs-dpp/src/identity/state_transition/identity_update_transition/action.rs @@ -54,7 +54,7 @@ impl From<&IdentityUpdateTransition> for IdentityUpdateTransitionAction { .map(|key| key.clone().to_identity_public_key()) .collect(), disable_public_keys: disable_public_keys.clone(), - public_keys_disabled_at: public_keys_disabled_at.clone(), + public_keys_disabled_at: *public_keys_disabled_at, identity_id: *identity_id, } } diff --git a/packages/rs-dpp/src/identity/state_transition/identity_update_transition/validate_identity_update_transition_state.rs b/packages/rs-dpp/src/identity/state_transition/identity_update_transition/validate_identity_update_transition_state.rs index 6e16c419f61..a5e75041162 100644 --- a/packages/rs-dpp/src/identity/state_transition/identity_update_transition/validate_identity_update_transition_state.rs +++ b/packages/rs-dpp/src/identity/state_transition/identity_update_transition/validate_identity_update_transition_state.rs @@ -52,7 +52,7 @@ where .map_err(|e| { NonConsensusError::StateRepositoryFetchError(format!( "state repository fetch identity for identity update validation error: {}", - e.to_string() + e )) })?; @@ -115,7 +115,7 @@ where .map_err(|e| { NonConsensusError::StateRepositoryFetchError(format!( "state repository fetch latest platform block time error: {}", - e.to_string() + e )) })?; diff --git a/packages/rs-dpp/src/tests/fixtures/public_keys_validator_mock.rs b/packages/rs-dpp/src/tests/fixtures/public_keys_validator_mock.rs index d3f27981806..c66f2b19aba 100644 --- a/packages/rs-dpp/src/tests/fixtures/public_keys_validator_mock.rs +++ b/packages/rs-dpp/src/tests/fixtures/public_keys_validator_mock.rs @@ -13,6 +13,12 @@ pub struct PublicKeysValidatorMock { called_with: Mutex>, } +impl Default for PublicKeysValidatorMock { + fn default() -> Self { + Self::new() + } +} + impl PublicKeysValidatorMock { pub fn new() -> Self { Self { diff --git a/packages/wasm-dpp/src/data_contract_factory/data_contract_factory.rs b/packages/wasm-dpp/src/data_contract_factory/data_contract_factory.rs deleted file mode 100644 index 779d4138b8b..00000000000 --- a/packages/wasm-dpp/src/data_contract_factory/data_contract_factory.rs +++ /dev/null @@ -1,163 +0,0 @@ -use std::sync::Arc; - -use dpp::{ - data_contract::{ - validation::data_contract_validator::DataContractValidator, DataContractFactory, - }, - platform_value, - prelude::Identifier, - version::ProtocolVersionValidator, - ProtocolError, -}; -use wasm_bindgen::prelude::*; - -use crate::entropy_generator::ExternalEntropyGenerator; -use crate::utils::WithJsError; - -use crate::{ - data_contract::errors::InvalidDataContractError, - errors::{from_dpp_err, protocol_error::from_protocol_error}, - js_value_to_data_contract_value, - validation::ValidationResultWasm, - with_js_error, DataContractCreateTransitionWasm, DataContractParameters, DataContractWasm, -}; - -#[wasm_bindgen(js_name=DataContractValidator)] -pub struct DataContractValidatorWasm(DataContractValidator); - -impl From for DataContractValidatorWasm { - fn from(v: DataContractValidator) -> Self { - DataContractValidatorWasm(v) - } -} - -impl From for DataContractValidator { - fn from(val: DataContractValidatorWasm) -> Self { - val.0 - } -} - -impl Default for DataContractValidatorWasm { - fn default() -> Self { - Self::new() - } -} - -#[wasm_bindgen(js_class=DataContractValidator)] -impl DataContractValidatorWasm { - #[wasm_bindgen(constructor)] - pub fn new() -> Self { - DataContractValidator::new(std::sync::Arc::new(ProtocolVersionValidator::default())).into() - } - - #[wasm_bindgen] - pub fn validate(&self, raw_data_contract: JsValue) -> Result { - let parameters: DataContractParameters = - with_js_error!(serde_wasm_bindgen::from_value(raw_data_contract))?; - let platform_object = platform_value::to_value(parameters).expect("Implements Serialize"); - - let validation_result = self - .0 - .validate(&platform_object) - .map_err(from_protocol_error)?; - Ok(validation_result.map(|_| JsValue::undefined()).into()) - } -} - -#[wasm_bindgen(js_name=DataContractFactory)] -pub struct DataContractFactoryWasm(DataContractFactory); - -impl From for DataContractFactoryWasm { - fn from(v: DataContractFactory) -> Self { - DataContractFactoryWasm(v) - } -} - -impl From for DataContractFactory { - fn from(val: DataContractFactoryWasm) -> Self { - val.0 - } -} - -#[wasm_bindgen(js_class=DataContractFactory)] -impl DataContractFactoryWasm { - #[wasm_bindgen(constructor)] - pub fn new( - protocol_version: u32, - validate_data_contract: DataContractValidatorWasm, - external_entropy_generator_arg: Option, - ) -> DataContractFactoryWasm { - if let Some(external_entropy_generator) = external_entropy_generator_arg { - DataContractFactory::new_with_entropy_generator( - protocol_version, - Arc::new(validate_data_contract.into()), - Box::new(external_entropy_generator), - ) - } else { - DataContractFactory::new(protocol_version, Arc::new(validate_data_contract.into())) - } - .into() - } - - #[wasm_bindgen(js_name=create)] - pub fn create( - &self, - owner_id: Vec, - documents: JsValue, - ) -> Result { - let documents_object: platform_value::Value = - with_js_error!(serde_wasm_bindgen::from_value(documents))?; - let identifier = Identifier::from_bytes(&owner_id) - .map_err(ProtocolError::ValueError) - .with_js_error()?; - //todo: contract config - self.0 - .create(identifier, documents_object, None, None) - .map(Into::into) - .with_js_error() - } - - #[wasm_bindgen(js_name=createFromObject)] - pub async fn create_from_object( - &self, - object: JsValue, - skip_validation: Option, - ) -> Result { - let parameters_value = js_value_to_data_contract_value(object.clone())?; - let result = self - .0 - .create_from_object(parameters_value, skip_validation.unwrap_or(false)) - .await; - match result { - Ok(data_contract) => Ok(data_contract.into()), - Err(dpp::ProtocolError::InvalidDataContractError(err)) => { - Err(InvalidDataContractError::new(err.errors, object).into()) - } - Err(other) => Err(from_dpp_err(other)), - } - } - - #[wasm_bindgen(js_name=createFromBuffer)] - pub async fn create_from_buffer( - &self, - buffer: Vec, - skip_validation: Option, - ) -> Result { - self.0 - .create_from_buffer(buffer, skip_validation.unwrap_or(false)) - .await - .map(Into::into) - .map_err(from_protocol_error) - } - - #[wasm_bindgen(js_name=createDataContractCreateTransition)] - pub async fn create_data_contract_create_transition( - &self, - data_contract: &DataContractWasm, - ) -> Result { - self.0 - .create_data_contract_create_transition(data_contract.clone().into()) - .map(Into::into) - .with_js_error() - } -} diff --git a/packages/wasm-dpp/src/data_contract_factory/mod.rs b/packages/wasm-dpp/src/data_contract_factory/mod.rs index 12d71eba330..779d4138b8b 100644 --- a/packages/wasm-dpp/src/data_contract_factory/mod.rs +++ b/packages/wasm-dpp/src/data_contract_factory/mod.rs @@ -1 +1,163 @@ -mod data_contract_factory; +use std::sync::Arc; + +use dpp::{ + data_contract::{ + validation::data_contract_validator::DataContractValidator, DataContractFactory, + }, + platform_value, + prelude::Identifier, + version::ProtocolVersionValidator, + ProtocolError, +}; +use wasm_bindgen::prelude::*; + +use crate::entropy_generator::ExternalEntropyGenerator; +use crate::utils::WithJsError; + +use crate::{ + data_contract::errors::InvalidDataContractError, + errors::{from_dpp_err, protocol_error::from_protocol_error}, + js_value_to_data_contract_value, + validation::ValidationResultWasm, + with_js_error, DataContractCreateTransitionWasm, DataContractParameters, DataContractWasm, +}; + +#[wasm_bindgen(js_name=DataContractValidator)] +pub struct DataContractValidatorWasm(DataContractValidator); + +impl From for DataContractValidatorWasm { + fn from(v: DataContractValidator) -> Self { + DataContractValidatorWasm(v) + } +} + +impl From for DataContractValidator { + fn from(val: DataContractValidatorWasm) -> Self { + val.0 + } +} + +impl Default for DataContractValidatorWasm { + fn default() -> Self { + Self::new() + } +} + +#[wasm_bindgen(js_class=DataContractValidator)] +impl DataContractValidatorWasm { + #[wasm_bindgen(constructor)] + pub fn new() -> Self { + DataContractValidator::new(std::sync::Arc::new(ProtocolVersionValidator::default())).into() + } + + #[wasm_bindgen] + pub fn validate(&self, raw_data_contract: JsValue) -> Result { + let parameters: DataContractParameters = + with_js_error!(serde_wasm_bindgen::from_value(raw_data_contract))?; + let platform_object = platform_value::to_value(parameters).expect("Implements Serialize"); + + let validation_result = self + .0 + .validate(&platform_object) + .map_err(from_protocol_error)?; + Ok(validation_result.map(|_| JsValue::undefined()).into()) + } +} + +#[wasm_bindgen(js_name=DataContractFactory)] +pub struct DataContractFactoryWasm(DataContractFactory); + +impl From for DataContractFactoryWasm { + fn from(v: DataContractFactory) -> Self { + DataContractFactoryWasm(v) + } +} + +impl From for DataContractFactory { + fn from(val: DataContractFactoryWasm) -> Self { + val.0 + } +} + +#[wasm_bindgen(js_class=DataContractFactory)] +impl DataContractFactoryWasm { + #[wasm_bindgen(constructor)] + pub fn new( + protocol_version: u32, + validate_data_contract: DataContractValidatorWasm, + external_entropy_generator_arg: Option, + ) -> DataContractFactoryWasm { + if let Some(external_entropy_generator) = external_entropy_generator_arg { + DataContractFactory::new_with_entropy_generator( + protocol_version, + Arc::new(validate_data_contract.into()), + Box::new(external_entropy_generator), + ) + } else { + DataContractFactory::new(protocol_version, Arc::new(validate_data_contract.into())) + } + .into() + } + + #[wasm_bindgen(js_name=create)] + pub fn create( + &self, + owner_id: Vec, + documents: JsValue, + ) -> Result { + let documents_object: platform_value::Value = + with_js_error!(serde_wasm_bindgen::from_value(documents))?; + let identifier = Identifier::from_bytes(&owner_id) + .map_err(ProtocolError::ValueError) + .with_js_error()?; + //todo: contract config + self.0 + .create(identifier, documents_object, None, None) + .map(Into::into) + .with_js_error() + } + + #[wasm_bindgen(js_name=createFromObject)] + pub async fn create_from_object( + &self, + object: JsValue, + skip_validation: Option, + ) -> Result { + let parameters_value = js_value_to_data_contract_value(object.clone())?; + let result = self + .0 + .create_from_object(parameters_value, skip_validation.unwrap_or(false)) + .await; + match result { + Ok(data_contract) => Ok(data_contract.into()), + Err(dpp::ProtocolError::InvalidDataContractError(err)) => { + Err(InvalidDataContractError::new(err.errors, object).into()) + } + Err(other) => Err(from_dpp_err(other)), + } + } + + #[wasm_bindgen(js_name=createFromBuffer)] + pub async fn create_from_buffer( + &self, + buffer: Vec, + skip_validation: Option, + ) -> Result { + self.0 + .create_from_buffer(buffer, skip_validation.unwrap_or(false)) + .await + .map(Into::into) + .map_err(from_protocol_error) + } + + #[wasm_bindgen(js_name=createDataContractCreateTransition)] + pub async fn create_data_contract_create_transition( + &self, + data_contract: &DataContractWasm, + ) -> Result { + self.0 + .create_data_contract_create_transition(data_contract.clone().into()) + .map(Into::into) + .with_js_error() + } +} diff --git a/packages/wasm-dpp/src/document/extended_document.rs b/packages/wasm-dpp/src/document/extended_document.rs index 5ec98afa856..6ffccf18472 100644 --- a/packages/wasm-dpp/src/document/extended_document.rs +++ b/packages/wasm-dpp/src/document/extended_document.rs @@ -3,7 +3,7 @@ use dpp::document::{ExtendedDocument, EXTENDED_DOCUMENT_IDENTIFIER_FIELDS}; use dpp::platform_value::{Bytes32, Value}; use dpp::prelude::{Identifier, Revision}; -use dpp::util::json_schema::JsonSchemaExt; + use dpp::util::json_value::JsonValueExt; use dpp::platform_value::converter::serde_json::BTreeValueJsonConverter; @@ -13,7 +13,7 @@ use std::convert::TryInto; use wasm_bindgen::prelude::*; use crate::buffer::Buffer; -use crate::document::BinaryType; + use crate::errors::RustConversionError; use crate::identifier::{identifier_from_js_value, IdentifierWrapper}; use crate::lodash::lodash_set; @@ -313,25 +313,6 @@ impl ExtendedDocumentWasm { } } -impl ExtendedDocumentWasm { - fn get_binary_type_of_path(&self, path: &String) -> BinaryType { - let maybe_binary_properties = self - .0 - .data_contract - .get_binary_properties(&self.0.document_type_name); - - if let Ok(binary_properties) = maybe_binary_properties { - if let Some(data) = binary_properties.get(path) { - if data.is_type_of_identifier() { - return BinaryType::Identifier; - } - return BinaryType::Buffer; - } - } - BinaryType::None - } -} - impl From for ExtendedDocumentWasm { fn from(d: ExtendedDocument) -> Self { ExtendedDocumentWasm(d) diff --git a/packages/wasm-dpp/src/document/mod.rs b/packages/wasm-dpp/src/document/mod.rs index 30de808b273..7fb25ded7ff 100644 --- a/packages/wasm-dpp/src/document/mod.rs +++ b/packages/wasm-dpp/src/document/mod.rs @@ -1,6 +1,5 @@ use dpp::dashcore::anyhow::Context; use dpp::prelude::{DataContract, Identifier}; -use dpp::util::json_schema::JsonSchemaExt; use anyhow::anyhow; use serde::{Deserialize, Serialize}; @@ -33,7 +32,7 @@ use dpp::document::{Document, EXTENDED_DOCUMENT_IDENTIFIER_FIELDS, IDENTIFIER_FI pub use extended_document::ExtendedDocumentWasm; use dpp::document::extended_document::property_names; -use dpp::platform_value::btreemap_extensions::BTreeValueMapReplacementPathHelper; + use dpp::platform_value::converter::serde_json::BTreeValueJsonConverter; use dpp::platform_value::ReplacementType; use dpp::platform_value::Value; @@ -305,52 +304,6 @@ impl DocumentWasm { } } -impl DocumentWasm { - fn get_binary_type_of_path( - &self, - path: &String, - data_contract: &DataContractWasm, - document_type_name: String, - ) -> BinaryType { - let maybe_binary_properties = data_contract - .0 - .get_binary_properties(document_type_name.as_str()); - - if let Ok(binary_properties) = maybe_binary_properties { - if let Some(data) = binary_properties.get(path) { - if data.is_type_of_identifier() { - return BinaryType::Identifier; - } - return BinaryType::Buffer; - } - } - BinaryType::None - } -} - -/// document's dynamic data, regardless they are identifiers or binary, they should -/// be stored as arrays of int -pub(crate) fn document_data_to_bytes( - document: &mut Document, - contract: &DataContract, - document_type: &str, -) -> Result<(), JsValue> { - let (identifier_paths, binary_paths): (Vec<_>, Vec<_>) = contract - .get_identifiers_and_binary_paths_owned(document_type) - .with_js_error()?; - document - .properties - .replace_at_paths(identifier_paths, ReplacementType::Identifier) - .map_err(ProtocolError::ValueError) - .with_js_error()?; - document - .properties - .replace_at_paths(binary_paths, ReplacementType::BinaryBytes) - .map_err(ProtocolError::ValueError) - .with_js_error()?; - Ok(()) -} - pub(crate) fn raw_document_from_js_value( js_raw_document: &JsValue, data_contract: &DataContract, diff --git a/packages/wasm-dpp/src/document/state_transition/document_batch_transition/mod.rs b/packages/wasm-dpp/src/document/state_transition/document_batch_transition/mod.rs index 98ef0820ef9..599e0a3c36e 100644 --- a/packages/wasm-dpp/src/document/state_transition/document_batch_transition/mod.rs +++ b/packages/wasm-dpp/src/document/state_transition/document_batch_transition/mod.rs @@ -1,5 +1,5 @@ use dpp::identity::KeyID; -use dpp::state_transition::fee::calculate_state_transition_fee_factory::calculate_state_transition_fee; + use dpp::{ document::{ document_transition::document_base_transition, @@ -16,7 +16,6 @@ use dpp::{ use js_sys::{Array, Reflect}; use serde::{Deserialize, Serialize}; -use dpp::platform_value::btreemap_extensions::BTreeValueMapReplacementPathHelper; use dpp::platform_value::{BinaryData, ReplacementType}; use wasm_bindgen::prelude::*; diff --git a/packages/wasm-dpp/src/errors/value_error.rs b/packages/wasm-dpp/src/errors/value_error.rs index 51e6b2f6652..e2d4e0c7e29 100644 --- a/packages/wasm-dpp/src/errors/value_error.rs +++ b/packages/wasm-dpp/src/errors/value_error.rs @@ -39,7 +39,7 @@ impl PlatformValueErrorWasm { } #[wasm_bindgen(js_name=toString)] - pub fn to_string(&self) -> String { + pub fn stringify(&self) -> String { format!("PlatformValueError: {}", self.message) } } diff --git a/packages/wasm-dpp/src/identity/state_transition/identity_create_transition/identity_create_transition.rs b/packages/wasm-dpp/src/identity/state_transition/identity_create_transition/identity_create_transition.rs deleted file mode 100644 index 5a6ba58895d..00000000000 --- a/packages/wasm-dpp/src/identity/state_transition/identity_create_transition/identity_create_transition.rs +++ /dev/null @@ -1,359 +0,0 @@ -use std::convert::TryInto; -use std::default::Default; - -use wasm_bindgen::__rt::Ref; -use wasm_bindgen::prelude::*; - -use crate::identifier::IdentifierWrapper; - -use crate::{ - buffer::Buffer, - create_asset_lock_proof_from_wasm_instance, - errors::RustConversionError, - identity::state_transition::asset_lock_proof::{ - ChainAssetLockProofWasm, InstantAssetLockProofWasm, - }, - identity::state_transition::identity_public_key_transitions::IdentityPublicKeyWithWitnessWasm, - state_transition::StateTransitionExecutionContextWasm, - with_js_error, -}; - -use crate::bls_adapter::{BlsAdapter, JsBlsAdapter}; -use crate::errors::from_dpp_err; -use dpp::state_transition::StateTransitionConvert; - -use crate::utils::{generic_of_js_val, ToSerdeJSONExt, WithJsError}; -use dpp::platform_value::string_encoding::Encoding; -use dpp::platform_value::{string_encoding, BinaryData}; -use dpp::{ - identifier::Identifier, - identity::state_transition::{ - asset_lock_proof::AssetLockProof, identity_create_transition::IdentityCreateTransition, - identity_public_key_transitions::IdentityPublicKeyWithWitness, - }, - state_transition::StateTransitionLike, -}; - -#[wasm_bindgen(js_name=IdentityCreateTransition)] -#[derive(Clone)] -pub struct IdentityCreateTransitionWasm(IdentityCreateTransition); - -impl From for IdentityCreateTransitionWasm { - fn from(v: IdentityCreateTransition) -> Self { - IdentityCreateTransitionWasm(v) - } -} - -impl From for IdentityCreateTransition { - fn from(v: IdentityCreateTransitionWasm) -> Self { - v.0 - } -} - -#[wasm_bindgen(js_class = IdentityCreateTransition)] -impl IdentityCreateTransitionWasm { - #[wasm_bindgen(constructor)] - pub fn new(raw_parameters: JsValue) -> Result { - let mut raw_state_transition = raw_parameters.with_serde_to_platform_value()?; - IdentityCreateTransition::clean_value(&mut raw_state_transition).with_js_error()?; - let identity_create_transition = IdentityCreateTransition::new(raw_state_transition) - .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?; - - Ok(identity_create_transition.into()) - } - - #[wasm_bindgen(js_name=setAssetLockProof)] - pub fn set_asset_lock_proof(&mut self, asset_lock_proof: JsValue) -> Result<(), JsValue> { - let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&asset_lock_proof)?; - - self.0 - .set_asset_lock_proof(asset_lock_proof) - .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?; - - Ok(()) - } - - #[wasm_bindgen(getter, js_name=assetLockProof)] - pub fn asset_lock_proof(&self) -> JsValue { - self.get_asset_lock_proof() - } - - #[wasm_bindgen(js_name=getAssetLockProof)] - pub fn get_asset_lock_proof(&self) -> JsValue { - let asset_lock_proof = self.0.get_asset_lock_proof().to_owned(); - - match asset_lock_proof { - AssetLockProof::Chain(chain_asset_lock_proof) => { - ChainAssetLockProofWasm::from(chain_asset_lock_proof).into() - } - AssetLockProof::Instant(instant_asset_lock_proof) => { - InstantAssetLockProofWasm::from(instant_asset_lock_proof).into() - } - } - } - - #[wasm_bindgen(js_name=setPublicKeys)] - pub fn set_public_keys(&mut self, public_keys: Vec) -> Result<(), JsValue> { - let public_keys = public_keys - .iter() - .map(|value| { - let public_key: Ref = - generic_of_js_val::( - value, - "IdentityPublicKeyWithWitness", - )?; - Ok(public_key.clone().into()) - }) - .collect::, JsValue>>()?; - - self.0.set_public_keys(public_keys); - - Ok(()) - } - - #[wasm_bindgen(js_name=addPublicKeys)] - pub fn add_public_keys(&mut self, public_keys: Vec) -> Result<(), JsValue> { - let mut public_keys = public_keys - .iter() - .map(|value| { - let public_key: Ref = - generic_of_js_val::( - value, - "IdentityPublicKeyWithWitness", - )?; - Ok(public_key.clone().into()) - }) - .collect::, JsValue>>()?; - - self.0.add_public_keys(&mut public_keys); - - Ok(()) - } - - #[wasm_bindgen(js_name=getPublicKeys)] - pub fn get_public_keys(&self) -> Vec { - self.0 - .get_public_keys() - .iter() - .map(IdentityPublicKeyWithWitness::to_owned) - .map(IdentityPublicKeyWithWitnessWasm::from) - .map(JsValue::from) - .collect() - } - - #[wasm_bindgen(getter, js_name=publicKeys)] - pub fn public_keys(&self) -> Vec { - self.get_public_keys() - } - - #[wasm_bindgen(js_name=getType)] - pub fn get_type(&self) -> u8 { - self.0.get_type() as u8 - } - - #[wasm_bindgen(getter, js_name=identityId)] - pub fn identity_id(&self) -> IdentifierWrapper { - self.get_identity_id() - } - - #[wasm_bindgen(js_name=getIdentityId)] - pub fn get_identity_id(&self) -> IdentifierWrapper { - (*self.0.get_identity_id()).into() - } - - #[wasm_bindgen(js_name=getOwnerId)] - pub fn get_owner_id(&self) -> IdentifierWrapper { - (*self.0.get_owner_id()).into() - } - - #[wasm_bindgen(js_name=toObject)] - pub fn to_object(&self, options: JsValue) -> Result { - let opts: super::to_object::ToObjectOptions = if options.is_object() { - with_js_error!(serde_wasm_bindgen::from_value(options.clone()))? - } else { - Default::default() - }; - - let _skip_signature = opts.skip_signature; - let object = super::to_object::to_object_struct(&self.0, opts); - let js_object = js_sys::Object::new(); - - js_sys::Reflect::set( - &js_object, - &"type".to_owned().into(), - &object.transition_type.into(), - )?; - - js_sys::Reflect::set( - &js_object, - &"protocolVersion".to_owned().into(), - &object.protocol_version.into(), - )?; - - if let Some(signature) = object.signature { - let signature_value: JsValue = if signature.is_empty() { - JsValue::undefined() - } else { - Buffer::from_bytes(&signature).into() - }; - - js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?; - } - - let asset_lock_proof_object = match object.asset_lock_proof { - AssetLockProof::Instant(instant_asset_lock_proof) => { - InstantAssetLockProofWasm::from(instant_asset_lock_proof).to_object()? - } - AssetLockProof::Chain(chain_asset_lock_proof) => { - ChainAssetLockProofWasm::from(chain_asset_lock_proof).to_object()? - } - }; - - js_sys::Reflect::set( - &js_object, - &"assetLockProof".to_owned().into(), - &asset_lock_proof_object, - )?; - - let keys_objects = object - .public_keys - .into_iter() - .map(IdentityPublicKeyWithWitnessWasm::from) - .map(|key| key.to_object(options.clone())) - .collect::>()?; - - js_sys::Reflect::set(&js_object, &"publicKeys".to_owned().into(), &keys_objects)?; - - Ok(js_object.into()) - } - - #[wasm_bindgen(js_name=toBuffer)] - pub fn to_buffer(&self, options: JsValue) -> Result { - let opts: super::to_object::ToObjectOptions = if options.is_object() { - with_js_error!(serde_wasm_bindgen::from_value(options))? - } else { - Default::default() - }; - - let buffer = self - .0 - .to_buffer(opts.skip_signature.unwrap_or(false)) - .map_err(from_dpp_err)?; - - Ok(Buffer::from_bytes(&buffer).into()) - } - - #[wasm_bindgen(js_name=toJSON)] - pub fn to_json(&self) -> Result { - let object = super::to_object::to_object_struct(&self.0, Default::default()); - let js_object = js_sys::Object::new(); - - js_sys::Reflect::set( - &js_object, - &"type".to_owned().into(), - &object.transition_type.into(), - )?; - - js_sys::Reflect::set( - &js_object, - &"protocolVersion".to_owned().into(), - &object.protocol_version.into(), - )?; - - if let Some(signature) = object.signature { - let signature_value: JsValue = if signature.is_empty() { - JsValue::undefined() - } else { - string_encoding::encode(signature.as_slice(), Encoding::Base64).into() - }; - - js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?; - } - - let asset_lock_proof_json = match object.asset_lock_proof { - AssetLockProof::Instant(instant_asset_lock_proof) => { - InstantAssetLockProofWasm::from(instant_asset_lock_proof).to_json()? - } - AssetLockProof::Chain(chain_asset_lock_proof) => { - ChainAssetLockProofWasm::from(chain_asset_lock_proof).to_json()? - } - }; - - js_sys::Reflect::set( - &js_object, - &"assetLockProof".to_owned().into(), - &asset_lock_proof_json, - )?; - - let keys_objects = object - .public_keys - .into_iter() - .map(IdentityPublicKeyWithWitnessWasm::from) - .map(|key| key.to_json()) - .collect::>()?; - - js_sys::Reflect::set(&js_object, &"publicKeys".to_owned().into(), &keys_objects)?; - - Ok(js_object.into()) - } - - #[wasm_bindgen(js_name=getModifiedDataIds)] - pub fn get_modified_data_ids(&self) -> Vec { - let ids = self.0.get_modified_data_ids(); - - ids.into_iter() - .map(|id| >::from(id).into()) - .collect() - } - - #[wasm_bindgen(js_name=isDataContractStateTransition)] - pub fn is_data_contract_state_transition(&self) -> bool { - self.0.is_data_contract_state_transition() - } - - #[wasm_bindgen(js_name=isDocumentStateTransition)] - pub fn is_document_state_transition(&self) -> bool { - self.0.is_document_state_transition() - } - - #[wasm_bindgen(js_name=isIdentityStateTransition)] - pub fn is_identity_state_transition(&self) -> bool { - self.0.is_identity_state_transition() - } - - #[wasm_bindgen(js_name=setExecutionContext)] - pub fn set_execution_context(&mut self, context: &StateTransitionExecutionContextWasm) { - self.0.set_execution_context(context.into()) - } - - #[wasm_bindgen(js_name=getExecutionContext)] - pub fn get_execution_context(&mut self) -> StateTransitionExecutionContextWasm { - self.0.get_execution_context().into() - } - - #[wasm_bindgen(js_name=signByPrivateKey)] - pub fn sign_by_private_key( - &mut self, - private_key: Vec, - key_type: u8, - bls: JsBlsAdapter, - ) -> Result<(), JsValue> { - let bls_adapter = BlsAdapter(bls); - let key_type = key_type - .try_into() - .map_err(|e: anyhow::Error| e.to_string())?; - - self.0 - .sign_by_private_key(private_key.as_slice(), key_type, &bls_adapter) - .with_js_error() - } - - #[wasm_bindgen(js_name=getSignature)] - pub fn get_signature(&self) -> Buffer { - Buffer::from_bytes_owned(self.0.get_signature().to_vec()) - } - #[wasm_bindgen(js_name=setSignature)] - pub fn set_signature(&mut self, signature: Option>) { - self.0.signature = BinaryData::new(signature.unwrap_or(vec![])) - } -} diff --git a/packages/wasm-dpp/src/identity/state_transition/identity_create_transition/mod.rs b/packages/wasm-dpp/src/identity/state_transition/identity_create_transition/mod.rs index e2c7d563d9f..dde930102ba 100644 --- a/packages/wasm-dpp/src/identity/state_transition/identity_create_transition/mod.rs +++ b/packages/wasm-dpp/src/identity/state_transition/identity_create_transition/mod.rs @@ -1,8 +1,365 @@ -pub use identity_create_transition::*; - pub mod apply_identity_create_transition; -pub mod identity_create_transition; pub mod identity_create_transition_basic_validator; pub mod identity_create_transition_state_validator; mod to_object; + +use std::convert::TryInto; +use std::default::Default; + +use wasm_bindgen::__rt::Ref; +use wasm_bindgen::prelude::*; + +use crate::identifier::IdentifierWrapper; + +use crate::{ + buffer::Buffer, + create_asset_lock_proof_from_wasm_instance, + errors::RustConversionError, + identity::state_transition::asset_lock_proof::{ + ChainAssetLockProofWasm, InstantAssetLockProofWasm, + }, + identity::state_transition::identity_public_key_transitions::IdentityPublicKeyWithWitnessWasm, + state_transition::StateTransitionExecutionContextWasm, + with_js_error, +}; + +use crate::bls_adapter::{BlsAdapter, JsBlsAdapter}; +use crate::errors::from_dpp_err; +use dpp::state_transition::StateTransitionConvert; + +use crate::utils::{generic_of_js_val, ToSerdeJSONExt, WithJsError}; +use dpp::platform_value::string_encoding::Encoding; +use dpp::platform_value::{string_encoding, BinaryData}; +use dpp::{ + identifier::Identifier, + identity::state_transition::{ + asset_lock_proof::AssetLockProof, identity_create_transition::IdentityCreateTransition, + identity_public_key_transitions::IdentityPublicKeyWithWitness, + }, + state_transition::StateTransitionLike, +}; + +#[wasm_bindgen(js_name=IdentityCreateTransition)] +#[derive(Clone)] +pub struct IdentityCreateTransitionWasm(IdentityCreateTransition); + +impl From for IdentityCreateTransitionWasm { + fn from(v: IdentityCreateTransition) -> Self { + IdentityCreateTransitionWasm(v) + } +} + +impl From for IdentityCreateTransition { + fn from(v: IdentityCreateTransitionWasm) -> Self { + v.0 + } +} + +#[wasm_bindgen(js_class = IdentityCreateTransition)] +impl IdentityCreateTransitionWasm { + #[wasm_bindgen(constructor)] + pub fn new(raw_parameters: JsValue) -> Result { + let mut raw_state_transition = raw_parameters.with_serde_to_platform_value()?; + IdentityCreateTransition::clean_value(&mut raw_state_transition).with_js_error()?; + let identity_create_transition = IdentityCreateTransition::new(raw_state_transition) + .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?; + + Ok(identity_create_transition.into()) + } + + #[wasm_bindgen(js_name=setAssetLockProof)] + pub fn set_asset_lock_proof(&mut self, asset_lock_proof: JsValue) -> Result<(), JsValue> { + let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&asset_lock_proof)?; + + self.0 + .set_asset_lock_proof(asset_lock_proof) + .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?; + + Ok(()) + } + + #[wasm_bindgen(getter, js_name=assetLockProof)] + pub fn asset_lock_proof(&self) -> JsValue { + self.get_asset_lock_proof() + } + + #[wasm_bindgen(js_name=getAssetLockProof)] + pub fn get_asset_lock_proof(&self) -> JsValue { + let asset_lock_proof = self.0.get_asset_lock_proof().to_owned(); + + match asset_lock_proof { + AssetLockProof::Chain(chain_asset_lock_proof) => { + ChainAssetLockProofWasm::from(chain_asset_lock_proof).into() + } + AssetLockProof::Instant(instant_asset_lock_proof) => { + InstantAssetLockProofWasm::from(instant_asset_lock_proof).into() + } + } + } + + #[wasm_bindgen(js_name=setPublicKeys)] + pub fn set_public_keys(&mut self, public_keys: Vec) -> Result<(), JsValue> { + let public_keys = public_keys + .iter() + .map(|value| { + let public_key: Ref = + generic_of_js_val::( + value, + "IdentityPublicKeyWithWitness", + )?; + Ok(public_key.clone().into()) + }) + .collect::, JsValue>>()?; + + self.0.set_public_keys(public_keys); + + Ok(()) + } + + #[wasm_bindgen(js_name=addPublicKeys)] + pub fn add_public_keys(&mut self, public_keys: Vec) -> Result<(), JsValue> { + let mut public_keys = public_keys + .iter() + .map(|value| { + let public_key: Ref = + generic_of_js_val::( + value, + "IdentityPublicKeyWithWitness", + )?; + Ok(public_key.clone().into()) + }) + .collect::, JsValue>>()?; + + self.0.add_public_keys(&mut public_keys); + + Ok(()) + } + + #[wasm_bindgen(js_name=getPublicKeys)] + pub fn get_public_keys(&self) -> Vec { + self.0 + .get_public_keys() + .iter() + .map(IdentityPublicKeyWithWitness::to_owned) + .map(IdentityPublicKeyWithWitnessWasm::from) + .map(JsValue::from) + .collect() + } + + #[wasm_bindgen(getter, js_name=publicKeys)] + pub fn public_keys(&self) -> Vec { + self.get_public_keys() + } + + #[wasm_bindgen(js_name=getType)] + pub fn get_type(&self) -> u8 { + self.0.get_type() as u8 + } + + #[wasm_bindgen(getter, js_name=identityId)] + pub fn identity_id(&self) -> IdentifierWrapper { + self.get_identity_id() + } + + #[wasm_bindgen(js_name=getIdentityId)] + pub fn get_identity_id(&self) -> IdentifierWrapper { + (*self.0.get_identity_id()).into() + } + + #[wasm_bindgen(js_name=getOwnerId)] + pub fn get_owner_id(&self) -> IdentifierWrapper { + (*self.0.get_owner_id()).into() + } + + #[wasm_bindgen(js_name=toObject)] + pub fn to_object(&self, options: JsValue) -> Result { + let opts: to_object::ToObjectOptions = if options.is_object() { + with_js_error!(serde_wasm_bindgen::from_value(options.clone()))? + } else { + Default::default() + }; + + let _skip_signature = opts.skip_signature; + let object = to_object::to_object_struct(&self.0, opts); + let js_object = js_sys::Object::new(); + + js_sys::Reflect::set( + &js_object, + &"type".to_owned().into(), + &object.transition_type.into(), + )?; + + js_sys::Reflect::set( + &js_object, + &"protocolVersion".to_owned().into(), + &object.protocol_version.into(), + )?; + + if let Some(signature) = object.signature { + let signature_value: JsValue = if signature.is_empty() { + JsValue::undefined() + } else { + Buffer::from_bytes(&signature).into() + }; + + js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?; + } + + let asset_lock_proof_object = match object.asset_lock_proof { + AssetLockProof::Instant(instant_asset_lock_proof) => { + InstantAssetLockProofWasm::from(instant_asset_lock_proof).to_object()? + } + AssetLockProof::Chain(chain_asset_lock_proof) => { + ChainAssetLockProofWasm::from(chain_asset_lock_proof).to_object()? + } + }; + + js_sys::Reflect::set( + &js_object, + &"assetLockProof".to_owned().into(), + &asset_lock_proof_object, + )?; + + let keys_objects = object + .public_keys + .into_iter() + .map(IdentityPublicKeyWithWitnessWasm::from) + .map(|key| key.to_object(options.clone())) + .collect::>()?; + + js_sys::Reflect::set(&js_object, &"publicKeys".to_owned().into(), &keys_objects)?; + + Ok(js_object.into()) + } + + #[wasm_bindgen(js_name=toBuffer)] + pub fn to_buffer(&self, options: JsValue) -> Result { + let opts: to_object::ToObjectOptions = if options.is_object() { + with_js_error!(serde_wasm_bindgen::from_value(options))? + } else { + Default::default() + }; + + let buffer = self + .0 + .to_buffer(opts.skip_signature.unwrap_or(false)) + .map_err(from_dpp_err)?; + + Ok(Buffer::from_bytes(&buffer).into()) + } + + #[wasm_bindgen(js_name=toJSON)] + pub fn to_json(&self) -> Result { + let object = to_object::to_object_struct(&self.0, Default::default()); + let js_object = js_sys::Object::new(); + + js_sys::Reflect::set( + &js_object, + &"type".to_owned().into(), + &object.transition_type.into(), + )?; + + js_sys::Reflect::set( + &js_object, + &"protocolVersion".to_owned().into(), + &object.protocol_version.into(), + )?; + + if let Some(signature) = object.signature { + let signature_value: JsValue = if signature.is_empty() { + JsValue::undefined() + } else { + string_encoding::encode(signature.as_slice(), Encoding::Base64).into() + }; + + js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?; + } + + let asset_lock_proof_json = match object.asset_lock_proof { + AssetLockProof::Instant(instant_asset_lock_proof) => { + InstantAssetLockProofWasm::from(instant_asset_lock_proof).to_json()? + } + AssetLockProof::Chain(chain_asset_lock_proof) => { + ChainAssetLockProofWasm::from(chain_asset_lock_proof).to_json()? + } + }; + + js_sys::Reflect::set( + &js_object, + &"assetLockProof".to_owned().into(), + &asset_lock_proof_json, + )?; + + let keys_objects = object + .public_keys + .into_iter() + .map(IdentityPublicKeyWithWitnessWasm::from) + .map(|key| key.to_json()) + .collect::>()?; + + js_sys::Reflect::set(&js_object, &"publicKeys".to_owned().into(), &keys_objects)?; + + Ok(js_object.into()) + } + + #[wasm_bindgen(js_name=getModifiedDataIds)] + pub fn get_modified_data_ids(&self) -> Vec { + let ids = self.0.get_modified_data_ids(); + + ids.into_iter() + .map(|id| >::from(id).into()) + .collect() + } + + #[wasm_bindgen(js_name=isDataContractStateTransition)] + pub fn is_data_contract_state_transition(&self) -> bool { + self.0.is_data_contract_state_transition() + } + + #[wasm_bindgen(js_name=isDocumentStateTransition)] + pub fn is_document_state_transition(&self) -> bool { + self.0.is_document_state_transition() + } + + #[wasm_bindgen(js_name=isIdentityStateTransition)] + pub fn is_identity_state_transition(&self) -> bool { + self.0.is_identity_state_transition() + } + + #[wasm_bindgen(js_name=setExecutionContext)] + pub fn set_execution_context(&mut self, context: &StateTransitionExecutionContextWasm) { + self.0.set_execution_context(context.into()) + } + + #[wasm_bindgen(js_name=getExecutionContext)] + pub fn get_execution_context(&mut self) -> StateTransitionExecutionContextWasm { + self.0.get_execution_context().into() + } + + #[wasm_bindgen(js_name=signByPrivateKey)] + pub fn sign_by_private_key( + &mut self, + private_key: Vec, + key_type: u8, + bls: JsBlsAdapter, + ) -> Result<(), JsValue> { + let bls_adapter = BlsAdapter(bls); + let key_type = key_type + .try_into() + .map_err(|e: anyhow::Error| e.to_string())?; + + self.0 + .sign_by_private_key(private_key.as_slice(), key_type, &bls_adapter) + .with_js_error() + } + + #[wasm_bindgen(js_name=getSignature)] + pub fn get_signature(&self) -> Buffer { + Buffer::from_bytes_owned(self.0.get_signature().to_vec()) + } + #[wasm_bindgen(js_name=setSignature)] + pub fn set_signature(&mut self, signature: Option>) { + self.0.signature = BinaryData::new(signature.unwrap_or(vec![])) + } +} diff --git a/packages/wasm-dpp/src/identity/state_transition/identity_topup_transition/identity_topup_transition.rs b/packages/wasm-dpp/src/identity/state_transition/identity_topup_transition/identity_topup_transition.rs deleted file mode 100644 index 4953f249296..00000000000 --- a/packages/wasm-dpp/src/identity/state_transition/identity_topup_transition/identity_topup_transition.rs +++ /dev/null @@ -1,300 +0,0 @@ -use crate::utils::{ToSerdeJSONExt, WithJsError}; - -use std::convert::TryInto; -use std::default::Default; - -use wasm_bindgen::prelude::*; - -use crate::identifier::IdentifierWrapper; - -use crate::{ - buffer::Buffer, - create_asset_lock_proof_from_wasm_instance, - errors::RustConversionError, - identity::state_transition::asset_lock_proof::{ - ChainAssetLockProofWasm, InstantAssetLockProofWasm, - }, - state_transition::StateTransitionExecutionContextWasm, - with_js_error, -}; - -use crate::bls_adapter::{BlsAdapter, JsBlsAdapter}; - -use crate::errors::from_dpp_err; -use dpp::platform_value::string_encoding::Encoding; -use dpp::platform_value::{string_encoding, BinaryData}; -use dpp::state_transition::StateTransitionConvert; -use dpp::{ - identifier::Identifier, - identity::state_transition::{ - asset_lock_proof::AssetLockProof, identity_topup_transition::IdentityTopUpTransition, - }, - state_transition::StateTransitionLike, -}; - -#[wasm_bindgen(js_name=IdentityTopUpTransition)] -#[derive(Clone)] -pub struct IdentityTopUpTransitionWasm(IdentityTopUpTransition); - -impl From for IdentityTopUpTransitionWasm { - fn from(v: IdentityTopUpTransition) -> Self { - IdentityTopUpTransitionWasm(v) - } -} - -impl From for IdentityTopUpTransition { - fn from(v: IdentityTopUpTransitionWasm) -> Self { - v.0 - } -} - -#[wasm_bindgen(js_class = IdentityTopUpTransition)] -impl IdentityTopUpTransitionWasm { - #[wasm_bindgen(constructor)] - pub fn new(raw_parameters: JsValue) -> Result { - let raw_state_transition = raw_parameters.with_serde_to_platform_value()?; - - let identity_topup_transition = - IdentityTopUpTransition::from_raw_object(raw_state_transition) - .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?; - - Ok(identity_topup_transition.into()) - } - - #[wasm_bindgen(js_name=setAssetLockProof)] - pub fn set_asset_lock_proof(&mut self, asset_lock_proof: JsValue) -> Result<(), JsValue> { - let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&asset_lock_proof)?; - - self.0 - .set_asset_lock_proof(asset_lock_proof) - .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?; - - Ok(()) - } - - #[wasm_bindgen(getter, js_name=assetLockProof)] - pub fn asset_lock_proof(&self) -> JsValue { - self.get_asset_lock_proof() - } - - #[wasm_bindgen(js_name=getAssetLockProof)] - pub fn get_asset_lock_proof(&self) -> JsValue { - let asset_lock_proof = self.0.get_asset_lock_proof().to_owned(); - - match asset_lock_proof { - AssetLockProof::Chain(chain_asset_lock_proof) => { - ChainAssetLockProofWasm::from(chain_asset_lock_proof).into() - } - AssetLockProof::Instant(instant_asset_lock_proof) => { - InstantAssetLockProofWasm::from(instant_asset_lock_proof).into() - } - } - } - - #[wasm_bindgen(js_name=getType)] - pub fn get_type(&self) -> u8 { - self.0.get_type() as u8 - } - - #[wasm_bindgen(getter, js_name=identityId)] - pub fn identity_id(&self) -> IdentifierWrapper { - self.get_identity_id() - } - - #[wasm_bindgen(js_name=getIdentityId)] - pub fn get_identity_id(&self) -> IdentifierWrapper { - (*self.0.get_identity_id()).into() - } - - #[wasm_bindgen(js_name=getOwnerId)] - pub fn get_owner_id(&self) -> IdentifierWrapper { - (*self.0.get_owner_id()).into() - } - - #[wasm_bindgen(js_name=toObject)] - pub fn to_object(&self, options: JsValue) -> Result { - let opts: super::to_object::ToObjectOptions = if options.is_object() { - with_js_error!(serde_wasm_bindgen::from_value(options))? - } else { - Default::default() - }; - - let object = super::to_object::to_object_struct(&self.0, opts); - let js_object = js_sys::Object::new(); - - js_sys::Reflect::set( - &js_object, - &"type".to_owned().into(), - &object.transition_type.into(), - )?; - - js_sys::Reflect::set( - &js_object, - &"protocolVersion".to_owned().into(), - &object.protocol_version.into(), - )?; - - if let Some(signature) = object.signature { - let signature_value: JsValue = if signature.is_empty() { - JsValue::undefined() - } else { - Buffer::from_bytes(signature.as_slice()).into() - }; - - js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?; - } - - let asset_lock_proof_object = match object.asset_lock_proof { - AssetLockProof::Instant(instant_asset_lock_proof) => { - InstantAssetLockProofWasm::from(instant_asset_lock_proof).to_object()? - } - AssetLockProof::Chain(chain_asset_lock_proof) => { - ChainAssetLockProofWasm::from(chain_asset_lock_proof).to_object()? - } - }; - - js_sys::Reflect::set( - &js_object, - &"assetLockProof".to_owned().into(), - &asset_lock_proof_object, - )?; - - js_sys::Reflect::set( - &js_object, - &"identityId".to_owned().into(), - &Buffer::from_bytes(object.identity_id.to_buffer().as_slice()), - )?; - - Ok(js_object.into()) - } - - #[wasm_bindgen(js_name=toBuffer)] - pub fn to_buffer(&self, options: JsValue) -> Result { - let opts: super::to_object::ToObjectOptions = if options.is_object() { - with_js_error!(serde_wasm_bindgen::from_value(options))? - } else { - Default::default() - }; - - let buffer = self - .0 - .to_buffer(opts.skip_signature.unwrap_or(false)) - .map_err(from_dpp_err)?; - - Ok(Buffer::from_bytes(&buffer).into()) - } - - #[wasm_bindgen(js_name=toJSON)] - pub fn to_json(&self) -> Result { - let object = super::to_object::to_object_struct(&self.0, Default::default()); - let js_object = js_sys::Object::new(); - - js_sys::Reflect::set( - &js_object, - &"type".to_owned().into(), - &object.transition_type.into(), - )?; - - js_sys::Reflect::set( - &js_object, - &"protocolVersion".to_owned().into(), - &object.protocol_version.into(), - )?; - - if let Some(signature) = object.signature { - let signature_value: JsValue = if signature.is_empty() { - JsValue::undefined() - } else { - string_encoding::encode(signature.as_slice(), Encoding::Base64).into() - }; - - js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?; - } - - let asset_lock_proof_json = match object.asset_lock_proof { - AssetLockProof::Instant(instant_asset_lock_proof) => { - InstantAssetLockProofWasm::from(instant_asset_lock_proof).to_json()? - } - AssetLockProof::Chain(chain_asset_lock_proof) => { - ChainAssetLockProofWasm::from(chain_asset_lock_proof).to_json()? - } - }; - - js_sys::Reflect::set( - &js_object, - &"assetLockProof".to_owned().into(), - &asset_lock_proof_json, - )?; - - let identity_id = object.identity_id.to_string(Encoding::Base58); - - js_sys::Reflect::set( - &js_object, - &"identityId".to_owned().into(), - &identity_id.into(), - )?; - - Ok(js_object.into()) - } - - #[wasm_bindgen(js_name=getModifiedDataIds)] - pub fn get_modified_data_ids(&self) -> Vec { - let ids = self.0.get_modified_data_ids(); - - ids.into_iter() - .map(|id| >::from(id).into()) - .collect() - } - - #[wasm_bindgen(js_name=isDataContractStateTransition)] - pub fn is_data_contract_state_transition(&self) -> bool { - self.0.is_data_contract_state_transition() - } - - #[wasm_bindgen(js_name=isDocumentStateTransition)] - pub fn is_document_state_transition(&self) -> bool { - self.0.is_document_state_transition() - } - - #[wasm_bindgen(js_name=isIdentityStateTransition)] - pub fn is_identity_state_transition(&self) -> bool { - self.0.is_identity_state_transition() - } - - #[wasm_bindgen(js_name=setExecutionContext)] - pub fn set_execution_context(&mut self, context: &StateTransitionExecutionContextWasm) { - self.0.set_execution_context(context.into()) - } - - #[wasm_bindgen(js_name=getExecutionContext)] - pub fn get_execution_context(&mut self) -> StateTransitionExecutionContextWasm { - self.0.get_execution_context().into() - } - - #[wasm_bindgen(js_name=signByPrivateKey)] - pub fn sign_by_private_key( - &mut self, - private_key: Vec, - key_type: u8, - bls: JsBlsAdapter, - ) -> Result<(), JsValue> { - let bls_adapter = BlsAdapter(bls); - let key_type = key_type - .try_into() - .map_err(|e: anyhow::Error| e.to_string())?; - - self.0 - .sign_by_private_key(private_key.as_slice(), key_type, &bls_adapter) - .with_js_error() - } - - #[wasm_bindgen(js_name=getSignature)] - pub fn get_signature(&self) -> Buffer { - Buffer::from_bytes(self.0.get_signature().as_slice()) - } - - #[wasm_bindgen(js_name=setSignature)] - pub fn set_signature(&mut self, signature: Option>) { - self.0.signature = BinaryData::new(signature.unwrap_or(vec![])) - } -} diff --git a/packages/wasm-dpp/src/identity/state_transition/identity_topup_transition/mod.rs b/packages/wasm-dpp/src/identity/state_transition/identity_topup_transition/mod.rs index edb89f09993..88bfe2e5696 100644 --- a/packages/wasm-dpp/src/identity/state_transition/identity_topup_transition/mod.rs +++ b/packages/wasm-dpp/src/identity/state_transition/identity_topup_transition/mod.rs @@ -1,8 +1,306 @@ -pub use identity_topup_transition::*; - pub mod apply_identity_topup_transition; -pub mod identity_topup_transition; pub mod identity_topup_transition_basic_validator; pub mod identity_topup_transition_state_validator; mod to_object; + +use crate::utils::{ToSerdeJSONExt, WithJsError}; + +use std::convert::TryInto; +use std::default::Default; + +use wasm_bindgen::prelude::*; + +use crate::identifier::IdentifierWrapper; + +use crate::{ + buffer::Buffer, + create_asset_lock_proof_from_wasm_instance, + errors::RustConversionError, + identity::state_transition::asset_lock_proof::{ + ChainAssetLockProofWasm, InstantAssetLockProofWasm, + }, + state_transition::StateTransitionExecutionContextWasm, + with_js_error, +}; + +use crate::bls_adapter::{BlsAdapter, JsBlsAdapter}; + +use crate::errors::from_dpp_err; +use dpp::platform_value::string_encoding::Encoding; +use dpp::platform_value::{string_encoding, BinaryData}; +use dpp::state_transition::StateTransitionConvert; +use dpp::{ + identifier::Identifier, + identity::state_transition::{ + asset_lock_proof::AssetLockProof, identity_topup_transition::IdentityTopUpTransition, + }, + state_transition::StateTransitionLike, +}; + +#[wasm_bindgen(js_name=IdentityTopUpTransition)] +#[derive(Clone)] +pub struct IdentityTopUpTransitionWasm(IdentityTopUpTransition); + +impl From for IdentityTopUpTransitionWasm { + fn from(v: IdentityTopUpTransition) -> Self { + IdentityTopUpTransitionWasm(v) + } +} + +impl From for IdentityTopUpTransition { + fn from(v: IdentityTopUpTransitionWasm) -> Self { + v.0 + } +} + +#[wasm_bindgen(js_class = IdentityTopUpTransition)] +impl IdentityTopUpTransitionWasm { + #[wasm_bindgen(constructor)] + pub fn new(raw_parameters: JsValue) -> Result { + let raw_state_transition = raw_parameters.with_serde_to_platform_value()?; + + let identity_topup_transition = + IdentityTopUpTransition::from_raw_object(raw_state_transition) + .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?; + + Ok(identity_topup_transition.into()) + } + + #[wasm_bindgen(js_name=setAssetLockProof)] + pub fn set_asset_lock_proof(&mut self, asset_lock_proof: JsValue) -> Result<(), JsValue> { + let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&asset_lock_proof)?; + + self.0 + .set_asset_lock_proof(asset_lock_proof) + .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?; + + Ok(()) + } + + #[wasm_bindgen(getter, js_name=assetLockProof)] + pub fn asset_lock_proof(&self) -> JsValue { + self.get_asset_lock_proof() + } + + #[wasm_bindgen(js_name=getAssetLockProof)] + pub fn get_asset_lock_proof(&self) -> JsValue { + let asset_lock_proof = self.0.get_asset_lock_proof().to_owned(); + + match asset_lock_proof { + AssetLockProof::Chain(chain_asset_lock_proof) => { + ChainAssetLockProofWasm::from(chain_asset_lock_proof).into() + } + AssetLockProof::Instant(instant_asset_lock_proof) => { + InstantAssetLockProofWasm::from(instant_asset_lock_proof).into() + } + } + } + + #[wasm_bindgen(js_name=getType)] + pub fn get_type(&self) -> u8 { + self.0.get_type() as u8 + } + + #[wasm_bindgen(getter, js_name=identityId)] + pub fn identity_id(&self) -> IdentifierWrapper { + self.get_identity_id() + } + + #[wasm_bindgen(js_name=getIdentityId)] + pub fn get_identity_id(&self) -> IdentifierWrapper { + (*self.0.get_identity_id()).into() + } + + #[wasm_bindgen(js_name=getOwnerId)] + pub fn get_owner_id(&self) -> IdentifierWrapper { + (*self.0.get_owner_id()).into() + } + + #[wasm_bindgen(js_name=toObject)] + pub fn to_object(&self, options: JsValue) -> Result { + let opts: to_object::ToObjectOptions = if options.is_object() { + with_js_error!(serde_wasm_bindgen::from_value(options))? + } else { + Default::default() + }; + + let object = to_object::to_object_struct(&self.0, opts); + let js_object = js_sys::Object::new(); + + js_sys::Reflect::set( + &js_object, + &"type".to_owned().into(), + &object.transition_type.into(), + )?; + + js_sys::Reflect::set( + &js_object, + &"protocolVersion".to_owned().into(), + &object.protocol_version.into(), + )?; + + if let Some(signature) = object.signature { + let signature_value: JsValue = if signature.is_empty() { + JsValue::undefined() + } else { + Buffer::from_bytes(signature.as_slice()).into() + }; + + js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?; + } + + let asset_lock_proof_object = match object.asset_lock_proof { + AssetLockProof::Instant(instant_asset_lock_proof) => { + InstantAssetLockProofWasm::from(instant_asset_lock_proof).to_object()? + } + AssetLockProof::Chain(chain_asset_lock_proof) => { + ChainAssetLockProofWasm::from(chain_asset_lock_proof).to_object()? + } + }; + + js_sys::Reflect::set( + &js_object, + &"assetLockProof".to_owned().into(), + &asset_lock_proof_object, + )?; + + js_sys::Reflect::set( + &js_object, + &"identityId".to_owned().into(), + &Buffer::from_bytes(object.identity_id.to_buffer().as_slice()), + )?; + + Ok(js_object.into()) + } + + #[wasm_bindgen(js_name=toBuffer)] + pub fn to_buffer(&self, options: JsValue) -> Result { + let opts: to_object::ToObjectOptions = if options.is_object() { + with_js_error!(serde_wasm_bindgen::from_value(options))? + } else { + Default::default() + }; + + let buffer = self + .0 + .to_buffer(opts.skip_signature.unwrap_or(false)) + .map_err(from_dpp_err)?; + + Ok(Buffer::from_bytes(&buffer).into()) + } + + #[wasm_bindgen(js_name=toJSON)] + pub fn to_json(&self) -> Result { + let object = to_object::to_object_struct(&self.0, Default::default()); + let js_object = js_sys::Object::new(); + + js_sys::Reflect::set( + &js_object, + &"type".to_owned().into(), + &object.transition_type.into(), + )?; + + js_sys::Reflect::set( + &js_object, + &"protocolVersion".to_owned().into(), + &object.protocol_version.into(), + )?; + + if let Some(signature) = object.signature { + let signature_value: JsValue = if signature.is_empty() { + JsValue::undefined() + } else { + string_encoding::encode(signature.as_slice(), Encoding::Base64).into() + }; + + js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?; + } + + let asset_lock_proof_json = match object.asset_lock_proof { + AssetLockProof::Instant(instant_asset_lock_proof) => { + InstantAssetLockProofWasm::from(instant_asset_lock_proof).to_json()? + } + AssetLockProof::Chain(chain_asset_lock_proof) => { + ChainAssetLockProofWasm::from(chain_asset_lock_proof).to_json()? + } + }; + + js_sys::Reflect::set( + &js_object, + &"assetLockProof".to_owned().into(), + &asset_lock_proof_json, + )?; + + let identity_id = object.identity_id.to_string(Encoding::Base58); + + js_sys::Reflect::set( + &js_object, + &"identityId".to_owned().into(), + &identity_id.into(), + )?; + + Ok(js_object.into()) + } + + #[wasm_bindgen(js_name=getModifiedDataIds)] + pub fn get_modified_data_ids(&self) -> Vec { + let ids = self.0.get_modified_data_ids(); + + ids.into_iter() + .map(|id| >::from(id).into()) + .collect() + } + + #[wasm_bindgen(js_name=isDataContractStateTransition)] + pub fn is_data_contract_state_transition(&self) -> bool { + self.0.is_data_contract_state_transition() + } + + #[wasm_bindgen(js_name=isDocumentStateTransition)] + pub fn is_document_state_transition(&self) -> bool { + self.0.is_document_state_transition() + } + + #[wasm_bindgen(js_name=isIdentityStateTransition)] + pub fn is_identity_state_transition(&self) -> bool { + self.0.is_identity_state_transition() + } + + #[wasm_bindgen(js_name=setExecutionContext)] + pub fn set_execution_context(&mut self, context: &StateTransitionExecutionContextWasm) { + self.0.set_execution_context(context.into()) + } + + #[wasm_bindgen(js_name=getExecutionContext)] + pub fn get_execution_context(&mut self) -> StateTransitionExecutionContextWasm { + self.0.get_execution_context().into() + } + + #[wasm_bindgen(js_name=signByPrivateKey)] + pub fn sign_by_private_key( + &mut self, + private_key: Vec, + key_type: u8, + bls: JsBlsAdapter, + ) -> Result<(), JsValue> { + let bls_adapter = BlsAdapter(bls); + let key_type = key_type + .try_into() + .map_err(|e: anyhow::Error| e.to_string())?; + + self.0 + .sign_by_private_key(private_key.as_slice(), key_type, &bls_adapter) + .with_js_error() + } + + #[wasm_bindgen(js_name=getSignature)] + pub fn get_signature(&self) -> Buffer { + Buffer::from_bytes(self.0.get_signature().as_slice()) + } + + #[wasm_bindgen(js_name=setSignature)] + pub fn set_signature(&mut self, signature: Option>) { + self.0.signature = BinaryData::new(signature.unwrap_or(vec![])) + } +} diff --git a/packages/wasm-dpp/src/identity/state_transition/identity_update_transition/identity_update_transition.rs b/packages/wasm-dpp/src/identity/state_transition/identity_update_transition/identity_update_transition.rs deleted file mode 100644 index 9cd16bd44d9..00000000000 --- a/packages/wasm-dpp/src/identity/state_transition/identity_update_transition/identity_update_transition.rs +++ /dev/null @@ -1,486 +0,0 @@ -use std::convert::TryInto; -use std::default::Default; - -use serde::{Deserialize, Serialize}; -use wasm_bindgen::__rt::Ref; -use wasm_bindgen::prelude::*; - -use crate::identifier::IdentifierWrapper; - -use crate::{ - buffer::Buffer, errors::RustConversionError, - identity::state_transition::identity_public_key_transitions::IdentityPublicKeyWithWitnessWasm, - identity::IdentityPublicKeyWasm, state_transition::StateTransitionExecutionContextWasm, - with_js_error, -}; - -use crate::bls_adapter::{BlsAdapter, JsBlsAdapter}; - -use crate::errors::from_dpp_err; -use crate::utils::{generic_of_js_val, WithJsError}; -use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyWithWitness; -use dpp::identity::{KeyID, TimestampMillis}; -use dpp::platform_value::string_encoding::Encoding; -use dpp::platform_value::{string_encoding, BinaryData, Value}; -use dpp::prelude::Revision; -use dpp::state_transition::{StateTransitionConvert, StateTransitionIdentitySigned}; -use dpp::{ - identifier::Identifier, - identity::state_transition::identity_update_transition::identity_update_transition::IdentityUpdateTransition, - platform_value, state_transition::StateTransitionLike, ProtocolError, -}; - -#[wasm_bindgen(js_name=IdentityUpdateTransition)] -#[derive(Clone)] -pub struct IdentityUpdateTransitionWasm(IdentityUpdateTransition); - -#[derive(Deserialize, Serialize)] -#[serde(rename_all = "camelCase")] -struct IdentityUpdateTransitionParams { - signature: Vec, - signature_public_key_id: KeyID, - protocol_version: u32, - identity_id: Vec, - revision: Revision, - add_public_keys: Option>, - disable_public_keys: Option>, - public_keys_disabled_at: Option, -} - -impl From for IdentityUpdateTransitionWasm { - fn from(v: IdentityUpdateTransition) -> Self { - IdentityUpdateTransitionWasm(v) - } -} - -impl From for IdentityUpdateTransition { - fn from(v: IdentityUpdateTransitionWasm) -> Self { - v.0 - } -} - -pub fn js_value_to_identity_update_transition_object(object: JsValue) -> Result { - let parameters: IdentityUpdateTransitionParams = - with_js_error!(serde_wasm_bindgen::from_value(object))?; - - platform_value::to_value(parameters).map_err(|e| e.to_string().into()) -} - -#[wasm_bindgen(js_class = IdentityUpdateTransition)] -impl IdentityUpdateTransitionWasm { - #[wasm_bindgen(constructor)] - pub fn new(raw_parameters: JsValue) -> Result { - let mut identity_update_transition_object = - js_value_to_identity_update_transition_object(raw_parameters)?; - - IdentityUpdateTransition::clean_value(&mut identity_update_transition_object) - .map_err(ProtocolError::ValueError) - .with_js_error()?; - - let identity_update_transition = - IdentityUpdateTransition::new(identity_update_transition_object) - .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?; - - Ok(identity_update_transition.into()) - } - - #[wasm_bindgen(js_name=setPublicKeysToAdd)] - pub fn set_public_keys_to_add( - &mut self, - public_keys: Option>, - ) -> Result<(), JsValue> { - let mut keys_to_add = vec![]; - if let Some(keys) = public_keys { - keys_to_add = keys - .iter() - .map(|value| { - let public_key: Ref = - generic_of_js_val::( - value, - "IdentityPublicKeyWithWitness", - )?; - Ok(public_key.clone().into()) - }) - .collect::, JsValue>>()?; - } - - self.0.set_public_keys_to_add(keys_to_add); - - Ok(()) - } - - #[wasm_bindgen(js_name=getPublicKeysToAdd)] - pub fn get_public_keys_add(&self) -> Vec { - self.0 - .get_public_keys_to_add() - .iter() - .map(|key| IdentityPublicKeyWithWitnessWasm::from(key.to_owned()).into()) - .collect() - } - - #[wasm_bindgen(getter, js_name=addPublicKeys)] - pub fn add_public_keys(&self) -> Vec { - self.get_public_keys_add() - } - - #[wasm_bindgen(js_name=getPublicKeyIdsToDisable)] - pub fn get_public_key_ids_to_disable(&self) -> Vec { - self.0 - .get_public_key_ids_to_disable() - .iter() - .map(|key| JsValue::from_f64(key.to_owned() as f64)) - .collect() - } - - #[wasm_bindgen(js_name=setPublicKeyIdsToDisable)] - pub fn set_public_key_ids_to_disable(&mut self, public_key_ids: Option>) { - let mut keys = vec![]; - if let Some(public_key_ids) = public_key_ids { - keys = public_key_ids - .iter() - .map(|key| key.to_owned() as KeyID) - .collect::>(); - } - - self.0.set_public_key_ids_to_disable(keys); - } - - #[wasm_bindgen(js_name=getPublicKeysDisabledAt)] - pub fn get_public_keys_disabled_at(&self) -> Option { - self.0 - .get_public_keys_disabled_at() - .map(|timestamp| js_sys::Date::new(&JsValue::from_f64(timestamp as f64))) - } - - #[wasm_bindgen(js_name=setPublicKeysDisabledAt)] - pub fn set_public_keys_disabled_at(&mut self, timestamp: Option) { - if let Some(timestamp) = timestamp { - self.0 - .set_public_keys_disabled_at(Some(timestamp.get_time() as TimestampMillis)); - } else { - self.0.set_public_keys_disabled_at(None); - } - } - - #[wasm_bindgen(js_name=getType)] - pub fn get_type(&self) -> u8 { - self.0.get_type() as u8 - } - - #[wasm_bindgen(getter, js_name=identityId)] - pub fn identity_id(&self) -> IdentifierWrapper { - self.get_identity_id() - } - - #[wasm_bindgen(js_name=getIdentityId)] - pub fn get_identity_id(&self) -> IdentifierWrapper { - (*self.0.get_identity_id()).into() - } - - #[wasm_bindgen(js_name=setIdentityId)] - pub fn set_identity_id(&mut self, identity_id: &IdentifierWrapper) { - self.0.set_identity_id(identity_id.to_owned().into()); - } - - #[wasm_bindgen(js_name=getOwnerId)] - pub fn get_owner_id(&self) -> IdentifierWrapper { - (*self.0.get_owner_id()).into() - } - - #[wasm_bindgen(js_name=toObject)] - pub fn to_object(&self, options: JsValue) -> Result { - let opts: super::to_object::ToObjectOptions = if options.is_object() { - with_js_error!(serde_wasm_bindgen::from_value(options.clone()))? - } else { - Default::default() - }; - - let object = super::to_object::to_object_struct(&self.0, opts); - let js_object = js_sys::Object::new(); - - js_sys::Reflect::set( - &js_object, - &"type".to_owned().into(), - &object.transition_type.into(), - )?; - - js_sys::Reflect::set( - &js_object, - &"protocolVersion".to_owned().into(), - &object.protocol_version.into(), - )?; - - js_sys::Reflect::set( - &js_object, - &"revision".to_owned().into(), - &object.revision.into(), - )?; - - if let Some(signature) = object.signature { - let signature_value: JsValue = if signature.is_empty() { - JsValue::undefined() - } else { - Buffer::from_bytes(&signature).into() - }; - - js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?; - - if let Some(signature_public_key_id) = object.signature_public_key_id { - js_sys::Reflect::set( - &js_object, - &"signaturePublicKeyId".to_owned().into(), - &JsValue::from(signature_public_key_id), - )?; - } else { - js_sys::Reflect::set( - &js_object, - &"signaturePublicKeyId".to_owned().into(), - &JsValue::undefined(), - )?; - } - } - - if let Some(timestamp) = object.public_keys_disabled_at { - js_sys::Reflect::set( - &js_object, - &"publicKeysDisabledAt".to_owned().into(), - &(timestamp as u32).into(), - )?; - } - - if let Some(public_keys_to_add) = object.public_keys_to_add { - let keys_objects = public_keys_to_add - .into_iter() - .map(|key| IdentityPublicKeyWithWitnessWasm::from(key).to_object(options.clone())) - .collect::>()?; - - js_sys::Reflect::set( - &js_object, - &"addPublicKeys".to_owned().into(), - &keys_objects, - )?; - } - - if let Some(public_key_ids_to_disable) = object.public_key_ids_to_disable { - let public_key_ids_to_disable = public_key_ids_to_disable - .into_iter() - .map(|key| JsValue::from_f64(key as f64)) - .collect::(); - - js_sys::Reflect::set( - &js_object, - &"disablePublicKeys".to_owned().into(), - &public_key_ids_to_disable.into(), - )?; - } - - js_sys::Reflect::set( - &js_object, - &"identityId".to_owned().into(), - &Buffer::from_bytes(object.identity_id.to_buffer().as_slice()), - )?; - - Ok(js_object.into()) - } - - #[wasm_bindgen(js_name=toBuffer)] - pub fn to_buffer(&self, options: JsValue) -> Result { - let opts: super::to_object::ToObjectOptions = if options.is_object() { - with_js_error!(serde_wasm_bindgen::from_value(options))? - } else { - Default::default() - }; - - let buffer = self - .0 - .to_buffer(opts.skip_signature.unwrap_or(false)) - .map_err(from_dpp_err)?; - - Ok(Buffer::from_bytes(&buffer).into()) - } - - #[wasm_bindgen(js_name=toJSON)] - pub fn to_json(&self) -> Result { - let object = super::to_object::to_object_struct(&self.0, Default::default()); - let js_object = js_sys::Object::new(); - - js_sys::Reflect::set( - &js_object, - &"type".to_owned().into(), - &object.transition_type.into(), - )?; - - js_sys::Reflect::set( - &js_object, - &"protocolVersion".to_owned().into(), - &object.protocol_version.into(), - )?; - - js_sys::Reflect::set( - &js_object, - &"revision".to_owned().into(), - &object.revision.into(), - )?; - - if let Some(signature) = object.signature { - let signature_value: JsValue = if signature.is_empty() { - JsValue::undefined() - } else { - string_encoding::encode(signature.as_slice(), Encoding::Base64).into() - }; - - js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?; - - if let Some(signature_public_key_id) = object.signature_public_key_id { - js_sys::Reflect::set( - &js_object, - &"signaturePublicKeyId".to_owned().into(), - &signature_public_key_id.into(), - )?; - } else { - js_sys::Reflect::set( - &js_object, - &"signaturePublicKeyId".to_owned().into(), - &JsValue::undefined(), - )?; - } - } - - if let Some(timestamp) = object.public_keys_disabled_at { - js_sys::Reflect::set( - &js_object, - &"publicKeysDisabledAt".to_owned().into(), - &(timestamp as u32).into(), - )?; - } - - if let Some(public_keys_to_add) = object.public_keys_to_add { - let keys_objects = public_keys_to_add - .into_iter() - .map(|key| IdentityPublicKeyWithWitnessWasm::from(key).to_json()) - .collect::>()?; - - js_sys::Reflect::set( - &js_object, - &"addPublicKeys".to_owned().into(), - &keys_objects, - )?; - } - - if let Some(public_key_ids_to_disable) = object.public_key_ids_to_disable { - let public_key_ids_to_disable = public_key_ids_to_disable - .into_iter() - .map(|key| JsValue::from_f64(key as f64)) - .collect::(); - - js_sys::Reflect::set( - &js_object, - &"disablePublicKeys".to_owned().into(), - &public_key_ids_to_disable.into(), - )?; - } - - let identity_id = object.identity_id.to_string(Encoding::Base58); - - js_sys::Reflect::set( - &js_object, - &"identityId".to_owned().into(), - &identity_id.into(), - )?; - - Ok(js_object.into()) - } - - #[wasm_bindgen(js_name=getModifiedDataIds)] - pub fn get_modified_data_ids(&self) -> Vec { - let ids = self.0.get_modified_data_ids(); - - ids.into_iter() - .map(|id| >::from(id).into()) - .collect() - } - - #[wasm_bindgen(js_name=isDataContractStateTransition)] - pub fn is_data_contract_state_transition(&self) -> bool { - self.0.is_data_contract_state_transition() - } - - #[wasm_bindgen(js_name=isDocumentStateTransition)] - pub fn is_document_state_transition(&self) -> bool { - self.0.is_document_state_transition() - } - - #[wasm_bindgen(js_name=isIdentityStateTransition)] - pub fn is_identity_state_transition(&self) -> bool { - self.0.is_identity_state_transition() - } - - #[wasm_bindgen(js_name=setExecutionContext)] - pub fn set_execution_context(&mut self, context: &StateTransitionExecutionContextWasm) { - self.0.set_execution_context(context.into()) - } - - #[wasm_bindgen(js_name=getExecutionContext)] - pub fn get_execution_context(&mut self) -> StateTransitionExecutionContextWasm { - self.0.get_execution_context().into() - } - - #[wasm_bindgen(js_name=signByPrivateKey)] - pub fn sign_by_private_key( - &mut self, - private_key: Vec, - key_type: u8, - bls: JsBlsAdapter, - ) -> Result<(), JsValue> { - let bls_adapter = BlsAdapter(bls); - let key_type = key_type - .try_into() - .map_err(|e: anyhow::Error| e.to_string())?; - - self.0 - .sign_by_private_key(private_key.as_slice(), key_type, &bls_adapter) - .with_js_error() - } - - #[wasm_bindgen(js_name=setSignaturePublicKeyId)] - pub fn set_signature_public_key_id(&mut self, key_id: Option) { - self.0.set_signature_public_key_id(key_id.unwrap_or(0)) - } - - #[wasm_bindgen(js_name=getSignature)] - pub fn get_signature(&self) -> Buffer { - Buffer::from_bytes_owned(self.0.get_signature().to_vec()) - } - - #[wasm_bindgen(js_name=setSignature)] - pub fn set_signature(&mut self, signature: Option>) { - self.0.signature = BinaryData::new(signature.unwrap_or(vec![])) - } - - #[wasm_bindgen(js_name=getRevision)] - pub fn get_revision(&self) -> u32 { - self.0.get_revision() as u32 - } - - #[wasm_bindgen(js_name=setRevision)] - pub fn set_revision(&mut self, revision: u32) { - self.0.set_revision(revision as u64) - } - - #[wasm_bindgen] - pub fn sign( - &mut self, - identity_public_key: &IdentityPublicKeyWasm, - private_key: Vec, - bls: JsBlsAdapter, - ) -> Result<(), JsValue> { - let bls_adapter = BlsAdapter(bls); - self.0 - .sign( - &identity_public_key.to_owned().into(), - &private_key, - &bls_adapter, - ) - .with_js_error() - } -} diff --git a/packages/wasm-dpp/src/identity/state_transition/identity_update_transition/mod.rs b/packages/wasm-dpp/src/identity/state_transition/identity_update_transition/mod.rs index c3fc2962b77..0f216308314 100644 --- a/packages/wasm-dpp/src/identity/state_transition/identity_update_transition/mod.rs +++ b/packages/wasm-dpp/src/identity/state_transition/identity_update_transition/mod.rs @@ -1,9 +1,493 @@ -pub use identity_update_transition::*; - pub mod apply_identity_update_transition; pub mod identity_update_public_keys_validator; -pub mod identity_update_transition; pub mod identity_update_transition_basic_validator; pub mod identity_update_transition_state_validator; mod to_object; + +use std::convert::TryInto; +use std::default::Default; + +use serde::{Deserialize, Serialize}; +use wasm_bindgen::__rt::Ref; +use wasm_bindgen::prelude::*; + +use crate::identifier::IdentifierWrapper; + +use crate::{ + buffer::Buffer, errors::RustConversionError, + identity::state_transition::identity_public_key_transitions::IdentityPublicKeyWithWitnessWasm, + identity::IdentityPublicKeyWasm, state_transition::StateTransitionExecutionContextWasm, + with_js_error, +}; + +use crate::bls_adapter::{BlsAdapter, JsBlsAdapter}; + +use crate::errors::from_dpp_err; +use crate::utils::{generic_of_js_val, WithJsError}; +use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyWithWitness; +use dpp::identity::{KeyID, TimestampMillis}; +use dpp::platform_value::string_encoding::Encoding; +use dpp::platform_value::{string_encoding, BinaryData, Value}; +use dpp::prelude::Revision; +use dpp::state_transition::{StateTransitionConvert, StateTransitionIdentitySigned}; +use dpp::{ + identifier::Identifier, + identity::state_transition::identity_update_transition::identity_update_transition::IdentityUpdateTransition, + platform_value, state_transition::StateTransitionLike, ProtocolError, +}; + +#[wasm_bindgen(js_name=IdentityUpdateTransition)] +#[derive(Clone)] +pub struct IdentityUpdateTransitionWasm(IdentityUpdateTransition); + +#[derive(Deserialize, Serialize)] +#[serde(rename_all = "camelCase")] +struct IdentityUpdateTransitionParams { + signature: Vec, + signature_public_key_id: KeyID, + protocol_version: u32, + identity_id: Vec, + revision: Revision, + add_public_keys: Option>, + disable_public_keys: Option>, + public_keys_disabled_at: Option, +} + +impl From for IdentityUpdateTransitionWasm { + fn from(v: IdentityUpdateTransition) -> Self { + IdentityUpdateTransitionWasm(v) + } +} + +impl From for IdentityUpdateTransition { + fn from(v: IdentityUpdateTransitionWasm) -> Self { + v.0 + } +} + +pub fn js_value_to_identity_update_transition_object(object: JsValue) -> Result { + let parameters: IdentityUpdateTransitionParams = + with_js_error!(serde_wasm_bindgen::from_value(object))?; + + platform_value::to_value(parameters).map_err(|e| e.to_string().into()) +} + +#[wasm_bindgen(js_class = IdentityUpdateTransition)] +impl IdentityUpdateTransitionWasm { + #[wasm_bindgen(constructor)] + pub fn new(raw_parameters: JsValue) -> Result { + let mut identity_update_transition_object = + js_value_to_identity_update_transition_object(raw_parameters)?; + + IdentityUpdateTransition::clean_value(&mut identity_update_transition_object) + .map_err(ProtocolError::ValueError) + .with_js_error()?; + + let identity_update_transition = + IdentityUpdateTransition::new(identity_update_transition_object) + .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?; + + Ok(identity_update_transition.into()) + } + + #[wasm_bindgen(js_name=setPublicKeysToAdd)] + pub fn set_public_keys_to_add( + &mut self, + public_keys: Option>, + ) -> Result<(), JsValue> { + let mut keys_to_add = vec![]; + if let Some(keys) = public_keys { + keys_to_add = keys + .iter() + .map(|value| { + let public_key: Ref = + generic_of_js_val::( + value, + "IdentityPublicKeyWithWitness", + )?; + Ok(public_key.clone().into()) + }) + .collect::, JsValue>>()?; + } + + self.0.set_public_keys_to_add(keys_to_add); + + Ok(()) + } + + #[wasm_bindgen(js_name=getPublicKeysToAdd)] + pub fn get_public_keys_add(&self) -> Vec { + self.0 + .get_public_keys_to_add() + .iter() + .map(|key| IdentityPublicKeyWithWitnessWasm::from(key.to_owned()).into()) + .collect() + } + + #[wasm_bindgen(getter, js_name=addPublicKeys)] + pub fn add_public_keys(&self) -> Vec { + self.get_public_keys_add() + } + + #[wasm_bindgen(js_name=getPublicKeyIdsToDisable)] + pub fn get_public_key_ids_to_disable(&self) -> Vec { + self.0 + .get_public_key_ids_to_disable() + .iter() + .map(|key| JsValue::from_f64(key.to_owned() as f64)) + .collect() + } + + #[wasm_bindgen(js_name=setPublicKeyIdsToDisable)] + pub fn set_public_key_ids_to_disable(&mut self, public_key_ids: Option>) { + let mut keys = vec![]; + if let Some(public_key_ids) = public_key_ids { + keys = public_key_ids + .iter() + .map(|key| key.to_owned() as KeyID) + .collect::>(); + } + + self.0.set_public_key_ids_to_disable(keys); + } + + #[wasm_bindgen(js_name=getPublicKeysDisabledAt)] + pub fn get_public_keys_disabled_at(&self) -> Option { + self.0 + .get_public_keys_disabled_at() + .map(|timestamp| js_sys::Date::new(&JsValue::from_f64(timestamp as f64))) + } + + #[wasm_bindgen(js_name=setPublicKeysDisabledAt)] + pub fn set_public_keys_disabled_at(&mut self, timestamp: Option) { + if let Some(timestamp) = timestamp { + self.0 + .set_public_keys_disabled_at(Some(timestamp.get_time() as TimestampMillis)); + } else { + self.0.set_public_keys_disabled_at(None); + } + } + + #[wasm_bindgen(js_name=getType)] + pub fn get_type(&self) -> u8 { + self.0.get_type() as u8 + } + + #[wasm_bindgen(getter, js_name=identityId)] + pub fn identity_id(&self) -> IdentifierWrapper { + self.get_identity_id() + } + + #[wasm_bindgen(js_name=getIdentityId)] + pub fn get_identity_id(&self) -> IdentifierWrapper { + (*self.0.get_identity_id()).into() + } + + #[wasm_bindgen(js_name=setIdentityId)] + pub fn set_identity_id(&mut self, identity_id: &IdentifierWrapper) { + self.0.set_identity_id(identity_id.to_owned().into()); + } + + #[wasm_bindgen(js_name=getOwnerId)] + pub fn get_owner_id(&self) -> IdentifierWrapper { + (*self.0.get_owner_id()).into() + } + + #[wasm_bindgen(js_name=toObject)] + pub fn to_object(&self, options: JsValue) -> Result { + let opts: to_object::ToObjectOptions = if options.is_object() { + with_js_error!(serde_wasm_bindgen::from_value(options.clone()))? + } else { + Default::default() + }; + + let object = to_object::to_object_struct(&self.0, opts); + let js_object = js_sys::Object::new(); + + js_sys::Reflect::set( + &js_object, + &"type".to_owned().into(), + &object.transition_type.into(), + )?; + + js_sys::Reflect::set( + &js_object, + &"protocolVersion".to_owned().into(), + &object.protocol_version.into(), + )?; + + js_sys::Reflect::set( + &js_object, + &"revision".to_owned().into(), + &object.revision.into(), + )?; + + if let Some(signature) = object.signature { + let signature_value: JsValue = if signature.is_empty() { + JsValue::undefined() + } else { + Buffer::from_bytes(&signature).into() + }; + + js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?; + + if let Some(signature_public_key_id) = object.signature_public_key_id { + js_sys::Reflect::set( + &js_object, + &"signaturePublicKeyId".to_owned().into(), + &JsValue::from(signature_public_key_id), + )?; + } else { + js_sys::Reflect::set( + &js_object, + &"signaturePublicKeyId".to_owned().into(), + &JsValue::undefined(), + )?; + } + } + + if let Some(timestamp) = object.public_keys_disabled_at { + js_sys::Reflect::set( + &js_object, + &"publicKeysDisabledAt".to_owned().into(), + &(timestamp as u32).into(), + )?; + } + + if let Some(public_keys_to_add) = object.public_keys_to_add { + let keys_objects = public_keys_to_add + .into_iter() + .map(|key| IdentityPublicKeyWithWitnessWasm::from(key).to_object(options.clone())) + .collect::>()?; + + js_sys::Reflect::set( + &js_object, + &"addPublicKeys".to_owned().into(), + &keys_objects, + )?; + } + + if let Some(public_key_ids_to_disable) = object.public_key_ids_to_disable { + let public_key_ids_to_disable = public_key_ids_to_disable + .into_iter() + .map(|key| JsValue::from_f64(key as f64)) + .collect::(); + + js_sys::Reflect::set( + &js_object, + &"disablePublicKeys".to_owned().into(), + &public_key_ids_to_disable.into(), + )?; + } + + js_sys::Reflect::set( + &js_object, + &"identityId".to_owned().into(), + &Buffer::from_bytes(object.identity_id.to_buffer().as_slice()), + )?; + + Ok(js_object.into()) + } + + #[wasm_bindgen(js_name=toBuffer)] + pub fn to_buffer(&self, options: JsValue) -> Result { + let opts: to_object::ToObjectOptions = if options.is_object() { + with_js_error!(serde_wasm_bindgen::from_value(options))? + } else { + Default::default() + }; + + let buffer = self + .0 + .to_buffer(opts.skip_signature.unwrap_or(false)) + .map_err(from_dpp_err)?; + + Ok(Buffer::from_bytes(&buffer).into()) + } + + #[wasm_bindgen(js_name=toJSON)] + pub fn to_json(&self) -> Result { + let object = to_object::to_object_struct(&self.0, Default::default()); + let js_object = js_sys::Object::new(); + + js_sys::Reflect::set( + &js_object, + &"type".to_owned().into(), + &object.transition_type.into(), + )?; + + js_sys::Reflect::set( + &js_object, + &"protocolVersion".to_owned().into(), + &object.protocol_version.into(), + )?; + + js_sys::Reflect::set( + &js_object, + &"revision".to_owned().into(), + &object.revision.into(), + )?; + + if let Some(signature) = object.signature { + let signature_value: JsValue = if signature.is_empty() { + JsValue::undefined() + } else { + string_encoding::encode(signature.as_slice(), Encoding::Base64).into() + }; + + js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?; + + if let Some(signature_public_key_id) = object.signature_public_key_id { + js_sys::Reflect::set( + &js_object, + &"signaturePublicKeyId".to_owned().into(), + &signature_public_key_id.into(), + )?; + } else { + js_sys::Reflect::set( + &js_object, + &"signaturePublicKeyId".to_owned().into(), + &JsValue::undefined(), + )?; + } + } + + if let Some(timestamp) = object.public_keys_disabled_at { + js_sys::Reflect::set( + &js_object, + &"publicKeysDisabledAt".to_owned().into(), + &(timestamp as u32).into(), + )?; + } + + if let Some(public_keys_to_add) = object.public_keys_to_add { + let keys_objects = public_keys_to_add + .into_iter() + .map(|key| IdentityPublicKeyWithWitnessWasm::from(key).to_json()) + .collect::>()?; + + js_sys::Reflect::set( + &js_object, + &"addPublicKeys".to_owned().into(), + &keys_objects, + )?; + } + + if let Some(public_key_ids_to_disable) = object.public_key_ids_to_disable { + let public_key_ids_to_disable = public_key_ids_to_disable + .into_iter() + .map(|key| JsValue::from_f64(key as f64)) + .collect::(); + + js_sys::Reflect::set( + &js_object, + &"disablePublicKeys".to_owned().into(), + &public_key_ids_to_disable.into(), + )?; + } + + let identity_id = object.identity_id.to_string(Encoding::Base58); + + js_sys::Reflect::set( + &js_object, + &"identityId".to_owned().into(), + &identity_id.into(), + )?; + + Ok(js_object.into()) + } + + #[wasm_bindgen(js_name=getModifiedDataIds)] + pub fn get_modified_data_ids(&self) -> Vec { + let ids = self.0.get_modified_data_ids(); + + ids.into_iter() + .map(|id| >::from(id).into()) + .collect() + } + + #[wasm_bindgen(js_name=isDataContractStateTransition)] + pub fn is_data_contract_state_transition(&self) -> bool { + self.0.is_data_contract_state_transition() + } + + #[wasm_bindgen(js_name=isDocumentStateTransition)] + pub fn is_document_state_transition(&self) -> bool { + self.0.is_document_state_transition() + } + + #[wasm_bindgen(js_name=isIdentityStateTransition)] + pub fn is_identity_state_transition(&self) -> bool { + self.0.is_identity_state_transition() + } + + #[wasm_bindgen(js_name=setExecutionContext)] + pub fn set_execution_context(&mut self, context: &StateTransitionExecutionContextWasm) { + self.0.set_execution_context(context.into()) + } + + #[wasm_bindgen(js_name=getExecutionContext)] + pub fn get_execution_context(&mut self) -> StateTransitionExecutionContextWasm { + self.0.get_execution_context().into() + } + + #[wasm_bindgen(js_name=signByPrivateKey)] + pub fn sign_by_private_key( + &mut self, + private_key: Vec, + key_type: u8, + bls: JsBlsAdapter, + ) -> Result<(), JsValue> { + let bls_adapter = BlsAdapter(bls); + let key_type = key_type + .try_into() + .map_err(|e: anyhow::Error| e.to_string())?; + + self.0 + .sign_by_private_key(private_key.as_slice(), key_type, &bls_adapter) + .with_js_error() + } + + #[wasm_bindgen(js_name=setSignaturePublicKeyId)] + pub fn set_signature_public_key_id(&mut self, key_id: Option) { + self.0.set_signature_public_key_id(key_id.unwrap_or(0)) + } + + #[wasm_bindgen(js_name=getSignature)] + pub fn get_signature(&self) -> Buffer { + Buffer::from_bytes_owned(self.0.get_signature().to_vec()) + } + + #[wasm_bindgen(js_name=setSignature)] + pub fn set_signature(&mut self, signature: Option>) { + self.0.signature = BinaryData::new(signature.unwrap_or(vec![])) + } + + #[wasm_bindgen(js_name=getRevision)] + pub fn get_revision(&self) -> u32 { + self.0.get_revision() as u32 + } + + #[wasm_bindgen(js_name=setRevision)] + pub fn set_revision(&mut self, revision: u32) { + self.0.set_revision(revision as u64) + } + + #[wasm_bindgen] + pub fn sign( + &mut self, + identity_public_key: &IdentityPublicKeyWasm, + private_key: Vec, + bls: JsBlsAdapter, + ) -> Result<(), JsValue> { + let bls_adapter = BlsAdapter(bls); + self.0 + .sign( + &identity_public_key.to_owned().into(), + &private_key, + &bls_adapter, + ) + .with_js_error() + } +} diff --git a/packages/wasm-dpp/src/state_transition/fee/refunds.rs b/packages/wasm-dpp/src/state_transition/fee/refunds.rs index a54bcb46dbd..10cbd37b5cd 100644 --- a/packages/wasm-dpp/src/state_transition/fee/refunds.rs +++ b/packages/wasm-dpp/src/state_transition/fee/refunds.rs @@ -51,9 +51,9 @@ impl Inner for RefundsWasm { } pub fn convert_hashmap_to_jsmap(map: &HashMap) -> js_sys::Map { - let mut js_map = js_sys::Map::new(); + let js_map = js_sys::Map::new(); for (key, value) in map { - js_map.set(&JsValue::from_str(&key), &BigInt::from(*value)); + js_map.set(&JsValue::from_str(key), &BigInt::from(*value)); } js_map }