pshenmic-dpp 1.0.3 → 1.0.5

package/packages/documents_batch/src/document_transition/mod.rs

@@ -0,0 +1,166 @@
+use crate::transitions::create::DocumentCreateTransitionWASM;
+use crate::transitions::delete::DocumentDeleteTransitionWASM;
+use crate::transitions::purchase::DocumentPurchaseTransitionWASM;
+use crate::transitions::replace::DocumentReplaceTransitionWASM;
+use crate::transitions::transfer::DocumentTransferTransitionWASM;
+use crate::transitions::update_price::DocumentUpdatePriceTransitionWASM;
+use dpp::prelude::{Identifier, IdentityNonce, Revision};
+use dpp::state_transition::documents_batch_transition::document_transition::action_type::TransitionActionTypeGetter;
+use dpp::state_transition::documents_batch_transition::document_transition::{
+    DocumentTransition, DocumentTransitionV0Methods,
+};
+use pshenmic_dpp_enums::batch::batch_enum::BatchTypeWASM;
+use pshenmic_dpp_utils::identifier_from_js_value;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[derive(Clone)]
+#[wasm_bindgen(js_name = "DocumentTransitionWASM")]
+pub struct DocumentTransitionWASM(DocumentTransition);
+
+impl From<DocumentTransition> for DocumentTransitionWASM {
+    fn from(transition: DocumentTransition) -> Self {
+        DocumentTransitionWASM(transition)
+    }
+}
+
+impl From<DocumentTransitionWASM> for DocumentTransition {
+    fn from(transition: DocumentTransitionWASM) -> Self {
+        transition.0
+    }
+}
+
+#[wasm_bindgen]
+impl DocumentTransitionWASM {
+    #[wasm_bindgen(getter = "actionType")]
+    pub fn get_action_type(&self) -> String {
+        BatchTypeWASM::from(self.0.action_type()).into()
+    }
+
+    #[wasm_bindgen(getter = "dataContractId")]
+    pub fn get_data_contract_id(&self) -> Vec<u8> {
+        self.0.data_contract_id().to_vec()
+    }
+
+    #[wasm_bindgen(getter = "id")]
+    pub fn get_id(&self) -> Vec<u8> {
+        self.0.get_id().to_vec()
+    }
+
+    #[wasm_bindgen(getter = "documentTypeName")]
+    pub fn get_document_type_name(&self) -> String {
+        self.0.document_type_name().clone()
+    }
+
+    #[wasm_bindgen(getter = "identityContractNonce")]
+    pub fn get_identity_contract_nonce(&self) -> IdentityNonce {
+        self.0.identity_contract_nonce()
+    }
+
+    #[wasm_bindgen(getter = "revision")]
+    pub fn get_revision(&self) -> Option<Revision> {
+        self.0.revision()
+    }
+
+    #[wasm_bindgen(getter = "entropy")]
+    pub fn get_entropy(&self) -> Option<Vec<u8>> {
+        self.0.entropy()
+    }
+
+    #[wasm_bindgen(getter = "createTransition")]
+    pub fn get_create_transition(&self) -> Result<DocumentCreateTransitionWASM, JsValue> {
+        match self.0.clone() {
+            DocumentTransition::Create(create) => Ok(DocumentCreateTransitionWASM::from(create)),
+            _ => Err(JsValue::undefined()),
+        }
+    }
+
+    #[wasm_bindgen(getter = "replaceTransition")]
+    pub fn get_replace_transition(&self) -> Result<DocumentReplaceTransitionWASM, JsValue> {
+        match self.0.clone() {
+            DocumentTransition::Replace(replace) => {
+                Ok(DocumentReplaceTransitionWASM::from(replace))
+            }
+            _ => Err(JsValue::undefined()),
+        }
+    }
+
+    #[wasm_bindgen(getter = "deleteTransition")]
+    pub fn get_delete_transition(&self) -> Result<DocumentDeleteTransitionWASM, JsValue> {
+        match self.0.clone() {
+            DocumentTransition::Delete(delete) => Ok(DocumentDeleteTransitionWASM::from(delete)),
+            _ => Err(JsValue::undefined()),
+        }
+    }
+
+    #[wasm_bindgen(getter = "purchaseTransition")]
+    pub fn get_purchase_transition(&self) -> Result<DocumentPurchaseTransitionWASM, JsValue> {
+        match self.0.clone() {
+            DocumentTransition::Purchase(purchase) => {
+                Ok(DocumentPurchaseTransitionWASM::from(purchase))
+            }
+            _ => Err(JsValue::undefined()),
+        }
+    }
+
+    #[wasm_bindgen(getter = "transferTransition")]
+    pub fn get_transfer_transition(&self) -> Result<DocumentTransferTransitionWASM, JsValue> {
+        match self.0.clone() {
+            DocumentTransition::Transfer(transfer) => {
+                Ok(DocumentTransferTransitionWASM::from(transfer))
+            }
+            _ => Err(JsValue::undefined()),
+        }
+    }
+
+    #[wasm_bindgen(getter = "updatePriceTransition")]
+    pub fn get_update_price_transition(
+        &self,
+    ) -> Result<DocumentUpdatePriceTransitionWASM, JsValue> {
+        match self.0.clone() {
+            DocumentTransition::UpdatePrice(update_price) => {
+                Ok(DocumentUpdatePriceTransitionWASM::from(update_price))
+            }
+            _ => Err(JsValue::undefined()),
+        }
+    }
+
+    #[wasm_bindgen(setter = "dataContractId")]
+    pub fn set_data_contract_id(&mut self, js_data_contract_id: JsValue) -> Result<(), JsValue> {
+        let data_contract_id = identifier_from_js_value(&js_data_contract_id)?;
+
+        Ok(self.0.set_data_contract_id(data_contract_id))
+    }
+
+    #[wasm_bindgen(setter = "revision")]
+    pub fn set_revision(&mut self, revision: Revision) {
+        self.0.set_revision(revision)
+    }
+
+    #[wasm_bindgen(setter = "identityContractNonce")]
+    pub fn set_identity_contract_nonce(&mut self, identity_contract_nonce: IdentityNonce) {
+        self.0.set_identity_contract_nonce(identity_contract_nonce)
+    }
+}
+
+impl DocumentTransitionWASM {
+    pub fn rs_get_data_contract_id(&self) -> Identifier {
+        self.0.data_contract_id()
+    }
+
+    pub fn rs_get_id(&self) -> Identifier {
+        self.0.get_id()
+    }
+
+    pub fn rs_get_entropy(&self) -> Option<Vec<u8>> {
+        self.0.entropy()
+    }
+
+    pub fn rs_get_revision(&self) -> Option<Revision> {
+        self.0.revision()
+    }
+
+    pub fn rs_get_identity_contract_nonce(&self) -> IdentityNonce {
+        self.0.identity_contract_nonce()
+    }
+}

package/packages/documents_batch/src/generators.rs

@@ -0,0 +1,122 @@
+use dpp::fee::Credits;
+use dpp::prelude::{Identifier, IdentityNonce};
+use dpp::state_transition::documents_batch_transition::document_base_transition::DocumentBaseTransition;
+use dpp::state_transition::documents_batch_transition::document_base_transition::v0::DocumentBaseTransitionV0;
+use dpp::state_transition::documents_batch_transition::document_create_transition::DocumentCreateTransitionV0;
+use dpp::state_transition::documents_batch_transition::document_delete_transition::DocumentDeleteTransitionV0;
+use dpp::state_transition::documents_batch_transition::document_replace_transition::DocumentReplaceTransitionV0;
+use dpp::state_transition::documents_batch_transition::{
+    DocumentCreateTransition, DocumentDeleteTransition, DocumentReplaceTransition,
+};
+use dpp::state_transition::documents_batch_transition::document_transition::document_transfer_transition::DocumentTransferTransitionV0;
+use dpp::state_transition::documents_batch_transition::document_transition::{DocumentPurchaseTransition, DocumentTransferTransition, DocumentUpdatePriceTransition};
+use dpp::state_transition::documents_batch_transition::document_transition::document_purchase_transition::DocumentPurchaseTransitionV0;
+use dpp::state_transition::documents_batch_transition::document_transition::document_update_price_transition::DocumentUpdatePriceTransitionV0;
+use pshenmic_dpp_document::DocumentWASM;
+
+pub fn generate_create_transition(
+    document: DocumentWASM,
+    identity_contract_nonce: IdentityNonce,
+    document_type_name: String,
+) -> DocumentCreateTransition {
+    DocumentCreateTransition::V0(DocumentCreateTransitionV0 {
+        base: DocumentBaseTransition::V0(DocumentBaseTransitionV0 {
+            id: document.rs_get_id(),
+            identity_contract_nonce,
+            document_type_name,
+            data_contract_id: document.rs_get_data_contract_id(),
+        }),
+        entropy: document.rs_get_entropy().unwrap(),
+        data: document.rs_get_properties(),
+        prefunded_voting_balance: None,
+    })
+}
+
+pub fn generate_delete_transition(
+    document: DocumentWASM,
+    identity_contract_nonce: IdentityNonce,
+    document_type_name: String,
+) -> DocumentDeleteTransition {
+    DocumentDeleteTransition::V0(DocumentDeleteTransitionV0 {
+        base: DocumentBaseTransition::V0(DocumentBaseTransitionV0 {
+            id: document.rs_get_id(),
+            identity_contract_nonce,
+            document_type_name,
+            data_contract_id: document.rs_get_data_contract_id(),
+        }),
+    })
+}
+
+pub fn generate_replace_transition(
+    document: DocumentWASM,
+    identity_contract_nonce: IdentityNonce,
+    document_type_name: String,
+) -> DocumentReplaceTransition {
+    DocumentReplaceTransition::V0(DocumentReplaceTransitionV0 {
+        base: DocumentBaseTransition::V0(DocumentBaseTransitionV0 {
+            id: document.rs_get_id(),
+            identity_contract_nonce,
+            document_type_name,
+            data_contract_id: document.rs_get_data_contract_id(),
+        }),
+        revision: document.get_revision().unwrap(),
+        data: document.rs_get_properties(),
+    })
+}
+
+pub fn generate_transfer_transition(
+    document: DocumentWASM,
+    identity_contract_nonce: IdentityNonce,
+    document_type_name: String,
+
+    recipient_owner_id: Identifier,
+) -> DocumentTransferTransition {
+    DocumentTransferTransition::V0(DocumentTransferTransitionV0 {
+        base: DocumentBaseTransition::V0(DocumentBaseTransitionV0 {
+            id: document.rs_get_id(),
+            identity_contract_nonce,
+            document_type_name,
+            data_contract_id: document.rs_get_data_contract_id(),
+        }),
+        revision: document.get_revision().unwrap(),
+        recipient_owner_id,
+    })
+}
+
+pub fn generate_update_price_transition(
+    document: DocumentWASM,
+    identity_contract_nonce: IdentityNonce,
+    document_type_name: String,
+
+    price: Credits,
+) -> DocumentUpdatePriceTransition {
+    DocumentUpdatePriceTransition::V0(DocumentUpdatePriceTransitionV0 {
+        base: DocumentBaseTransition::V0(DocumentBaseTransitionV0 {
+            id: document.rs_get_id(),
+            identity_contract_nonce,
+            document_type_name,
+            data_contract_id: document.rs_get_data_contract_id(),
+        }),
+        revision: document.get_revision().unwrap(),
+        price,
+    })
+}
+
+pub fn generate_purchase_transition(
+    document: DocumentWASM,
+    identity_contract_nonce: IdentityNonce,
+    document_type_name: String,
+
+    price: Credits,
+) -> DocumentPurchaseTransition {
+    DocumentPurchaseTransition::V0(DocumentPurchaseTransitionV0 {
+        base: DocumentBaseTransition::V0(DocumentBaseTransitionV0 {
+            id: document.rs_get_id(),
+            identity_contract_nonce,
+            document_type_name,
+            data_contract_id: document.rs_get_data_contract_id(),
+        }),
+        revision: document.get_revision().unwrap(),
+        price: price,
+    })
+}

package/packages/documents_batch/src/lib.rs

@@ -0,0 +1,188 @@
+use crate::document_transition::DocumentTransitionWASM;
+use dpp::fee::Credits;
+use dpp::identity::KeyID;
+use dpp::platform_value::BinaryData;
+use dpp::prelude::{IdentityNonce, UserFeeIncrease};
+use dpp::serialization::{PlatformDeserializable, 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::methods::v0::DocumentsBatchTransitionMethodsV0;
+use dpp::state_transition::documents_batch_transition::{
+    DocumentsBatchTransition, DocumentsBatchTransitionV0,
+};
+use dpp::state_transition::{StateTransition, StateTransitionIdentitySigned, StateTransitionLike};
+use pshenmic_dpp_state_transition::StateTransitionWASM;
+use pshenmic_dpp_utils::{IntoWasm, WithJsError, identifier_from_js_value};
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+pub mod document_base_transition;
+pub mod document_transition;
+pub mod generators;
+pub mod prefunded_voting_balance;
+pub mod transitions;
+
+#[derive(Debug, Clone, PartialEq)]
+#[wasm_bindgen(js_name=DocumentsBatchWASM)]
+pub struct DocumentsBatchWASM(DocumentsBatchTransition);
+
+impl From<DocumentsBatchTransition> for DocumentsBatchWASM {
+    fn from(transition: DocumentsBatchTransition) -> Self {
+        DocumentsBatchWASM(transition)
+    }
+}
+
+impl From<DocumentsBatchWASM> for DocumentsBatchTransition {
+    fn from(wrapper: DocumentsBatchWASM) -> Self {
+        wrapper.0
+    }
+}
+
+#[wasm_bindgen]
+impl DocumentsBatchWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        document_transitions: js_sys::Array,
+        js_owner_id: JsValue,
+        user_fee_increase: Option<UserFeeIncrease>,
+        signature_public_key_id: Option<KeyID>,
+        signature: Option<Vec<u8>>,
+    ) -> Result<DocumentsBatchWASM, JsValue> {
+        let owner_id = identifier_from_js_value(&js_owner_id)?;
+
+        let transitions: Vec<DocumentTransition> = document_transitions
+            .iter()
+            .map(|js_document_transition| {
+                let document_transition: DocumentTransitionWASM = js_document_transition
+                    .to_wasm::<DocumentTransitionWASM>("DocumentTransitionWASM")
+                    .unwrap()
+                    .clone();
+
+                DocumentTransition::from(document_transition.clone().clone())
+            })
+            .collect();
+
+        Ok(DocumentsBatchWASM(DocumentsBatchTransition::V0(
+            DocumentsBatchTransitionV0 {
+                owner_id,
+                transitions,
+                user_fee_increase: user_fee_increase.unwrap_or(0),
+                signature_public_key_id: signature_public_key_id.unwrap_or(0),
+                signature: BinaryData::from(signature.unwrap_or(Vec::new())),
+            },
+        )))
+    }
+
+    #[wasm_bindgen(getter = "transitions")]
+    pub fn get_transitions(&self) -> Vec<DocumentTransitionWASM> {
+        let rs_transitions = self.0.transitions();
+
+        rs_transitions
+            .iter()
+            .map(|transition| DocumentTransitionWASM::from(transition.clone()))
+            .collect()
+    }
+
+    #[wasm_bindgen(getter = "signature")]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.signature().to_vec()
+    }
+
+    #[wasm_bindgen(getter = "signaturePublicKeyId")]
+    pub fn get_signature_public_key_id(&self) -> KeyID {
+        self.0.signature_public_key_id()
+    }
+
+    #[wasm_bindgen(getter = "allPurchasesAmount")]
+    pub fn get_all_purchases_amount(&self) -> Result<Option<Credits>, JsValue> {
+        self.0.all_purchases_amount().with_js_error()
+    }
+
+    #[wasm_bindgen(getter = "ownerId")]
+    pub fn get_owner_id(&self) -> Vec<u8> {
+        self.0.owner_id().to_vec()
+    }
+
+    #[wasm_bindgen(getter = "modifiedDataIds")]
+    pub fn get_modified_data_ids(&self) -> Result<JsValue, JsValue> {
+        let vec_of_ids: Vec<Vec<u8>> = self
+            .0
+            .modified_data_ids()
+            .iter()
+            .map(|id| id.to_vec())
+            .collect();
+
+        serde_wasm_bindgen::to_value(&vec_of_ids).map_err(JsValue::from)
+    }
+
+    #[wasm_bindgen(getter = "allConflictingIndexCollateralVotingFunds")]
+    pub fn get_all_conflicting_index_collateral_voting_funds(
+        &self,
+    ) -> Result<Option<Credits>, JsValue> {
+        self.0
+            .all_conflicting_index_collateral_voting_funds()
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(setter = "transitions")]
+    pub fn set_transitions(&mut self, transitions: Vec<DocumentTransitionWASM>) {
+        let rs_transitions = transitions
+            .iter()
+            .map(|transition| DocumentTransition::from(transition.clone().clone()))
+            .collect();
+
+        self.0.set_transitions(rs_transitions);
+    }
+
+    #[wasm_bindgen(setter = "signature")]
+    pub fn set_signature(&mut self, js_signature: Vec<u8>) {
+        self.0.set_signature(BinaryData::from(js_signature))
+    }
+
+    #[wasm_bindgen(setter = "signaturePublicKeyId")]
+    pub fn set_signature_public_key_id(&mut self, key_id: KeyID) {
+        self.0.set_signature_public_key_id(key_id)
+    }
+
+    #[wasm_bindgen(js_name = "setIdentityContractNonce")]
+    pub fn set_identity_contract_nonce(&mut self, nonce: IdentityNonce) {
+        self.0.set_identity_contract_nonce(nonce)
+    }
+
+    #[wasm_bindgen(js_name = "toStateTransition")]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        let st = StateTransition::from(self.0.clone());
+
+        StateTransitionWASM::from(st)
+    }
+
+    #[wasm_bindgen(js_name = "fromStateTransition")]
+    pub fn from_state_transition(
+        state_transition: &StateTransitionWASM,
+    ) -> Result<DocumentsBatchWASM, JsValue> {
+        let rs_transition: StateTransition = StateTransition::from(state_transition.clone());
+
+        match rs_transition {
+            StateTransition::DocumentsBatch(batch) => Ok(DocumentsBatchWASM(batch)),
+            _ => Err(JsValue::from("invalid state document_transition content")),
+        }
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Result<JsValue, JsValue> {
+        let bytes = self.0.serialize_to_bytes().with_js_error();
+
+        match bytes {
+            Ok(bytes) => Ok(JsValue::from(bytes.clone())),
+            Err(err) => Err(err),
+        }
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<DocumentsBatchWASM, JsValue> {
+        let rs_batch =
+            DocumentsBatchTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error()?;
+
+        Ok(DocumentsBatchWASM::from(rs_batch))
+    }
+}

package/packages/documents_batch/src/prefunded_voting_balance/mod.rs

@@ -0,0 +1,45 @@
+use dpp::fee::Credits;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "PrefundedVotingBalanceWASM")]
+#[derive(Clone)]
+pub struct PrefundedVotingBalanceWASM {
+    index_name: String,
+    credits: Credits,
+}
+
+impl From<(String, Credits)> for PrefundedVotingBalanceWASM {
+    fn from((index_name, credits): (String, Credits)) -> Self {
+        PrefundedVotingBalanceWASM {
+            index_name,
+            credits,
+        }
+    }
+}
+
+impl From<PrefundedVotingBalanceWASM> for (String, Credits) {
+    fn from(value: PrefundedVotingBalanceWASM) -> Self {
+        (value.index_name, value.credits)
+    }
+}
+
+#[wasm_bindgen]
+impl PrefundedVotingBalanceWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(index_name: String, credits: Credits) -> PrefundedVotingBalanceWASM {
+        PrefundedVotingBalanceWASM {
+            index_name,
+            credits,
+        }
+    }
+
+    #[wasm_bindgen(getter, js_name = "indexName")]
+    pub fn index_name(&self) -> String {
+        self.index_name.clone()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn credits(&self) -> Credits {
+        self.credits.clone()
+    }
+}

package/packages/documents_batch/src/transitions/create/mod.rs

@@ -0,0 +1,123 @@
+use crate::document_base_transition::DocumentBaseTransitionWASM;
+use crate::document_transition::DocumentTransitionWASM;
+use crate::generators::generate_create_transition;
+use crate::prefunded_voting_balance::PrefundedVotingBalanceWASM;
+use dpp::dashcore::hashes::serde::Serialize;
+use dpp::prelude::IdentityNonce;
+use dpp::state_transition::documents_batch_transition::DocumentCreateTransition;
+use dpp::state_transition::documents_batch_transition::document_create_transition::v0::v0_methods::DocumentCreateTransitionV0Methods;
+use dpp::state_transition::documents_batch_transition::document_transition::DocumentTransition;
+use pshenmic_dpp_document::DocumentWASM;
+use pshenmic_dpp_utils::ToSerdeJSONExt;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::{JsError, JsValue};
+
+#[wasm_bindgen(js_name = "DocumentCreateTransitionWASM")]
+#[derive(Clone)]
+pub struct DocumentCreateTransitionWASM(DocumentCreateTransition);
+
+impl From<DocumentCreateTransitionWASM> for DocumentCreateTransition {
+    fn from(transition: DocumentCreateTransitionWASM) -> Self {
+        transition.0
+    }
+}
+
+impl From<DocumentCreateTransition> for DocumentCreateTransitionWASM {
+    fn from(transition: DocumentCreateTransition) -> Self {
+        DocumentCreateTransitionWASM(transition)
+    }
+}
+
+#[wasm_bindgen]
+impl DocumentCreateTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        document: &DocumentWASM,
+        identity_contract_nonce: IdentityNonce,
+        document_type_name: String,
+    ) -> Result<DocumentCreateTransitionWASM, JsValue> {
+        let rs_create_transition = generate_create_transition(
+            document.clone(),
+            identity_contract_nonce,
+            document_type_name.to_string(),
+        );
+
+        Ok(DocumentCreateTransitionWASM(rs_create_transition))
+    }
+
+    #[wasm_bindgen(getter = "data")]
+    pub fn get_data(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        self.0.data().serialize(&serializer).map_err(JsValue::from)
+    }
+
+    #[wasm_bindgen(getter = "base")]
+    pub fn get_base(&self) -> DocumentBaseTransitionWASM {
+        self.0.base().clone().into()
+    }
+
+    #[wasm_bindgen(getter = "entropy")]
+    pub fn get_entropy(&self) -> Vec<u8> {
+        self.0.entropy().to_vec()
+    }
+
+    #[wasm_bindgen(setter = "data")]
+    pub fn set_data(&mut self, js_data: JsValue) -> Result<(), JsValue> {
+        let data = js_data.with_serde_to_platform_value_map()?;
+
+        Ok(self.0.set_data(data))
+    }
+
+    #[wasm_bindgen(setter = "base")]
+    pub fn set_base(&mut self, base: &DocumentBaseTransitionWASM) {
+        self.0.set_base(base.clone().into())
+    }
+
+    #[wasm_bindgen(setter = "entropy")]
+    pub fn set_entropy(&mut self, js_entropy: Vec<u8>) -> Result<(), JsValue> {
+        let entropy: [u8; 32] = js_entropy.as_slice().try_into().map_err(JsError::from)?;
+
+        Ok(self.0.set_entropy(entropy))
+    }
+
+    #[wasm_bindgen(getter = "prefundedVotingBalance")]
+    pub fn get_prefunded_voting_balance(&self) -> Option<PrefundedVotingBalanceWASM> {
+        let rs_balance = self.0.prefunded_voting_balance();
+
+        match rs_balance {
+            Some(balance) => Some(balance.clone().into()),
+            None => None,
+        }
+    }
+
+    #[wasm_bindgen(setter = "prefundedVotingBalance")]
+    pub fn set_prefunded_voting_balance(
+        &mut self,
+        prefunded_voting_balance: &PrefundedVotingBalanceWASM,
+    ) {
+        self.0.set_prefunded_voting_balance(
+            prefunded_voting_balance.index_name(),
+            prefunded_voting_balance.credits(),
+        )
+    }
+
+    #[wasm_bindgen(js_name = "clearPrefundedVotingBalance")]
+    pub fn clear_prefunded_voting_balance(&mut self) {
+        self.0.clear_prefunded_voting_balance()
+    }
+
+    #[wasm_bindgen(js_name = "toDocumentTransition")]
+    pub fn to_document_transition(&self) -> DocumentTransitionWASM {
+        let rs_transition = DocumentTransition::from(self.0.clone());
+
+        DocumentTransitionWASM::from(rs_transition)
+    }
+
+    #[wasm_bindgen(js_name = "fromDocumentTransition")]
+    pub fn from_document_transition(
+        js_transition: DocumentTransitionWASM,
+    ) -> Result<DocumentCreateTransitionWASM, JsValue> {
+        js_transition.get_create_transition()
+    }
+}