@dashevo/wasm-dpp 0.23.0-dev.10

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

@@ -0,0 +1,219 @@
+const IdentityPublicKey = require('../../../../../lib/identity/IdentityPublicKey');
+
+const stateTransitionTypes = require(
+  '../../../../../lib/stateTransition/stateTransitionTypes',
+);
+
+const protocolVersion = require('../../../../../lib/version/protocolVersion');
+const Identifier = require('../../../../../lib/identifier/Identifier');
+
+const getIdentityUpdateTransitionFixture = require('../../../../../lib/test/fixtures/getIdentityUpdateTransitionFixture');
+const generateRandomIdentifier = require('../../../../../lib/test/utils/generateRandomIdentifier');
+
+describe('IdentityUpdateTransition', () => {
+  let rawStateTransition;
+  let stateTransition;
+
+  beforeEach(() => {
+    stateTransition = getIdentityUpdateTransitionFixture();
+    rawStateTransition = stateTransition.toObject();
+  });
+
+  describe('#getType', () => {
+    it('should return IDENTITY_UPDATE type', () => {
+      expect(stateTransition.getType()).to.equal(stateTransitionTypes.IDENTITY_UPDATE);
+    });
+  });
+
+  describe('#setIdentityId', () => {
+    it('should set identityId', () => {
+      const id = generateRandomIdentifier();
+
+      stateTransition.setIdentityId(id);
+
+      expect(stateTransition.identityId).to.deep.equal(id);
+    });
+  });
+
+  describe('#getIdentityId', () => {
+    it('should return identityId', () => {
+      expect(stateTransition.getIdentityId()).to.deep.equal(rawStateTransition.identityId);
+    });
+  });
+
+  describe('#getRevision', () => {
+    it('should return revision', () => {
+      expect(stateTransition.getRevision()).to.equal(rawStateTransition.revision);
+    });
+  });
+
+  describe('#setRevision', () => {
+    it('should set revision', () => {
+      stateTransition.setRevision(42);
+
+      expect(stateTransition.revision).to.equal(42);
+    });
+  });
+
+  describe('#getOwnerId', () => {
+    it('should return owner id', () => {
+      expect(stateTransition.getOwnerId()).to.deep.equal(
+        rawStateTransition.identityId,
+      );
+    });
+  });
+
+  describe('#getPublicKeysToAdd', () => {
+    it('should return public keys to add', () => {
+      expect(stateTransition.getPublicKeysToAdd()).to.deep.equal(
+        rawStateTransition.addPublicKeys.map((rawPublicKey) => new IdentityPublicKey(rawPublicKey)),
+      );
+    });
+  });
+
+  describe('#setPublicKeysToAdd', () => {
+    it('should set public keys to add', () => {
+      const publicKeys = [new IdentityPublicKey({
+        id: 0,
+        type: IdentityPublicKey.TYPES.BLS12_381,
+        purpose: 0,
+        securityLevel: 0,
+        readOnly: true,
+        data: Buffer.from('01fac99ca2c8f39c286717c213e190aba4b7af76db320ec43f479b7d9a2012313a0ae59ca576edf801444bc694686694', 'hex'),
+      })];
+
+      stateTransition.setPublicKeysToAdd(publicKeys);
+
+      expect(stateTransition.addPublicKeys).to.have.deep.members(publicKeys);
+    });
+  });
+
+  describe('#getPublicKeyIdsToDisable', () => {
+    it('should return public key ids to disable', () => {
+      expect(stateTransition.getPublicKeyIdsToDisable())
+        .to.deep.equal(stateTransition.disablePublicKeys);
+    });
+  });
+
+  describe('#setPublicKeyIdsToDisable', () => {
+    it('should set public key ids to disable', () => {
+      stateTransition.setPublicKeyIdsToDisable([1, 2]);
+
+      expect(stateTransition.disablePublicKeys).to.deep.equal([1, 2]);
+    });
+  });
+
+  describe('#getPublicKeysDisabledAt', () => {
+    it('should return time to disable public keys', () => {
+      expect(stateTransition.getPublicKeysDisabledAt())
+        .to.deep.equal(new Date(stateTransition.publicKeysDisabledAt));
+    });
+  });
+
+  describe('#setPublicKeysDisabledAt', () => {
+    it('should set time to disable public keys', () => {
+      const now = new Date();
+
+      stateTransition.setPublicKeysDisabledAt(now);
+
+      expect(stateTransition.publicKeysDisabledAt).to.deep.equal(new Date(now));
+    });
+  });
+
+  describe('#toObject', () => {
+    it('should return raw state transition', () => {
+      rawStateTransition = stateTransition.toObject();
+
+      expect(rawStateTransition).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.IDENTITY_UPDATE,
+        signature: undefined,
+        identityId: rawStateTransition.identityId,
+        revision: rawStateTransition.revision,
+        publicKeysDisabledAt: rawStateTransition.publicKeysDisabledAt,
+        addPublicKeys: rawStateTransition.addPublicKeys,
+        disablePublicKeys: rawStateTransition.disablePublicKeys,
+        signaturePublicKeyId: undefined,
+      });
+    });
+
+    it('should return raw state transition without signature', () => {
+      rawStateTransition = stateTransition.toObject({ skipSignature: true });
+
+      expect(rawStateTransition).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.IDENTITY_UPDATE,
+        identityId: rawStateTransition.identityId,
+        revision: rawStateTransition.revision,
+        publicKeysDisabledAt: rawStateTransition.publicKeysDisabledAt,
+        addPublicKeys: rawStateTransition.addPublicKeys,
+        disablePublicKeys: rawStateTransition.disablePublicKeys,
+      });
+    });
+
+    it('should return raw state transition without optional properties', () => {
+      stateTransition.setPublicKeyIdsToDisable(undefined);
+      stateTransition.setPublicKeysDisabledAt(undefined);
+      stateTransition.setPublicKeysToAdd(undefined);
+
+      rawStateTransition = stateTransition.toObject();
+
+      expect(rawStateTransition).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.IDENTITY_UPDATE,
+        signature: undefined,
+        identityId: rawStateTransition.identityId,
+        revision: rawStateTransition.revision,
+        signaturePublicKeyId: undefined,
+      });
+    });
+  });
+
+  describe('#toJSON ', () => {
+    it('should return JSON representation of state transition', () => {
+      const jsonStateTransition = stateTransition.toJSON();
+
+      expect(jsonStateTransition).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.IDENTITY_UPDATE,
+        signature: undefined,
+        identityId: stateTransition.getIdentityId().toString(),
+        revision: rawStateTransition.revision,
+        publicKeysDisabledAt: rawStateTransition.publicKeysDisabledAt,
+        addPublicKeys: stateTransition.getPublicKeysToAdd().map((k) => k.toJSON()),
+        disablePublicKeys: rawStateTransition.disablePublicKeys,
+        signaturePublicKeyId: undefined,
+      });
+    });
+  });
+
+  describe('#getModifiedDataIds', () => {
+    it('should return ids of topped up identity', () => {
+      const result = stateTransition.getModifiedDataIds();
+
+      expect(result.length).to.be.equal(1);
+      const identityId = result[0];
+
+      expect(identityId).to.be.an.instanceOf(Identifier);
+      expect(identityId).to.be.deep.equal(rawStateTransition.identityId);
+    });
+  });
+
+  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();
+    });
+  });
+});

package/test/unit/identity/stateTransition/IdentityUpdateTransition/applyIdentityUpdateTransitionFactory.spec.js

@@ -0,0 +1,149 @@
+const applyIdentityUpdateTransitionFactory = require('../../../../../lib/identity/stateTransition/IdentityUpdateTransition/applyIdentityUpdateTransitionFactory');
+const createStateRepositoryMock = require('../../../../../lib/test/mocks/createStateRepositoryMock');
+const getIdentityUpdateTransitionFixture = require('../../../../../lib/test/fixtures/getIdentityUpdateTransitionFixture');
+const getIdentityFixture = require('../../../../../lib/test/fixtures/getIdentityFixture');
+const StateTransitionExecutionContext = require('../../../../../lib/stateTransition/StateTransitionExecutionContext');
+const getBiggestPossibleIdentity = require('../../../../../lib/identity/getBiggestPossibleIdentity');
+
+describe('applyIdentityUpdateTransition', () => {
+  let applyIdentityUpdateTransition;
+  let stateRepositoryMock;
+  let stateTransition;
+  let identity;
+  let executionContext;
+
+  beforeEach(function beforeEach() {
+    stateTransition = getIdentityUpdateTransitionFixture();
+    stateTransition.setRevision(stateTransition.getRevision() + 1);
+    identity = getIdentityFixture();
+
+    executionContext = new StateTransitionExecutionContext();
+
+    stateTransition.setExecutionContext(executionContext);
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchIdentity.resolves(identity);
+
+    applyIdentityUpdateTransition = applyIdentityUpdateTransitionFactory(
+      stateRepositoryMock,
+    );
+  });
+
+  it('should add public keys', async () => {
+    stateTransition.setPublicKeysDisabledAt(undefined);
+    stateTransition.setPublicKeyIdsToDisable(undefined);
+
+    await applyIdentityUpdateTransition(stateTransition);
+
+    expect(identity.getPublicKeys()).to.have.lengthOf(3);
+
+    expect(identity.getPublicKeyById(3).toObject())
+      .to.deep.equal(stateTransition.getPublicKeysToAdd()[0]);
+
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      stateTransition.getIdentityId(),
+      executionContext,
+    );
+
+    expect(stateRepositoryMock.updateIdentity).to.be.calledOnceWithExactly(
+      identity,
+      executionContext,
+    );
+
+    const publicKeyHashes = stateTransition.getPublicKeysToAdd()
+      .map((publicKey) => publicKey.hash());
+
+    expect(stateRepositoryMock.storeIdentityPublicKeyHashes).to.be.calledOnceWithExactly(
+      identity.getId(),
+      publicKeyHashes,
+      executionContext,
+    );
+
+    expect(identity.getRevision()).to.equal(stateTransition.getRevision());
+  });
+
+  it('should disable public key', async () => {
+    stateTransition.setPublicKeysToAdd(undefined);
+
+    await applyIdentityUpdateTransition(stateTransition);
+
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      stateTransition.getIdentityId(),
+      executionContext,
+    );
+
+    expect(stateRepositoryMock.storeIdentityPublicKeyHashes).to.not.be.called();
+
+    expect(stateRepositoryMock.updateIdentity).to.be.calledOnceWithExactly(
+      identity,
+      executionContext,
+    );
+
+    const [id] = stateTransition.getPublicKeyIdsToDisable();
+
+    expect(identity.getPublicKeyById(id).getDisabledAt())
+      .to.equal(stateTransition.getPublicKeysDisabledAt().getTime());
+
+    expect(identity.getRevision()).to.equal(stateTransition.getRevision());
+  });
+
+  it('should not add public keys on dry run', async () => {
+    const biggestPossibleIdentity = getBiggestPossibleIdentity();
+
+    stateTransition.setPublicKeysDisabledAt(undefined);
+    stateTransition.setPublicKeyIdsToDisable(undefined);
+
+    stateTransition.getExecutionContext().enableDryRun();
+
+    await applyIdentityUpdateTransition(stateTransition);
+
+    stateTransition.getExecutionContext().disableDryRun();
+
+    expect(identity.getPublicKeys()).to.have.lengthOf(2);
+
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      stateTransition.getIdentityId(),
+      executionContext,
+    );
+
+    expect(stateRepositoryMock.updateIdentity).to.be.calledOnceWithExactly(
+      biggestPossibleIdentity,
+      executionContext,
+    );
+
+    const publicKeyHashes = stateTransition.getPublicKeysToAdd()
+      .map((publicKey) => publicKey.hash());
+
+    expect(stateRepositoryMock.storeIdentityPublicKeyHashes).to.be.calledOnceWithExactly(
+      biggestPossibleIdentity.getId(),
+      publicKeyHashes,
+      executionContext,
+    );
+
+    expect(biggestPossibleIdentity.getRevision()).to.equal(stateTransition.getRevision());
+  });
+
+  it('should use biggestPossibleIdentity on dry run', async () => {
+    const biggestPossibleIdentity = getBiggestPossibleIdentity();
+
+    stateTransition.setPublicKeysToAdd(undefined);
+
+    stateTransition.getExecutionContext().enableDryRun();
+
+    await applyIdentityUpdateTransition(stateTransition);
+
+    stateTransition.getExecutionContext().disableDryRun();
+
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      stateTransition.getIdentityId(),
+      executionContext,
+    );
+
+    expect(stateRepositoryMock.storeIdentityPublicKeyHashes).to.not.be.called();
+
+    expect(stateRepositoryMock.updateIdentity).to.be.calledOnceWithExactly(
+      biggestPossibleIdentity,
+      executionContext,
+    );
+  });
+});

package/test/unit/identity/stateTransition/assetLockProof/createAssetLockProofInstance.spec.js

@@ -0,0 +1,21 @@
+const createAssetLockProofInstance = require('../../../../../lib/identity/stateTransition/assetLockProof/createAssetLockProofInstance');
+const getChainAssetLockFixture = require('../../../../../lib/test/fixtures/getChainAssetLockProofFixture');
+const getInstantAssetLockProofFixture = require('../../../../../lib/test/fixtures/getInstantAssetLockProofFixture');
+const ChainAssetLockProof = require('../../../../../lib/identity/stateTransition/assetLockProof/chain/ChainAssetLockProof');
+const InstantAssetLockProof = require('../../../../../lib/identity/stateTransition/assetLockProof/instant/InstantAssetLockProof');
+
+describe('createAssetLockProofInstance', () => {
+  it('should create an instance of InstantAssetLockProof', () => {
+    const assetLockProofFixture = getInstantAssetLockProofFixture();
+    const instance = createAssetLockProofInstance(assetLockProofFixture.toObject());
+
+    expect(instance).to.be.an.instanceOf(InstantAssetLockProof);
+  });
+
+  it('should create an instance of ChainAssetLockProof', () => {
+    const assetLockProofFixture = getChainAssetLockFixture();
+    const instance = createAssetLockProofInstance(assetLockProofFixture.toObject());
+
+    expect(instance).to.be.an.instanceOf(ChainAssetLockProof);
+  });
+});

package/test/unit/identity/stateTransition/assetLockProof/fetchAssetLockPublicKeyHashFactory.spec.js

@@ -0,0 +1,36 @@
+const fetchAssetLockPublicKeyHashFactory = require('../../../../../lib/identity/stateTransition/assetLockProof/fetchAssetLockPublicKeyHashFactory');
+const getInstantAssetLockProofFixture = require('../../../../../lib/test/fixtures/getInstantAssetLockProofFixture');
+const AssetLockOutputNotFoundError = require('../../../../../lib/identity/errors/AssetLockOutputNotFoundError');
+
+describe('fetchAssetLockPublicKeyHashFactory', () => {
+  let fetchAssetLockPublicKeyHash;
+  let fetchAssetLockTransactionOutputMock;
+  let assetLockProof;
+
+  beforeEach(function beforeEach() {
+    fetchAssetLockTransactionOutputMock = this.sinonSandbox.stub();
+
+    fetchAssetLockPublicKeyHash = fetchAssetLockPublicKeyHashFactory(
+      fetchAssetLockTransactionOutputMock,
+    );
+
+    assetLockProof = getInstantAssetLockProofFixture();
+  });
+
+  it('should return public key hash for specified asset lock proof', async () => {
+    fetchAssetLockTransactionOutputMock.resolves(assetLockProof.getOutput());
+
+    const result = await fetchAssetLockPublicKeyHash(assetLockProof);
+
+    expect(result).to.deep.equal(assetLockProof.getOutput().script.getData());
+  });
+
+  it('should throw AssetLockOutputNotFoundError if output is not found', async () => {
+    try {
+      await fetchAssetLockPublicKeyHash(assetLockProof);
+      expect.fail('should throw AssetLockOutputNotFoundError');
+    } catch (e) {
+      expect(e).to.be.an.instanceOf(AssetLockOutputNotFoundError);
+    }
+  });
+});

package/test/unit/identity/validation/validateRequiredPurposeAndSecurityLevelFactory.spec.js

@@ -0,0 +1,47 @@
+const IdentityPublicKey = require('../../../../lib/identity/IdentityPublicKey');
+
+const validateRequiredPurposeAndSecurityLevelFactory = require('../../../../lib/identity/validation/validateRequiredPurposeAndSecurityLevelFactory');
+
+const { expectValidationError } = require('../../../../lib/test/expect/expectError');
+
+const ValidationResult = require('../../../../lib/validation/ValidationResult');
+
+const MissingMasterPublicKeyError = require('../../../../lib/errors/consensus/basic/identity/MissingMasterPublicKeyError');
+
+describe('validateRequiredPurposeAndSecurityLevel', () => {
+  let validateRequiredPurposeAndSecurityLevel;
+
+  beforeEach(() => {
+    validateRequiredPurposeAndSecurityLevel = (
+      validateRequiredPurposeAndSecurityLevelFactory()
+    );
+  });
+
+  it('should return invalid result if the state transition does not contain master key', async () => {
+    const result = await validateRequiredPurposeAndSecurityLevel([{
+      purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+      securityLevel: IdentityPublicKey.SECURITY_LEVELS.CRITICAL,
+    }, {
+      // this key must be filtered out
+      purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+      securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+      disabledAt: 42,
+    }]);
+
+    expectValidationError(result, MissingMasterPublicKeyError);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(1046);
+  });
+
+  it('should return valid result', async () => {
+    const result = await validateRequiredPurposeAndSecurityLevel([{
+      purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+      securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+    }]);
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+  });
+});

package/test/unit/stateTransition/StateTransitionFactory.spec.js

@@ -0,0 +1,160 @@
+const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
+
+const DataContractCreateTransition = require('../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+
+const ValidationResult = require('../../../lib/validation/ValidationResult');
+
+const InvalidStateTransitionError = require('../../../lib/stateTransition/errors/InvalidStateTransitionError');
+
+const SerializedObjectParsingError = require('../../../lib/errors/consensus/basic/decode/SerializedObjectParsingError');
+
+const createDPPMock = require('../../../lib/test/mocks/createDPPMock');
+const StateTransitionFactory = require('../../../lib/stateTransition/StateTransitionFactory');
+const SomeConsensusError = require('../../../lib/test/mocks/SomeConsensusError');
+
+describe('StateTransitionFactory', () => {
+  let validateStateTransitionBasicMock;
+  let createStateTransitionMock;
+  let factory;
+  let stateTransition;
+  let rawStateTransition;
+  let decodeProtocolEntityMock;
+  let dppMock;
+
+  beforeEach(function beforeEach() {
+    const dataContract = getDataContractFixture();
+
+    stateTransition = new DataContractCreateTransition({
+      dataContract: dataContract.toObject(),
+      entropy: dataContract.getEntropy(),
+    });
+    rawStateTransition = stateTransition.toObject();
+
+    decodeProtocolEntityMock = this.sinonSandbox.stub();
+
+    validateStateTransitionBasicMock = this.sinonSandbox.stub();
+    createStateTransitionMock = this.sinonSandbox.stub().returns(stateTransition);
+
+    dppMock = createDPPMock();
+
+    factory = new StateTransitionFactory(
+      validateStateTransitionBasicMock,
+      createStateTransitionMock,
+      dppMock,
+      decodeProtocolEntityMock,
+    );
+  });
+
+  describe('createFromObject', () => {
+    it('should return new State Transition with data from passed object', async () => {
+      validateStateTransitionBasicMock.returns(new ValidationResult());
+
+      const result = await factory.createFromObject(rawStateTransition);
+
+      expect(result).to.equal(stateTransition);
+
+      expect(validateStateTransitionBasicMock).to.have.been.calledOnceWith(rawStateTransition);
+
+      expect(createStateTransitionMock).to.have.been.calledOnceWith(rawStateTransition);
+    });
+
+    it('should return new State Transition without validation if "skipValidation" option is passed', async () => {
+      const result = await factory.createFromObject(rawStateTransition, { skipValidation: true });
+
+      expect(result).to.equal(stateTransition);
+
+      expect(validateStateTransitionBasicMock).to.have.not.been.called();
+
+      expect(createStateTransitionMock).to.have.been.calledOnceWith(rawStateTransition);
+    });
+
+    it('should throw InvalidStateTransitionError if passed object is not valid', async () => {
+      const validationError = new SomeConsensusError('test');
+
+      validateStateTransitionBasicMock.returns(new ValidationResult([validationError]));
+
+      try {
+        await factory.createFromObject(rawStateTransition);
+
+        expect.fail('InvalidStateTransitionError is not thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(InvalidStateTransitionError);
+        expect(e.getRawStateTransition()).to.equal(rawStateTransition);
+
+        expect(e.getErrors()).to.have.length(1);
+
+        const [consensusError] = e.getErrors();
+
+        expect(consensusError).to.equal(validationError);
+
+        expect(validateStateTransitionBasicMock).to.have.been.calledOnceWith(
+          rawStateTransition,
+        );
+      }
+    });
+  });
+
+  describe('createFromBuffer', () => {
+    let serializedStateTransition;
+
+    beforeEach(function beforeEach() {
+      this.sinonSandbox.stub(factory, 'createFromObject');
+
+      serializedStateTransition = stateTransition.toBuffer();
+    });
+
+    afterEach(() => {
+      factory.createFromObject.restore();
+    });
+
+    it('should return new State Transition from serialized contract', async () => {
+      decodeProtocolEntityMock.returns([rawStateTransition.protocolVersion, rawStateTransition]);
+
+      factory.createFromObject.resolves(stateTransition);
+
+      const result = await factory.createFromBuffer(serializedStateTransition);
+
+      expect(result).to.equal(stateTransition);
+
+      expect(factory.createFromObject).to.have.been.calledOnceWith(rawStateTransition);
+
+      expect(decodeProtocolEntityMock).to.have.been.calledOnceWith(
+        serializedStateTransition,
+      );
+    });
+
+    it('should throw InvalidStateTransitionError if the decoding fails with consensus error', async () => {
+      const parsingError = new SerializedObjectParsingError(
+        serializedStateTransition,
+        new Error(),
+      );
+
+      decodeProtocolEntityMock.throws(parsingError);
+
+      try {
+        await factory.createFromBuffer(serializedStateTransition);
+
+        expect.fail('should throw InvalidStateTransitionError');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(InvalidStateTransitionError);
+
+        const [innerError] = e.getErrors();
+        expect(innerError).to.be.equal(parsingError);
+      }
+    });
+
+    it('should throw an error if decoding fails with any other error', async () => {
+      const otherParsingError = new Error();
+
+      decodeProtocolEntityMock.throws(otherParsingError);
+
+      try {
+        await factory.createFromBuffer(serializedStateTransition);
+
+        expect.fail('should throw an error');
+      } catch (e) {
+        expect(e).to.be.equal(otherParsingError);
+      }
+    });
+  });
+});