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

package/src/utils.rs

@@ -9,6 +9,7 @@ use dpp::{
 };
 
 use dpp::platform_value::Value;
+use dpp::serialization_traits::PlatformDeserializable;
 use js_sys::{Function, Uint8Array};
 use serde::de::DeserializeOwned;
 use serde_json::Value as JsonValue;
@@ -193,7 +194,7 @@ pub fn generic_of_js_val<T: RefFromWasmAbi<Abi = u32>>(
         .name();
 
     if ctor_name == class_name {
-        let ptr = js_sys::Reflect::get(js_value, &JsValue::from_str("ptr"))?;
+        let ptr = js_sys::Reflect::get(js_value, &JsValue::from_str("__wbg_ptr"))?;
         let ptr_u32: u32 = ptr
             .as_f64()
             .ok_or_else(|| JsValue::from(JsError::new("Invalid JS object pointer")))?

package/src/validation/validation_result.rs

@@ -3,6 +3,7 @@ use crate::{
     errors::consensus::consensus_error::from_consensus_error_ref,
     utils::{consensus_errors_from_buffers, WithJsError},
 };
+use dpp::serialization_traits::PlatformDeserializable;
 use dpp::{consensus::ConsensusError, validation::ConsensusValidationResult};
 use js_sys::{JsString, Uint8Array};
 use wasm_bindgen::prelude::*;

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();
+    });
+  });
+});