@dashevo/wasm-dpp 0.25.0-dev.15 → 0.25.0-dev.16

package/src/identity/state_transition/identity_credit_transfer_transition/transition.rs

@@ -0,0 +1,311 @@
+use crate::utils::{ToSerdeJSONExt, WithJsError};
+
+use std::convert::TryInto;
+use std::default::Default;
+
+use wasm_bindgen::prelude::*;
+
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::identifier::IdentifierWrapper;
+use crate::{buffer::Buffer, errors::RustConversionError, with_js_error, IdentityPublicKeyWasm};
+use dpp::identifier::Identifier;
+use dpp::identity::state_transition::identity_credit_transfer_transition::IdentityCreditTransferTransition;
+use dpp::identity::KeyType;
+use dpp::platform_value::string_encoding::Encoding;
+use dpp::platform_value::{string_encoding, BinaryData};
+use dpp::serialization_traits::PlatformSerializable;
+use dpp::state_transition::StateTransitionLike;
+use dpp::state_transition::{StateTransition, StateTransitionIdentitySigned};
+
+#[wasm_bindgen(js_name=IdentityCreditTransferTransition)]
+#[derive(Clone)]
+pub struct IdentityCreditTransferTransitionWasm(IdentityCreditTransferTransition);
+
+impl From<IdentityCreditTransferTransition> for IdentityCreditTransferTransitionWasm {
+    fn from(v: IdentityCreditTransferTransition) -> Self {
+        IdentityCreditTransferTransitionWasm(v)
+    }
+}
+
+impl From<IdentityCreditTransferTransitionWasm> for IdentityCreditTransferTransition {
+    fn from(v: IdentityCreditTransferTransitionWasm) -> Self {
+        v.0
+    }
+}
+
+#[wasm_bindgen(js_class = IdentityCreditTransferTransition)]
+impl IdentityCreditTransferTransitionWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<IdentityCreditTransferTransitionWasm, JsValue> {
+        let raw_state_transition = raw_parameters.with_serde_to_platform_value()?;
+
+        let identity_credit_transfer_transition =
+            IdentityCreditTransferTransition::from_raw_object(raw_state_transition)
+                .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?;
+
+        Ok(identity_credit_transfer_transition.into())
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u8 {
+        IdentityCreditTransferTransition::get_type() as u8
+    }
+
+    #[wasm_bindgen(getter, js_name=identityId)]
+    pub fn identity_id(&self) -> IdentifierWrapper {
+        self.get_identity_id()
+    }
+
+    #[wasm_bindgen(getter, js_name=recipientId)]
+    pub fn recipient_id(&self) -> IdentifierWrapper {
+        self.get_recipient_id()
+    }
+
+    #[wasm_bindgen(getter, js_name=amount)]
+    pub fn amount(&self) -> u64 {
+        self.0.get_amount()
+    }
+
+    #[wasm_bindgen(js_name=getIdentityId)]
+    pub fn get_identity_id(&self) -> IdentifierWrapper {
+        (*self.0.get_identity_id()).into()
+    }
+
+    #[wasm_bindgen(js_name=getRecipientId)]
+    pub fn get_recipient_id(&self) -> IdentifierWrapper {
+        (*self.0.get_recipient_id()).into()
+    }
+
+    #[wasm_bindgen(js_name=getAmount)]
+    pub fn get_amount(&self) -> f64 {
+        self.0.get_amount() as f64
+    }
+
+    #[wasm_bindgen(js_name=setAmount)]
+    pub fn set_amount(&mut self, amount: f64) {
+        self.0.set_amount(amount as u64);
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self, options: JsValue) -> Result<JsValue, JsValue> {
+        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)?;
+
+            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(),
+                )?;
+            }
+        }
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"identityId".to_owned().into(),
+            &Buffer::from_bytes(object.identity_id.to_buffer().as_slice()),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"recipientId".to_owned().into(),
+            &Buffer::from_bytes(object.recipient_id.to_buffer().as_slice()),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"amount".to_owned().into(),
+            &JsValue::from_f64(object.amount as f64),
+        )?;
+
+        Ok(js_object.into())
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
+        let bytes = PlatformSerializable::serialize(&StateTransition::IdentityCreditTransfer(
+            self.0.clone(),
+        ))
+        .with_js_error()?;
+        Ok(Buffer::from_bytes(&bytes))
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        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)?;
+
+            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(),
+                )?;
+            }
+        }
+
+        let identity_id = object.identity_id.to_string(Encoding::Base58);
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"identityId".to_owned().into(),
+            &identity_id.into(),
+        )?;
+
+        let recipient_id = object.recipient_id.to_string(Encoding::Base58);
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"recipientId".to_owned().into(),
+            &recipient_id.into(),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"amount".to_owned().into(),
+            &JsValue::from_f64(object.amount as f64),
+        )?;
+
+        Ok(js_object.into())
+    }
+
+    #[wasm_bindgen(js_name=getModifiedDataIds)]
+    pub fn get_modified_data_ids(&self) -> Vec<JsValue> {
+        let ids = self.0.get_modified_data_ids();
+
+        ids.into_iter()
+            .map(|id| <IdentifierWrapper as std::convert::From<Identifier>>::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=signByPrivateKey)]
+    pub fn sign_by_private_key(
+        &mut self,
+        private_key: Vec<u8>,
+        key_type: u8,
+        bls: Option<JsBlsAdapter>,
+    ) -> Result<(), JsValue> {
+        let key_type = key_type
+            .try_into()
+            .map_err(|e: anyhow::Error| e.to_string())?;
+
+        if bls.is_none() && key_type == KeyType::BLS12_381 {
+            return Err(JsError::new(
+                format!("BLS adapter is required for BLS key type '{}'", key_type).as_str(),
+            )
+            .into());
+        }
+
+        let bls_adapter = if let Some(adapter) = bls {
+            BlsAdapter(adapter)
+        } else {
+            BlsAdapter(JsValue::undefined().into())
+        };
+
+        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<Vec<u8>>) {
+        self.0.signature = BinaryData::new(signature.unwrap_or(vec![]))
+    }
+
+    #[wasm_bindgen]
+    pub fn sign(
+        &mut self,
+        identity_public_key: &IdentityPublicKeyWasm,
+        private_key: Vec<u8>,
+        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()
+    }
+}

package/src/identity/state_transition/mod.rs

@@ -1,11 +1,13 @@
 pub use asset_lock_proof::*;
 pub use identity_create_transition::*;
+pub use identity_credit_transfer_transition::*;
 pub use identity_topup_transition::*;
 pub use identity_update_transition::*;
 pub use validate_public_key_signatures::*;
 
 mod asset_lock_proof;
 mod identity_create_transition;
+mod identity_credit_transfer_transition;
 pub(crate) mod identity_public_key_transitions;
 mod identity_topup_transition;
 mod identity_update_transition;

package/src/identity/state_transition/transition_types.rs

@@ -11,6 +11,7 @@ pub enum StateTransitionTypeWasm {
     DataContractUpdate = 4,
     IdentityUpdate = 5,
     IdentityCreditWithdrawal = 6,
+    IdentityCreditTransfer = 7,
 }
 
 impl From<StateTransitionType> for StateTransitionTypeWasm {
@@ -25,6 +26,9 @@ impl From<StateTransitionType> for StateTransitionTypeWasm {
             StateTransitionType::IdentityCreditWithdrawal => {
                 StateTransitionTypeWasm::IdentityCreditWithdrawal
             }
+            StateTransitionType::IdentityCreditTransfer => {
+                StateTransitionTypeWasm::IdentityCreditTransfer
+            }
         }
     }
 }

package/src/state_transition/conversion.rs

@@ -2,7 +2,8 @@ use crate::errors::consensus::consensus_error::from_consensus_error;
 use crate::utils::generic_of_js_val;
 use crate::{
     DataContractCreateTransitionWasm, DataContractUpdateTransitionWasm,
-    DocumentsBatchTransitionWasm, IdentityCreateTransitionWasm, IdentityTopUpTransitionWasm,
+    DocumentsBatchTransitionWasm, IdentityCreateTransitionWasm,
+    IdentityCreditTransferTransitionWasm, IdentityTopUpTransitionWasm,
     IdentityUpdateTransitionWasm, PreCalculatedOperationWasm, ReadOperationWasm,
     SignatureVerificationOperationWasm,
 };
@@ -127,6 +128,15 @@ pub fn create_state_transition_from_wasm_instance(
 
             Ok(StateTransition::IdentityUpdate(st.clone().into()))
         }
+        StateTransitionType::IdentityCreditTransfer => {
+            let st: Ref<IdentityCreditTransferTransitionWasm> =
+                generic_of_js_val::<IdentityCreditTransferTransitionWasm>(
+                    js_value,
+                    "IdentityCreditTransferTransition",
+                )?;
+
+            Ok(StateTransition::IdentityCreditTransfer(st.clone().into()))
+        }
         _ => Err(JsError::new("Unsupported state transition type").into()),
     }
 }

package/src/state_transition/state_transition_facade.rs

@@ -69,7 +69,7 @@ impl StateTransitionFacadeWasm {
             .map_err(PlatformValueErrorWasm::from)?
             .try_into()
             .map_err(|e: TryFromPrimitiveError<StateTransitionType>| {
-                InvalidStateTransitionTypeErrorWasm::new(e.number as u8)
+                InvalidStateTransitionTypeErrorWasm::new(e.number)
             })?;
 
         if state_transition_type == StateTransitionType::DataContractUpdate {

package/src/state_transition/state_transition_factory.rs

@@ -8,6 +8,7 @@ use dpp::{state_transition::{
     StateTransitionFactory, StateTransitionFactoryOptions, StateTransition, errors::StateTransitionError,
 }, version::ProtocolVersionValidator, data_contract::state_transition::{data_contract_create_transition::validation::state::validate_data_contract_create_transition_basic::DataContractCreateTransitionBasicValidator, data_contract_update_transition::validation::basic::DataContractUpdateTransitionBasicValidator}, identity::{state_transition::{identity_create_transition::validation::basic::IdentityCreateTransitionBasicValidator, validate_public_key_signatures::{PublicKeysSignaturesValidator}, asset_lock_proof::{AssetLockProofValidator, ChainAssetLockProofStructureValidator, InstantAssetLockProofStructureValidator, AssetLockTransactionValidator}, identity_topup_transition::validation::basic::IdentityTopUpTransitionBasicValidator, identity_credit_withdrawal_transition::validation::basic::validate_identity_credit_withdrawal_transition_basic::IdentityCreditWithdrawalTransitionBasicValidator, identity_update_transition::validate_identity_update_transition_basic::ValidateIdentityUpdateTransitionBasic}, validation::PublicKeysValidator}, document::validation::basic::validate_documents_batch_transition_basic::DocumentBatchTransitionBasicValidator, ProtocolError};
 use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
+use dpp::identity::state_transition::identity_credit_transfer_transition::validation::basic::identity_credit_transfer_basic::IdentityCreditTransferTransitionBasicValidator;
 use dpp::platform_value::Value;
 
 use crate::utils::{ToSerdeJSONExt, WithJsError};
@@ -18,7 +19,8 @@ use crate::{
     state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
     state_transition::errors::invalid_state_transition_error::InvalidStateTransitionErrorWasm,
     with_js_error, DataContractCreateTransitionWasm, DataContractUpdateTransitionWasm,
-    DocumentsBatchTransitionWasm, IdentityCreateTransitionWasm, IdentityTopUpTransitionWasm,
+    DocumentsBatchTransitionWasm, IdentityCreateTransitionWasm,
+    IdentityCreditTransferTransitionWasm, IdentityTopUpTransitionWasm,
     IdentityUpdateTransitionWasm,
 };
 
@@ -58,6 +60,9 @@ impl StateTransitionFactoryWasm {
                 StateTransition::IdentityTopUp(st) => {
                     Ok(IdentityTopUpTransitionWasm::from(st).into())
                 }
+                StateTransition::IdentityCreditTransfer(st) => {
+                    Ok(IdentityCreditTransferTransitionWasm::from(st).into())
+                }
                 StateTransition::DocumentsBatch(st) => {
                     Ok(DocumentsBatchTransitionWasm::from(st).into())
                 }
@@ -150,6 +155,10 @@ impl StateTransitionFactoryWasm {
                     state_repository_wrapper.clone(),
                     protocol_version_validator.clone(),
                 ),
+                IdentityCreditTransferTransitionBasicValidator::new(
+                    ProtocolVersionValidator::default(),
+                )
+                .map_err(from_dpp_init_error)?,
             ),
         );
 

package/src/state_transition/validation/validate_state_transition_identity_signature.rs

@@ -100,5 +100,10 @@ pub async fn validate_state_transition_identity_signature_wasm(
                 .validate(&mut state_transition, &execution_context)
                 .await
         }
+        StateTransition::IdentityCreditTransfer(mut state_transition) => {
+            validator
+                .validate(&mut state_transition, &execution_context)
+                .await
+        }
     }
 }

package/test/unit/dataContract/DataContract.spec.js

@@ -335,4 +335,22 @@ describe('DataContract', () => {
       expect(dataContract.getMetadata().toObject()).to.deep.equal(otherMetadataToObject);
     });
   });
+
+  describe('#setConfig', () => {
+    it('should set config', () => {
+      const config = {
+        canBeDeleted: true,
+        readonly: true,
+        keepsHistory: true,
+        documentsKeepHistoryContractDefault: true,
+        documentsMutableContractDefault: true,
+      };
+
+      dataContract.setConfig(config);
+
+      const restoredConfig = dataContract.getConfig();
+
+      expect(config).to.deep.equal(restoredConfig);
+    });
+  });
 });

package/test/unit/dataContract/DataContractFactory.spec.js

@@ -46,6 +46,26 @@ describe('DataContractFactory', () => {
 
       expect(result).excluding('$id').to.deep.equal(rawDataContract);
     });
+
+    it('should pass config', () => {
+      const config = {
+        canBeDeleted: false,
+        readonly: false,
+        keepsHistory: true,
+        documentsKeepHistoryContractDefault: false,
+        documentsMutableContractDefault: true,
+      };
+      const contract = factory.create(
+        dataContract.getOwnerId(),
+        rawDataContract.documents,
+        config,
+      );
+
+      const result = contract.toObject();
+
+      expect(contract.getConfig()).to.be.deep.equal(config);
+      expect(result).excluding('$id').to.deep.equal(rawDataContract);
+    });
   });
 
   describe('createFromObject', () => {

package/test/unit/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition.spec.js

@@ -68,6 +68,16 @@ describe('DataContractCreateTransition', () => {
       expect(result).to.be.instanceOf(Buffer);
       expect(result).to.have.lengthOf(2271);
     });
+
+    it('should be able to restore contract config from bytes', () => {
+      const config = stateTransition.getDataContract().getConfig();
+      config.keepsHistory = true;
+      stateTransition.setDataContractConfig(config);
+      expect(stateTransition.getDataContract().getConfig().keepsHistory).to.be.true();
+      const buffer = stateTransition.toBuffer();
+      const restoredSt = DataContractCreateTransition.fromBuffer(buffer);
+      expect(restoredSt.getDataContract().getConfig().keepsHistory).to.be.true();
+    });
   });
 
   describe('#getOwnerId', () => {

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition.spec.js

@@ -68,6 +68,16 @@ describe('DataContractUpdateTransition', () => {
       expect(result).to.be.instanceOf(Buffer);
       expect(result).to.have.lengthOf(2239);
     });
+
+    it('should be able to restore contract config from bytes', () => {
+      const config = stateTransition.getDataContract().getConfig();
+      config.keepsHistory = true;
+      stateTransition.setDataContractConfig(config);
+      expect(stateTransition.getDataContract().getConfig().keepsHistory).to.be.true();
+      const buffer = stateTransition.toBuffer();
+      const restoredSt = DataContractUpdateTransition.fromBuffer(buffer);
+      expect(restoredSt.getDataContract().getConfig().keepsHistory).to.be.true();
+    });
   });
 
   describe.skip('#hash', () => {

package/test/unit/identity/stateTransition/identityCreditTransferTransition/identityCreditTransferTransition.spec.js

@@ -0,0 +1,139 @@
+const getIdentityCreditTransferTransitionFixture = require('../../../../../lib/test/fixtures/getIdentityCreditTransferTransitionFixture');
+
+const { default: loadWasmDpp } = require('../../../../..');
+const { getLatestProtocolVersion, StateTransitionTypes } = require('../../../../..');
+
+describe('IdentityCreditTransferTransition', () => {
+  let rawStateTransition;
+  let stateTransition;
+
+  let IdentityCreditTransferTransition;
+  let Identifier;
+
+  before(async () => {
+    ({
+      IdentityCreditTransferTransition, Identifier,
+    } = await loadWasmDpp());
+  });
+
+  beforeEach(async () => {
+    rawStateTransition = (await getIdentityCreditTransferTransitionFixture()).toObject();
+
+    stateTransition = new IdentityCreditTransferTransition(
+      rawStateTransition,
+    );
+  });
+
+  describe('#constructor', () => {
+    it('should create an instance with specified data from specified raw transition', () => {
+      expect(stateTransition.getIdentityId().toBuffer()).to.be.deep.equal(
+        rawStateTransition.identityId,
+      );
+      expect(stateTransition.getRecipientId().toBuffer()).to.be.deep.equal(
+        rawStateTransition.recipientId,
+      );
+      expect(stateTransition.getAmount()).to.be.equal(
+        rawStateTransition.amount,
+      );
+    });
+  });
+
+  describe('#getType', () => {
+    it('should return IDENTITY_CREDIT_TRANSFER type', () => {
+      expect(stateTransition.getType()).to.equal(StateTransitionTypes.IdentityCreditTransfer);
+    });
+  });
+
+  describe('#getIdentityId', () => {
+    it('should return identity id', () => {
+      expect(stateTransition.getIdentityId().toBuffer()).to.deep.equal(
+        rawStateTransition.identityId,
+      );
+    });
+  });
+
+  describe('#getRecipientId', () => {
+    it('should return recipient id', () => {
+      expect(stateTransition.getRecipientId().toBuffer()).to.deep.equal(
+        rawStateTransition.recipientId,
+      );
+    });
+  });
+
+  describe('#toObject', () => {
+    it('should return raw state transition', () => {
+      rawStateTransition = stateTransition.toObject();
+
+      expect(rawStateTransition).to.deep.equal({
+        protocolVersion: getLatestProtocolVersion(),
+        type: StateTransitionTypes.IdentityCreditTransfer,
+        identityId: rawStateTransition.identityId,
+        recipientId: rawStateTransition.recipientId,
+        amount: rawStateTransition.amount,
+        signature: Buffer.alloc(32).fill(0),
+        signaturePublicKeyId: 0,
+      });
+    });
+
+    it('should return raw state transition', () => {
+      rawStateTransition = stateTransition.toObject({ skipSignature: true });
+
+      expect(rawStateTransition).to.deep.equal({
+        protocolVersion: getLatestProtocolVersion(),
+        type: StateTransitionTypes.IdentityCreditTransfer,
+        identityId: rawStateTransition.identityId,
+        recipientId: rawStateTransition.recipientId,
+        amount: rawStateTransition.amount,
+      });
+    });
+  });
+
+  describe('#toJSON', () => {
+    it('should return JSON representation of state transition', () => {
+      const jsonStateTransition = stateTransition.toJSON();
+
+      expect(jsonStateTransition).to.deep.equal({
+        protocolVersion: getLatestProtocolVersion(),
+        type: StateTransitionTypes.IdentityCreditTransfer,
+        identityId: new Identifier(rawStateTransition.identityId).toString(),
+        recipientId: new Identifier(rawStateTransition.recipientId).toString(),
+        amount: rawStateTransition.amount,
+        signature: Buffer.alloc(32).fill(0).toString('base64'),
+        signaturePublicKeyId: 0,
+      });
+    });
+  });
+
+  describe('#getModifiedDataIds', () => {
+    it('should return ids of topped up identity', () => {
+      const result = stateTransition.getModifiedDataIds();
+
+      expect(result.length).to.be.equal(2);
+      const [identityId, recipientId] = result;
+
+      expect(identityId).to.be.an.instanceOf(Identifier);
+      expect(identityId.toBuffer()).to.be.deep.equal(rawStateTransition.identityId);
+
+      expect(recipientId).to.be.an.instanceOf(Identifier);
+      expect(recipientId.toBuffer()).to.be.deep.equal(rawStateTransition.recipientId);
+    });
+  });
+
+  describe('#isDataContractStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransition.isDataContractStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isDocumentStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransition.isDocumentStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isIdentityStateTransition', () => {
+    it('should return true', () => {
+      expect(stateTransition.isIdentityStateTransition()).to.be.true();
+    });
+  });
+});