@dashevo/wasm-dpp 1.8.0 → 2.0.0-dev.1

package/src/document/state_transition/{document_batch_transition → batch_transition}/document_transition/mod.rs

@@ -7,17 +7,23 @@ mod document_create_transition;
 // pub use document_replace_transition::*;
 
 use dpp::platform_value::Value;
-use dpp::state_transition::documents_batch_transition::document_create_transition::v0::v0_methods::DocumentCreateTransitionV0Methods;
-use dpp::state_transition::documents_batch_transition::document_transition::action_type::TransitionActionTypeGetter;
-use dpp::state_transition::documents_batch_transition::document_transition::DocumentTransitionV0Methods;
-use dpp::{
-    state_transition::documents_batch_transition::document_transition::DocumentTransition,
-    util::json_value::JsonValueExt, ProtocolError,
+use dpp::state_transition::batch_transition::batched_transition::document_transition::{
+    DocumentTransition, DocumentTransitionV0Methods,
 };
+use dpp::state_transition::batch_transition::batched_transition::document_transition_action_type::DocumentTransitionActionTypeGetter;
+use dpp::state_transition::batch_transition::document_create_transition::v0::v0_methods::DocumentCreateTransitionV0Methods;
+use dpp::{util::json_value::JsonValueExt, ProtocolError};
 use serde::Serialize;
 use serde_json::Value as JsonValue;
 use wasm_bindgen::prelude::*;
-
+use dpp::fee::Credits;
+use dpp::platform_value::converter::serde_json::BTreeValueJsonConverter;
+use dpp::prelude::Revision;
+use dpp::state_transition::batch_transition::document_base_transition::DocumentBaseTransition;
+use dpp::state_transition::batch_transition::document_replace_transition::v0::v0_methods::DocumentReplaceTransitionV0Methods;
+use dpp::state_transition::batch_transition::batched_transition::document_purchase_transition::v0::v0_methods::DocumentPurchaseTransitionV0Methods;
+use dpp::state_transition::batch_transition::batched_transition::document_transfer_transition::v0::v0_methods::DocumentTransferTransitionV0Methods;
+use dpp::state_transition::batch_transition::batched_transition::document_update_price_transition::v0::v0_methods::DocumentUpdatePriceTransitionV0Methods;
 use crate::{
     buffer::Buffer,
     identifier::{identifier_from_js_value, IdentifierWrapper},
@@ -42,6 +48,28 @@ impl DocumentTransitionWasm {
         self.0.document_type_name().to_owned()
     }
 
+    #[wasm_bindgen(js_name=getData)]
+    pub fn get_data(&self) -> JsValue {
+        match &self.0 {
+            DocumentTransition::Create(document_create_transition) => {
+                let json_value = document_create_transition.data().to_json_value().unwrap();
+                json_value
+                    .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+                    .unwrap()
+            }
+            DocumentTransition::Replace(document_replace_transition) => {
+                let json_value = document_replace_transition.data().to_json_value().unwrap();
+                json_value
+                    .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+                    .unwrap()
+            }
+            DocumentTransition::Delete(_) => JsValue::null(),
+            DocumentTransition::Transfer(_) => JsValue::null(),
+            DocumentTransition::UpdatePrice(_) => JsValue::null(),
+            DocumentTransition::Purchase(_) => JsValue::null(),
+        }
+    }
+
     #[wasm_bindgen(js_name=getAction)]
     pub fn get_action(&self) -> u8 {
         self.0.action_type() as u8
@@ -59,18 +87,49 @@ impl DocumentTransitionWasm {
         Ok(())
     }
 
+    #[wasm_bindgen(js_name=getIdentityContractNonce)]
+    pub fn get_identity_contract_nonce(&self) -> JsValue {
+        match self.0.base() {
+            DocumentBaseTransition::V0(v0) => JsValue::from(v0.identity_contract_nonce),
+        }
+    }
+
     #[wasm_bindgen(js_name=getRevision)]
-    pub fn get_revision(&self) -> JsValue {
-        if let Some(revision) = self.0.revision() {
-            (revision as f64).into()
-        } else {
-            JsValue::NULL
+    pub fn get_revision(&self) -> Option<Revision> {
+        self.0.revision()
+    }
+    #[wasm_bindgen(js_name=getEntropy)]
+    pub fn get_entropy(&self) -> Option<Vec<u8>> {
+        self.0.entropy()
+    }
+
+    #[wasm_bindgen(js_name=get_price)]
+    pub fn get_price(&self) -> Option<Credits> {
+        match &self.0 {
+            DocumentTransition::Create(_) => None,
+            DocumentTransition::Replace(_) => None,
+            DocumentTransition::Delete(_) => None,
+            DocumentTransition::Transfer(_) => None,
+            DocumentTransition::UpdatePrice(update_price) => Some(update_price.price()),
+            DocumentTransition::Purchase(purchase) => Some(purchase.price()),
+        }
+    }
+
+    #[wasm_bindgen(js_name=getReceiverId)]
+    pub fn get_receiver_id(&self) -> Option<IdentifierWrapper> {
+        match &self.0 {
+            DocumentTransition::Create(_) => None,
+            DocumentTransition::Replace(_) => None,
+            DocumentTransition::Delete(_) => None,
+            DocumentTransition::Transfer(transfer) => Some(transfer.recipient_owner_id().into()),
+            DocumentTransition::UpdatePrice(_) => None,
+            DocumentTransition::Purchase(_) => None,
         }
     }
 
     #[wasm_bindgen(js_name=setRevision)]
-    pub fn set_revision(&mut self, revision: u32) {
-        self.0.set_revision(revision as u64);
+    pub fn set_revision(&mut self, revision: u64) {
+        self.0.set_revision(revision);
     }
 
     #[wasm_bindgen(js_name=hasPrefundedBalance)]
@@ -82,6 +141,32 @@ impl DocumentTransitionWasm {
             _ => false,
         }
     }
+
+    #[wasm_bindgen(js_name=getPrefundedVotingBalance)]
+    pub fn get_prefunded_voting_balance(&self) -> Result<JsValue, JsValue> {
+        match &self.0 {
+            DocumentTransition::Create(create_transition) => {
+                let prefunded_voting_balance = create_transition.prefunded_voting_balance().clone();
+
+                if prefunded_voting_balance.is_none() {
+                    return Ok(JsValue::null());
+                }
+
+                let (index_name, credits) = prefunded_voting_balance.unwrap();
+
+                let js_object = js_sys::Object::new();
+
+                js_sys::Reflect::set(
+                    &js_object,
+                    &JsValue::from_str(&index_name),
+                    &JsValue::from(credits),
+                )?;
+
+                Ok(JsValue::from(js_object))
+            }
+            _ => Ok(JsValue::null()),
+        }
+    }
 }
 
 impl From<DocumentTransition> for DocumentTransitionWasm {

package/src/document/state_transition/{document_batch_transition → batch_transition}/mod.rs

@@ -12,9 +12,8 @@ use dpp::consensus::signature::SignatureError;
 use dpp::consensus::ConsensusError;
 use dpp::platform_value::BinaryData;
 use dpp::serialization::PlatformSerializable;
-use dpp::state_transition::documents_batch_transition::accessors::DocumentsBatchTransitionAccessorsV0;
-use dpp::state_transition::documents_batch_transition::document_transition::DocumentTransition;
-use dpp::state_transition::documents_batch_transition::DocumentsBatchTransition;
+use dpp::state_transition::batch_transition::accessors::DocumentsBatchTransitionAccessorsV0;
+use dpp::state_transition::batch_transition::BatchTransition;
 use dpp::state_transition::StateTransition;
 use wasm_bindgen::prelude::*;
 
@@ -26,17 +25,23 @@ use crate::{
     IdentityPublicKeyWasm,
 };
 
-use document_transition::DocumentTransitionWasm;
-use dpp::state_transition::documents_batch_transition::methods::v0::DocumentsBatchTransitionMethodsV0;
+use dpp::ed25519_dalek::ed25519::signature::SignerMut;
+use dpp::state_transition::batch_transition::batched_transition::BatchedTransition;
+use dpp::state_transition::batch_transition::methods::v0::DocumentsBatchTransitionMethodsV0;
 
+use crate::batch_transition::batched_transition::BatchedTransitionWasm;
+use crate::batch_transition::document_transition::DocumentTransitionWasm;
+use crate::batch_transition::token_transition::TokenTransitionWasm;
 use dpp::state_transition::StateTransitionIdentitySigned;
 
+pub mod batched_transition;
 pub mod document_transition;
+pub mod token_transition;
 // pub mod validation;
 
 #[derive(Clone, Debug)]
-#[wasm_bindgen(js_name = DocumentsBatchTransition)]
-pub struct DocumentsBatchTransitionWasm(DocumentsBatchTransition);
+#[wasm_bindgen(js_name = BatchTransition)]
+pub struct BatchTransitionWasm(BatchTransition);
 
 #[derive(Debug, Serialize, Deserialize, Default, Clone, Copy)]
 #[serde(rename_all = "camelCase")]
@@ -47,8 +52,8 @@ pub struct ToObjectOptions {
     skip_identifiers_conversion: bool,
 }
 
-#[wasm_bindgen(js_class=DocumentsBatchTransition)]
-impl DocumentsBatchTransitionWasm {
+#[wasm_bindgen(js_class=BatchTransition)]
+impl BatchTransitionWasm {
     // #[wasm_bindgen(constructor)]
     // pub fn from_object(
     //     js_raw_transition: JsValue,
@@ -90,7 +95,7 @@ impl DocumentsBatchTransitionWasm {
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u8 {
-        StateTransitionType::DocumentsBatch.into()
+        StateTransitionType::Batch.into()
     }
 
     #[wasm_bindgen(js_name=getOwnerId)]
@@ -98,14 +103,26 @@ impl DocumentsBatchTransitionWasm {
         self.0.owner_id().to_owned().into()
     }
 
+    #[wasm_bindgen(js_name=getUserFeeIncrease)]
+    pub fn get_user_fee_increase(&self) -> u16 {
+        self.0.user_fee_increase() as u16
+    }
+
+    #[wasm_bindgen(js_name=setUserFeeIncrease)]
+    pub fn set_user_fee_increase(&mut self, user_fee_increase: u16) {
+        self.0.set_user_fee_increase(user_fee_increase);
+    }
+
     #[wasm_bindgen(js_name=getTransitions)]
     pub fn get_transitions(&self) -> js_sys::Array {
         let array = js_sys::Array::new();
-        let transitions = self.0.transitions();
 
-        for tr in transitions.iter().cloned() {
-            let transition: DocumentTransitionWasm = tr.into();
-            array.push(&transition.into());
+        for tr in self.0.transitions_iter() {
+            let js_value = match tr.to_owned_transition() {
+                BatchedTransition::Token(doc) => TokenTransitionWasm::from(doc).into(),
+                BatchedTransition::Document(tok) => DocumentTransitionWasm::from(tok).into(),
+            };
+            array.push(&js_value);
         }
 
         array
@@ -115,8 +132,8 @@ impl DocumentsBatchTransitionWasm {
     pub fn set_transitions(&mut self, js_transitions: Array) -> Result<(), JsValue> {
         let mut transitions = vec![];
         for js_transition in js_transitions.iter() {
-            let transition: DocumentTransition = js_transition
-                .to_wasm::<DocumentTransitionWasm>("DocumentTransition")?
+            let transition: BatchedTransition = js_transition
+                .to_wasm::<BatchedTransitionWasm>("BatchedTransition")?
                 .to_owned()
                 .into();
             transitions.push(transition)
@@ -128,8 +145,8 @@ impl DocumentsBatchTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=setIdentityContractNonce)]
-    pub fn set_identity_contract_nonce(&mut self, nonce: u32) {
-        self.0.set_identity_contract_nonce(nonce as u64);
+    pub fn set_identity_contract_nonce(&mut self, nonce: u64) {
+        self.0.set_identity_contract_nonce(nonce);
     }
 
     // #[wasm_bindgen(js_name=toJSON)]
@@ -276,7 +293,7 @@ impl DocumentsBatchTransitionWasm {
         let bls_adapter = BlsAdapter(bls);
 
         // TODO: come up with a better way to set signature to the binding.
-        let mut state_transition = StateTransition::DocumentsBatch(self.0.clone());
+        let mut state_transition = StateTransition::Batch(self.0.clone());
         state_transition
             .sign(
                 &identity_public_key.to_owned().into(),
@@ -322,7 +339,7 @@ impl DocumentsBatchTransitionWasm {
     ) -> Result<bool, JsValue> {
         let bls_adapter = BlsAdapter(bls);
 
-        let verification_result = StateTransition::DocumentsBatch(self.0.clone())
+        let verification_result = StateTransition::Batch(self.0.clone())
             .verify_signature(&identity_public_key.to_owned().into(), &bls_adapter);
 
         match verification_result {
@@ -402,10 +419,9 @@ impl DocumentsBatchTransitionWasm {
 
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
-        let bytes = PlatformSerializable::serialize_to_bytes(&StateTransition::DocumentsBatch(
-            self.0.clone(),
-        ))
-        .with_js_error()?;
+        let bytes =
+            PlatformSerializable::serialize_to_bytes(&StateTransition::Batch(self.0.clone()))
+                .with_js_error()?;
         Ok(Buffer::from_bytes(&bytes))
     }
 
@@ -423,14 +439,14 @@ impl DocumentsBatchTransitionWasm {
     // }
 }
 
-impl From<DocumentsBatchTransition> for DocumentsBatchTransitionWasm {
-    fn from(t: DocumentsBatchTransition) -> Self {
-        DocumentsBatchTransitionWasm(t)
+impl From<BatchTransition> for BatchTransitionWasm {
+    fn from(t: BatchTransition) -> Self {
+        BatchTransitionWasm(t)
     }
 }
 
-impl From<DocumentsBatchTransitionWasm> for DocumentsBatchTransition {
-    fn from(t: DocumentsBatchTransitionWasm) -> Self {
+impl From<BatchTransitionWasm> for BatchTransition {
+    fn from(t: BatchTransitionWasm) -> Self {
         t.0
     }
 }

package/src/document/state_transition/batch_transition/token_transition/burn.rs

@@ -0,0 +1,12 @@
+use dpp::state_transition::batch_transition::TokenBurnTransition;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name=TokenBurnTransition)]
+#[derive(Debug, Clone)]
+pub struct TokenBurnTransitionWasm(TokenBurnTransition);
+
+impl From<TokenBurnTransition> for TokenBurnTransitionWasm {
+    fn from(value: TokenBurnTransition) -> Self {
+        Self(value)
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/claim.rs

@@ -0,0 +1,12 @@
+use dpp::state_transition::batch_transition::TokenClaimTransition;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name=TokenClaimTransition)]
+#[derive(Debug, Clone)]
+pub struct TokenClaimTransitionWasm(TokenClaimTransition);
+
+impl From<TokenClaimTransition> for TokenClaimTransitionWasm {
+    fn from(value: TokenClaimTransition) -> Self {
+        Self(value)
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/config.rs

@@ -0,0 +1,12 @@
+use dpp::state_transition::batch_transition::TokenConfigUpdateTransition;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name=TokenConfigUpdateTransition)]
+#[derive(Debug, Clone)]
+pub struct TokenConfigUpdateTransitionWasm(TokenConfigUpdateTransition);
+
+impl From<TokenConfigUpdateTransition> for TokenConfigUpdateTransitionWasm {
+    fn from(value: TokenConfigUpdateTransition) -> Self {
+        Self(value)
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/destroy.rs

@@ -0,0 +1,22 @@
+use crate::identifier::IdentifierWrapper;
+use wasm_bindgen::prelude::wasm_bindgen;
+use dpp::state_transition::batch_transition::token_destroy_frozen_funds_transition::v0::v0_methods::TokenDestroyFrozenFundsTransitionV0Methods;
+use dpp::state_transition::batch_transition::TokenDestroyFrozenFundsTransition;
+
+#[wasm_bindgen(js_name=TokenDestroyFrozenFundsTransition)]
+#[derive(Debug, Clone)]
+pub struct TokenDestroyFrozenFundsTransitionWasm(TokenDestroyFrozenFundsTransition);
+
+impl From<TokenDestroyFrozenFundsTransition> for TokenDestroyFrozenFundsTransitionWasm {
+    fn from(value: TokenDestroyFrozenFundsTransition) -> Self {
+        Self(value)
+    }
+}
+
+#[wasm_bindgen(js_class = TokenDestroyFrozenFundsTransition)]
+impl TokenDestroyFrozenFundsTransitionWasm {
+    #[wasm_bindgen(js_name=getFrozenIdentityId)]
+    pub fn frozen_identity_id(&self) -> IdentifierWrapper {
+        self.0.frozen_identity_id().into()
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/emergency_action.rs

@@ -0,0 +1,12 @@
+use dpp::state_transition::batch_transition::TokenEmergencyActionTransition;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name=TokenEmergencyActionTransition)]
+#[derive(Debug, Clone)]
+pub struct TokenEmergencyActionTransitionWasm(TokenEmergencyActionTransition);
+
+impl From<TokenEmergencyActionTransition> for TokenEmergencyActionTransitionWasm {
+    fn from(value: TokenEmergencyActionTransition) -> Self {
+        Self(value)
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/freeze.rs

@@ -0,0 +1,22 @@
+use crate::identifier::IdentifierWrapper;
+use dpp::state_transition::batch_transition::token_freeze_transition::v0::v0_methods::TokenFreezeTransitionV0Methods;
+use dpp::state_transition::batch_transition::TokenFreezeTransition;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name=TokenFreezeTransition)]
+#[derive(Debug, Clone)]
+pub struct TokenFreezeTransitionWasm(TokenFreezeTransition);
+
+impl From<TokenFreezeTransition> for TokenFreezeTransitionWasm {
+    fn from(value: TokenFreezeTransition) -> Self {
+        Self(value)
+    }
+}
+
+#[wasm_bindgen(js_class = TokenFreezeTransition)]
+impl TokenFreezeTransitionWasm {
+    #[wasm_bindgen(js_name=getFrozenIdentityId)]
+    pub fn frozen_identity_id(&self) -> IdentifierWrapper {
+        self.0.frozen_identity_id().into()
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/mint.rs

@@ -0,0 +1,31 @@
+use crate::identifier::IdentifierWrapper;
+use crate::tokens::TokenConfigurationWasm;
+use crate::utils::WithJsError;
+use dpp::state_transition::batch_transition::token_mint_transition::v0::v0_methods::TokenMintTransitionV0Methods;
+use dpp::state_transition::batch_transition::TokenMintTransition;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen(js_name=TokenMintTransition)]
+#[derive(Debug, Clone)]
+pub struct TokenMintTransitionWasm(TokenMintTransition);
+
+impl From<TokenMintTransition> for TokenMintTransitionWasm {
+    fn from(value: TokenMintTransition) -> Self {
+        Self(value)
+    }
+}
+
+#[wasm_bindgen(js_class=TokenMintTransition)]
+impl TokenMintTransitionWasm {
+    #[wasm_bindgen(js_name=getRecipientId)]
+    pub fn recipient_id(
+        &self,
+        token_configuration: TokenConfigurationWasm,
+    ) -> Result<IdentifierWrapper, JsValue> {
+        self.0
+            .recipient_id(&token_configuration.into())
+            .with_js_error()
+            .map(Into::into)
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/mod.rs

@@ -0,0 +1,147 @@
+pub mod burn;
+mod claim;
+pub mod config;
+pub mod destroy;
+pub mod emergency_action;
+pub mod freeze;
+pub mod mint;
+pub mod transfer;
+pub mod unfreeze;
+
+use crate::batch_transition::token_transition::burn::TokenBurnTransitionWasm;
+use crate::batch_transition::token_transition::claim::TokenClaimTransitionWasm;
+use crate::batch_transition::token_transition::config::TokenConfigUpdateTransitionWasm;
+use crate::batch_transition::token_transition::destroy::TokenDestroyFrozenFundsTransitionWasm;
+use crate::batch_transition::token_transition::emergency_action::TokenEmergencyActionTransitionWasm;
+use crate::batch_transition::token_transition::freeze::TokenFreezeTransitionWasm;
+use crate::batch_transition::token_transition::mint::TokenMintTransitionWasm;
+use crate::batch_transition::token_transition::transfer::TokenTransferTransitionWasm;
+use crate::batch_transition::token_transition::unfreeze::TokenUnfreezeTransitionWasm;
+use crate::identifier::IdentifierWrapper;
+use dpp::prelude::IdentityNonce;
+use dpp::state_transition::batch_transition::batched_transition::token_transition::{
+    TokenTransition, TokenTransitionV0Methods,
+};
+use dpp::state_transition::batch_transition::token_base_transition::v0::v0_methods::TokenBaseTransitionV0Methods;
+use dpp::state_transition::batch_transition::token_base_transition::v0::TokenBaseTransitionV0;
+use dpp::state_transition::batch_transition::token_mint_transition::TokenMintTransitionV0;
+use dpp::state_transition::batch_transition::TokenMintTransition;
+use js_sys::Number;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen]
+pub enum TokenTransitionType {
+    Burn,
+    Mint,
+    Transfer,
+    Freeze,
+    Unfreeze,
+    DestroyFrozenFunds,
+    Claim,
+    EmergencyAction,
+    ConfigUpdate,
+}
+
+impl From<&TokenTransition> for TokenTransitionType {
+    fn from(t: &TokenTransition) -> Self {
+        match t {
+            TokenTransition::Burn(_) => TokenTransitionType::Burn,
+            TokenTransition::Mint(_) => TokenTransitionType::Mint,
+            TokenTransition::Transfer(_) => TokenTransitionType::Transfer,
+            TokenTransition::Freeze(_) => TokenTransitionType::Freeze,
+            TokenTransition::Unfreeze(_) => TokenTransitionType::Unfreeze,
+            TokenTransition::DestroyFrozenFunds(_) => TokenTransitionType::DestroyFrozenFunds,
+            TokenTransition::EmergencyAction(_) => TokenTransitionType::EmergencyAction,
+            TokenTransition::ConfigUpdate(_) => TokenTransitionType::ConfigUpdate,
+            TokenTransition::Claim(_) => TokenTransitionType::Claim,
+        }
+    }
+}
+
+#[wasm_bindgen(js_name=TokenTransition)]
+#[derive(Debug, Clone)]
+pub struct TokenTransitionWasm(TokenTransition);
+
+impl From<TokenTransition> for TokenTransitionWasm {
+    fn from(t: TokenTransition) -> Self {
+        TokenTransitionWasm(t)
+    }
+}
+
+impl From<TokenTransitionWasm> for TokenTransition {
+    fn from(t: TokenTransitionWasm) -> Self {
+        t.0
+    }
+}
+
+#[wasm_bindgen(js_class = TokenTransition)]
+impl TokenTransitionWasm {
+    #[wasm_bindgen(js_name=getTransitionType)]
+    pub fn transition_type(&self) -> TokenTransitionType {
+        TokenTransitionType::from(&self.0)
+    }
+
+    #[wasm_bindgen(js_name=getTokenId)]
+    pub fn token_id(&self) -> IdentifierWrapper {
+        self.0.base().token_id().into()
+    }
+
+    #[wasm_bindgen(js_name=getTokenContractPosition)]
+    pub fn token_contract_position(&self) -> Number {
+        self.0.base().token_contract_position().into()
+    }
+
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn data_contract_id(&self) -> IdentifierWrapper {
+        self.0.base().data_contract_id().into()
+    }
+
+    #[wasm_bindgen(js_name=getHistoricalDocumentTypeName)]
+    pub fn historical_document_type_name(&self) -> String {
+        self.0.historical_document_type_name().to_string()
+    }
+
+    #[wasm_bindgen(js_name=getHistoricalDocumentId)]
+    pub fn historical_document_id(
+        &self,
+        owner_id: IdentifierWrapper,
+        owner_nonce: IdentityNonce,
+    ) -> IdentifierWrapper {
+        self.0
+            .historical_document_id(owner_id.into(), owner_nonce)
+            .into()
+    }
+
+    #[wasm_bindgen(js_name=getIdentityContractNonce)]
+    pub fn identity_contract_nonce(&self) -> IdentityNonce {
+        self.0.base().identity_contract_nonce()
+    }
+
+    #[wasm_bindgen(js_name=toTransition)]
+    pub fn to_transition(&self) -> JsValue {
+        match &self.0 {
+            TokenTransition::Burn(burn) => TokenBurnTransitionWasm::from(burn.clone()).into(),
+            TokenTransition::Mint(mint) => TokenMintTransitionWasm::from(mint.clone()).into(),
+            TokenTransition::Transfer(transfer) => {
+                TokenTransferTransitionWasm::from(transfer.clone()).into()
+            }
+            TokenTransition::Freeze(freeze) => {
+                TokenFreezeTransitionWasm::from(freeze.clone()).into()
+            }
+            TokenTransition::Unfreeze(unfreeze) => {
+                TokenUnfreezeTransitionWasm::from(unfreeze.clone()).into()
+            }
+            TokenTransition::DestroyFrozenFunds(destroy_frozen_funds) => {
+                TokenDestroyFrozenFundsTransitionWasm::from(destroy_frozen_funds.clone()).into()
+            }
+            TokenTransition::EmergencyAction(emergency_action) => {
+                TokenEmergencyActionTransitionWasm::from(emergency_action.clone()).into()
+            }
+            TokenTransition::ConfigUpdate(config_update) => {
+                TokenConfigUpdateTransitionWasm::from(config_update.clone()).into()
+            }
+            TokenTransition::Claim(claim) => TokenClaimTransitionWasm::from(claim.clone()).into(),
+        }
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/transfer.rs

@@ -0,0 +1,22 @@
+use crate::identifier::IdentifierWrapper;
+use dpp::state_transition::batch_transition::token_transfer_transition::v0::v0_methods::TokenTransferTransitionV0Methods;
+use dpp::state_transition::batch_transition::TokenTransferTransition;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name=TokenTransferTransition)]
+#[derive(Debug, Clone)]
+pub struct TokenTransferTransitionWasm(TokenTransferTransition);
+
+impl From<TokenTransferTransition> for TokenTransferTransitionWasm {
+    fn from(value: TokenTransferTransition) -> Self {
+        Self(value)
+    }
+}
+
+#[wasm_bindgen(js_class = TokenTransferTransition)]
+impl TokenTransferTransitionWasm {
+    #[wasm_bindgen(js_name=getRecipientId)]
+    pub fn recipient_id(&self) -> IdentifierWrapper {
+        self.0.recipient_id().into()
+    }
+}

package/src/document/state_transition/batch_transition/token_transition/unfreeze.rs

@@ -0,0 +1,22 @@
+use crate::identifier::IdentifierWrapper;
+use dpp::state_transition::batch_transition::token_unfreeze_transition::v0::v0_methods::TokenUnfreezeTransitionV0Methods;
+use dpp::state_transition::batch_transition::TokenUnfreezeTransition;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name=TokenUnfreezeTransition)]
+#[derive(Debug, Clone)]
+pub struct TokenUnfreezeTransitionWasm(TokenUnfreezeTransition);
+
+impl From<TokenUnfreezeTransition> for TokenUnfreezeTransitionWasm {
+    fn from(value: TokenUnfreezeTransition) -> Self {
+        Self(value)
+    }
+}
+
+#[wasm_bindgen(js_class = TokenUnfreezeTransition)]
+impl TokenUnfreezeTransitionWasm {
+    #[wasm_bindgen(js_name=getFrozenIdentityId)]
+    pub fn frozen_identity_id(&self) -> IdentifierWrapper {
+        self.0.frozen_identity_id().into()
+    }
+}

package/src/document/state_transition/mod.rs

@@ -1 +1 @@
-pub mod document_batch_transition;
+pub mod batch_transition;

package/src/errors/consensus/basic/identity/identity_insufficient_balance_error.rs

@@ -23,8 +23,8 @@ impl IdentityInsufficientBalanceErrorWasm {
     }
 
     #[wasm_bindgen(js_name=getBalance)]
-    pub fn balance(&self) -> u32 {
-        self.inner.balance() as u32
+    pub fn balance(&self) -> u64 {
+        self.inner.balance()
     }
 
     #[wasm_bindgen(js_name=getCode)]