@dashevo/wasm-dpp 0.25.0-dev.8 → 0.25.0-pr.1545.2

package/test/unit/errors/consensus/codes.spec.js

@@ -1,102 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-const codes = require('@dashevo/dpp/lib/errors/consensus/codes');
-const AbstractConsensusError = require('@dashevo/dpp/lib/errors/consensus/AbstractConsensusError');
-const AbstractBasicError = require('@dashevo/dpp/lib/errors/consensus/basic/AbstractBasicError');
-const AbstractSignatureError = require('@dashevo/dpp/lib/errors/consensus/signature/AbstractSignatureError');
-const AbstractFeeError = require('@dashevo/dpp/lib/errors/consensus/fee/AbstractFeeError');
-const AbstractStateError = require('@dashevo/dpp/lib/errors/consensus/state/AbstractStateError');
-
-const getAllFiles = (dirPath, arrayOfFiles) => {
-  const files = fs.readdirSync(dirPath);
-
-  // eslint-disable-next-line no-param-reassign
-  arrayOfFiles = arrayOfFiles || [];
-
-  files.forEach((file) => {
-    if (fs.statSync(`${dirPath}/${file}`).isDirectory()) {
-      // eslint-disable-next-line no-param-reassign
-      arrayOfFiles = getAllFiles(`${dirPath}/${file}`, arrayOfFiles);
-    } else if (file.slice(-3) === '.js') {
-      arrayOfFiles.push(path.join(dirPath, '/', file));
-    }
-  });
-
-  return arrayOfFiles;
-};
-
-function isChildOf(classToCheck, parentClass) {
-  if (!classToCheck || !classToCheck.prototype) {
-    return false;
-  }
-
-  if (classToCheck.prototype instanceof parentClass) {
-    return true;
-  }
-
-  return isChildOf(classToCheck.prototype, parentClass);
-}
-
-const errorClasses = Object.values(codes).map((ErrorClass) => ErrorClass);
-const errorClassDuplicates = errorClasses.filter((item, index) => (
-  errorClasses.indexOf(item) !== index
-));
-
-describe('Consensus error codes', () => {
-  // Skip the tests for browsers
-  if (global.window !== undefined) {
-    return;
-  }
-
-  const normalizedPath = path.join(__dirname, '../../../../../js-dpp/lib/errors/');
-  const allFiles = getAllFiles(normalizedPath);
-
-  allFiles.forEach((fileName) => {
-    // eslint-disable-next-line global-require,import/no-dynamic-require
-    const ErrorClass = require(fileName);
-
-    if (
-      (isChildOf(ErrorClass, AbstractConsensusError)) && !ErrorClass.name.startsWith('Abstract')
-    ) {
-      context(ErrorClass.name, () => {
-        let code;
-        let AssignedErrorClass;
-
-        beforeEach(() => {
-          const result = Object.entries(codes)
-            .find(([, ErrorClassWithCode]) => ErrorClassWithCode === ErrorClass);
-
-          if (result) {
-            code = Number(result[0]);
-            // eslint-disable-next-line prefer-destructuring
-            AssignedErrorClass = result[1];
-          }
-        });
-
-        it('should have error code defined', () => {
-          expect(AssignedErrorClass).to.exist();
-        });
-
-        it('should have been define in the correct code range', () => {
-          if (isChildOf(ErrorClass, AbstractBasicError)) {
-            expect(code).to.be.above(999);
-            expect(code).to.be.below(2000);
-          } else if (isChildOf(ErrorClass, AbstractSignatureError)) {
-            expect(code).to.be.above(1999);
-            expect(code).to.be.below(3000);
-          } else if (isChildOf(ErrorClass, AbstractFeeError)) {
-            expect(code).to.be.above(2999);
-            expect(code).to.be.below(4000);
-          } else if (isChildOf(ErrorClass, AbstractStateError)) {
-            expect(code).to.be.above(3999);
-            expect(code).to.be.below(5000);
-          }
-        });
-
-        it('should not have duplicates', () => {
-          expect(errorClassDuplicates).to.not.include(ErrorClass);
-        });
-      });
-    }
-  });
-});

package/test/unit/identity/creditsConverter.spec.js

@@ -1,34 +0,0 @@
-const {
-  convertSatoshiToCredits,
-  convertCreditsToSatoshi,
-  RATIO,
-} = require('@dashevo/dpp/lib/identity/creditsConverter');
-
-describe('creditsConverter', () => {
-  describe('convertSatoshiToCredits', () => {
-    it('should convert satoshi to credits', () => {
-      const amount = 42;
-
-      const convertedAmount = convertSatoshiToCredits(amount);
-
-      expect(convertedAmount).to.equal(amount * RATIO);
-    });
-  });
-  describe('convertCreditsToSatoshi', () => {
-    it('should convert credits to satoshi', () => {
-      const amount = 10000;
-
-      const convertedAmount = convertCreditsToSatoshi(amount);
-
-      expect(convertedAmount).to.equal(Math.floor(amount / RATIO));
-    });
-
-    it('should convert credits to 0 satoshi if amount < RATIO', () => {
-      const amount = RATIO - 1;
-
-      const convertedAmount = convertCreditsToSatoshi(amount);
-
-      expect(convertedAmount).to.equal(0);
-    });
-  });
-});

package/test/unit/identity/errors/InvalidIdentityError.spec.js

@@ -1,46 +0,0 @@
-const InvalidIdentityError = require('@dashevo/dpp/lib/identity/errors/InvalidIdentityError');
-const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
-
-describe('InvalidIdentityError', () => {
-  let rawIdentity;
-  let error;
-
-  beforeEach(() => {
-    error = new Error('Some error');
-
-    const identity = getIdentityFixture();
-    rawIdentity = identity.toObject();
-  });
-
-  it('should return errors', () => {
-    const errors = [error];
-
-    const invalidIdentityError = new InvalidIdentityError(errors, rawIdentity);
-
-    expect(invalidIdentityError.getErrors()).to.deep.equal(errors);
-  });
-
-  it('should return Identity', async () => {
-    const errors = [error];
-
-    const invalidIdentityError = new InvalidIdentityError(errors, rawIdentity);
-
-    expect(invalidIdentityError.getRawIdentity()).to.deep.equal(rawIdentity);
-  });
-
-  it('should contain message for 1 error', async () => {
-    const errors = [error];
-
-    const invalidIdentityError = new InvalidIdentityError(errors, rawIdentity);
-
-    expect(invalidIdentityError.message).to.equal(`Invalid Identity: "${error.message}"`);
-  });
-
-  it('should contain message for multiple errors', async () => {
-    const errors = [error, error];
-
-    const invalidIdentityError = new InvalidIdentityError(errors, rawIdentity);
-
-    expect(invalidIdentityError.message).to.equal(`Invalid Identity: "${error.message}" and 1 more`);
-  });
-});

package/test/unit/identity/stateTransition/IdentityCreateTransition/applyIdentityCreateTransitionFactory.spec.js

@@ -1,89 +0,0 @@
-const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
-
-const { convertSatoshiToCredits } = require('@dashevo/dpp/lib/identity/creditsConverter');
-
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-
-const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-
-const { default: loadWasmDpp } = require('../../../../../dist');
-
-describe('applyIdentityCreateTransitionFactory', () => {
-  let stateTransition;
-  let applyIdentityCreateTransition;
-  let stateRepositoryMock;
-  let output;
-  let executionContext;
-
-  let StateTransitionExecutionContext;
-  let IdentityCreateTransition;
-  let Identity;
-
-  let applyIdentityCreateTransitionDPP;
-
-  before(async () => {
-    ({
-      StateTransitionExecutionContext,
-      IdentityCreateTransition,
-      applyIdentityCreateTransition: applyIdentityCreateTransitionDPP,
-      Identity,
-    } = await loadWasmDpp());
-  });
-
-  beforeEach(function beforeEach() {
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-    stateRepositoryMock.createIdentity.resolves();
-    stateRepositoryMock.addToSystemCredits.resolves();
-    stateRepositoryMock.markAssetLockTransactionOutPointAsUsed.resolves();
-
-    stateTransition = new IdentityCreateTransition(
-      getIdentityCreateTransitionFixture().toObject(),
-    );
-
-    executionContext = new StateTransitionExecutionContext();
-
-    output = stateTransition.getAssetLockProof().getOutput();
-
-    applyIdentityCreateTransition = (st) => applyIdentityCreateTransitionDPP(
-      stateRepositoryMock,
-      st,
-      executionContext,
-    );
-  });
-
-  it('should store identity created from state transition', async function () {
-    await applyIdentityCreateTransition(stateTransition);
-
-    const balance = convertSatoshiToCredits(
-      output.satoshis,
-    );
-
-    const identity = new Identity({
-      protocolVersion: protocolVersion.latestVersion,
-      id: stateTransition.getIdentityId(),
-      publicKeys: stateTransition.getPublicKeys()
-        .map((key) => key.toObject({ skipSignature: true })),
-      balance,
-      revision: 0,
-    });
-
-    const { match } = this.sinonSandbox;
-
-    expect(stateRepositoryMock.createIdentity).to.have.been.calledOnceWithExactly(
-      match((arg) => expect(arg.toObject()).to.deep.equal(identity.toObject())),
-      match.instanceOf(StateTransitionExecutionContext),
-    );
-
-    expect(stateRepositoryMock.addToSystemCredits).to.have.been.calledOnceWithExactly(
-      balance,
-      match.instanceOf(StateTransitionExecutionContext),
-    );
-
-    const outPoint = stateTransition.getAssetLockProof().getOutPoint();
-    expect(stateRepositoryMock.markAssetLockTransactionOutPointAsUsed).to.have.been
-      .calledOnceWithExactly(
-        match((arg) => Buffer.from(arg).equals(outPoint)),
-        match.instanceOf(StateTransitionExecutionContext),
-      );
-  });
-});

package/test/unit/identity/stateTransition/IdentityTopUpTransition/applyIdentityTopUpTransitionFactory.spec.js

@@ -1,142 +0,0 @@
-const getIdentityTopUpTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityTopUpTransitionFixture');
-
-const { convertSatoshiToCredits } = require('@dashevo/dpp/lib/identity/creditsConverter');
-
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-
-const { default: loadWasmDpp } = require('../../../../../dist');
-
-describe('applyIdentityTopUpTransitionFactory', () => {
-  let stateTransition;
-  let applyIdentityTopUpTransition;
-  let stateRepositoryMock;
-  let executionContext;
-
-  let StateTransitionExecutionContext;
-  let IdentityTopUpTransition;
-
-  let applyIdentityTopUpTransitionDPP;
-
-  before(async () => {
-    ({
-      StateTransitionExecutionContext,
-      IdentityTopUpTransition,
-      applyIdentityTopUpTransition: applyIdentityTopUpTransitionDPP,
-    } = await loadWasmDpp());
-  });
-
-  beforeEach(async function beforeEach() {
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-    stateRepositoryMock.fetchIdentityBalanceWithDebt.resolves(0);
-    stateRepositoryMock.addToIdentityBalance.resolves();
-    stateRepositoryMock.addToSystemCredits.resolves();
-    stateRepositoryMock.markAssetLockTransactionOutPointAsUsed.resolves();
-
-    const rawTransaction = '030000000137feb5676d0851337ea3c9a992496aab7a0b3eee60aeeb9774000b7f4bababa5000000006b483045022100d91557de37645c641b948c6cd03b4ae3791a63a650db3e2fee1dcf5185d1b10402200e8bd410bf516ca61715867666d31e44495428ce5c1090bf2294a829ebcfa4ef0121025c3cc7fbfc52f710c941497fd01876c189171ea227458f501afcb38a297d65b4ffffffff021027000000000000166a14152073ca2300a86b510fa2f123d3ea7da3af68dcf77cb0090a0000001976a914152073ca2300a86b510fa2f123d3ea7da3af68dc88ac00000000';
-
-    stateRepositoryMock.fetchTransaction.resolves({
-      data: Buffer.from(rawTransaction, 'hex'),
-      height: 42,
-    });
-
-    stateTransition = new IdentityTopUpTransition(
-      getIdentityTopUpTransitionFixture().toObject(),
-    );
-
-    executionContext = new StateTransitionExecutionContext();
-
-    applyIdentityTopUpTransition = (st) => applyIdentityTopUpTransitionDPP(
-      stateRepositoryMock,
-      st,
-      executionContext,
-    );
-  });
-
-  it('should add topup amount to identity balance', async function () {
-    const balanceToTopUp = convertSatoshiToCredits(
-      stateTransition.getAssetLockProof().getOutput().satoshis,
-    );
-
-    await applyIdentityTopUpTransition(stateTransition);
-
-    const { match } = this.sinonSandbox;
-
-    expect(stateRepositoryMock.addToIdentityBalance).to.have.been.calledOnceWithExactly(
-      match((arg) => arg.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
-      balanceToTopUp,
-      match.instanceOf(StateTransitionExecutionContext),
-    );
-
-    expect(stateRepositoryMock.addToSystemCredits).to.have.been.calledOnceWithExactly(
-      balanceToTopUp,
-      match.instanceOf(StateTransitionExecutionContext),
-    );
-
-    const outPoint = stateTransition.getAssetLockProof().getOutPoint();
-
-    expect(stateRepositoryMock.markAssetLockTransactionOutPointAsUsed).to.have.been
-      .calledOnceWithExactly(
-        match((arg) => Buffer.from(arg).equals(outPoint)),
-        match.instanceOf(StateTransitionExecutionContext),
-      );
-  });
-
-  it('should ignore balance debt for system credits', async function () {
-    stateRepositoryMock.fetchIdentityBalanceWithDebt.resolves(-5);
-
-    const balanceToTopUp = convertSatoshiToCredits(
-      stateTransition.getAssetLockProof().getOutput().satoshis,
-    );
-
-    await applyIdentityTopUpTransition(stateTransition);
-
-    const { match } = this.sinonSandbox;
-
-    expect(stateRepositoryMock.addToIdentityBalance).to.have.been.calledOnceWithExactly(
-      match((arg) => arg.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
-      balanceToTopUp,
-      match.instanceOf(StateTransitionExecutionContext),
-    );
-
-    expect(stateRepositoryMock.addToSystemCredits).to.have.been.calledOnceWithExactly(
-      balanceToTopUp - 5,
-      match.instanceOf(StateTransitionExecutionContext),
-    );
-
-    const outPoint = stateTransition.getAssetLockProof().getOutPoint();
-
-    expect(stateRepositoryMock.markAssetLockTransactionOutPointAsUsed).to.have.been
-      .calledOnceWithExactly(
-        match((arg) => Buffer.from(arg).equals(outPoint)),
-        match.instanceOf(StateTransitionExecutionContext),
-      );
-  });
-
-  it('should add topup amount to identity balance on dry run', async function () {
-    const { match } = this.sinonSandbox;
-
-    const balanceToTopUp = convertSatoshiToCredits(
-      stateTransition.getAssetLockProof().getOutput().satoshis,
-    );
-
-    executionContext.enableDryRun();
-
-    await applyIdentityTopUpTransition(stateTransition);
-
-    executionContext.disableDryRun();
-
-    expect(stateRepositoryMock.addToIdentityBalance).to.have.been.calledOnceWithExactly(
-      match((arg) => arg.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
-      balanceToTopUp,
-      match.instanceOf(StateTransitionExecutionContext),
-    );
-
-    const outPoint = stateTransition.getAssetLockProof().getOutPoint();
-
-    expect(stateRepositoryMock.markAssetLockTransactionOutPointAsUsed).to.have.been
-      .calledOnceWithExactly(
-        match((arg) => Buffer.from(arg).equals(outPoint)),
-        match.instanceOf(StateTransitionExecutionContext),
-      );
-  });
-});

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

@@ -1,100 +0,0 @@
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-const getIdentityUpdateTransitionFixture = require('../../../../../lib/test/fixtures/getIdentityUpdateTransitionFixture');
-
-const { default: loadWasmDpp } = require('../../../../../dist');
-
-describe('applyIdentityUpdateTransition', () => {
-  let applyIdentityUpdateTransition;
-  let stateRepositoryMock;
-  let stateTransition;
-  let executionContext;
-
-  let StateTransitionExecutionContext;
-
-  let applyIdentityUpdateTransitionDPP;
-
-  before(async () => {
-    ({
-      StateTransitionExecutionContext,
-      applyIdentityUpdateTransition: applyIdentityUpdateTransitionDPP,
-    } = await loadWasmDpp());
-  });
-
-  beforeEach(async function beforeEach() {
-    stateTransition = await getIdentityUpdateTransitionFixture();
-    stateTransition.setRevision(stateTransition.getRevision() + 1);
-
-    executionContext = new StateTransitionExecutionContext();
-
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-    stateRepositoryMock.updateIdentityRevision.resolves();
-    stateRepositoryMock.disableIdentityKeys.resolves();
-    stateRepositoryMock.addKeysToIdentity.resolves();
-
-    applyIdentityUpdateTransition = (st) => applyIdentityUpdateTransitionDPP(
-      stateRepositoryMock,
-      st,
-      executionContext,
-    );
-  });
-
-  it('should add and disable public keys', async function () {
-    await applyIdentityUpdateTransition(stateTransition);
-
-    const { match } = this.sinonSandbox;
-
-    expect(stateRepositoryMock.updateIdentityRevision).to.be.calledOnceWithExactly(
-      match((id) => id.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
-      stateTransition.getRevision(),
-      match.instanceOf(StateTransitionExecutionContext),
-    );
-
-    expect(stateRepositoryMock.disableIdentityKeys).to.be.calledOnceWithExactly(
-      match((id) => id.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
-      stateTransition.getPublicKeyIdsToDisable(),
-      stateTransition.getPublicKeysDisabledAt().getTime(),
-      match.instanceOf(StateTransitionExecutionContext),
-    );
-
-    const publicKeysToAdd = stateTransition.getPublicKeysToAdd()
-      .map((publicKey) => publicKey.toObject({ skipSignature: true }));
-
-    expect(stateRepositoryMock.addKeysToIdentity).to.be.calledOnceWithExactly(
-      match((id) => id.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
-      match((args) => expect(args.map((k) => k.toObject())).to.deep.equals(publicKeysToAdd)),
-      match.instanceOf(StateTransitionExecutionContext),
-    );
-  });
-
-  it('should add and disable public keys on dry run', async function () {
-    const { match } = this.sinonSandbox;
-
-    executionContext.enableDryRun();
-
-    await applyIdentityUpdateTransition(stateTransition);
-
-    executionContext.disableDryRun();
-
-    expect(stateRepositoryMock.updateIdentityRevision).to.be.calledOnceWithExactly(
-      match((id) => id.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
-      stateTransition.getRevision(),
-      match.instanceOf(StateTransitionExecutionContext),
-    );
-
-    expect(stateRepositoryMock.disableIdentityKeys).to.be.calledOnceWithExactly(
-      match((id) => id.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
-      stateTransition.getPublicKeyIdsToDisable(),
-      stateTransition.getPublicKeysDisabledAt().getTime(),
-      match.instanceOf(StateTransitionExecutionContext),
-    );
-
-    const publicKeysToAdd = stateTransition.getPublicKeysToAdd()
-      .map((publicKey) => publicKey.toObject({ skipSignature: true }));
-
-    expect(stateRepositoryMock.addKeysToIdentity).to.be.calledOnceWithExactly(
-      match((id) => id.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
-      match((args) => expect(args.map((k) => k.toObject())).to.deep.equals(publicKeysToAdd)),
-      match.instanceOf(StateTransitionExecutionContext),
-    );
-  });
-});

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

@@ -1,36 +0,0 @@
-const createAssetLockProofInstanceJS = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/createAssetLockProofInstance');
-const getChainAssetLockFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
-const getInstantAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
-const { default: loadWasmDpp } = require('../../../../../dist');
-
-describe('createAssetLockProofInstance', () => {
-  let createAssetLockProofInstance;
-  let InstantAssetLockProof;
-  let ChainAssetLockProof;
-
-  before(async () => {
-    ({
-      createAssetLockProofInstance,
-      InstantAssetLockProof,
-      ChainAssetLockProof,
-    } = await loadWasmDpp());
-  });
-
-  it('should create an instance of InstantAssetLockProof', () => {
-    const assetLockProofFixture = getInstantAssetLockProofFixture();
-    const instance = createAssetLockProofInstance(assetLockProofFixture.toObject());
-    const instanceJS = createAssetLockProofInstanceJS(assetLockProofFixture.toObject());
-
-    expect(instance.toObject()).to.deep.equal(instanceJS.toObject());
-    expect(instance).to.be.an.instanceOf(InstantAssetLockProof);
-  });
-
-  it('should create an instance of ChainAssetLockProof', () => {
-    const assetLockProofFixture = getChainAssetLockFixture();
-    const instance = createAssetLockProofInstance(assetLockProofFixture.toObject());
-    const instanceJS = createAssetLockProofInstanceJS(assetLockProofFixture.toObject());
-
-    expect(instance.toObject()).to.deep.equal(instanceJS.toObject());
-    expect(instance).to.be.an.instanceOf(ChainAssetLockProof);
-  });
-});

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

@@ -1,63 +0,0 @@
-const { Script } = require('@dashevo/dashcore-lib');
-
-const getInstantAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
-
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-const { default: loadWasmpDpp } = require('../../../../../dist');
-
-describe('fetchAssetLockPublicKeyHashFactory', () => {
-  let fetchAssetLockPublicKeyHash;
-  let stateRepositoryMock;
-  let executionContext;
-
-  let StateTransitionExecutionContext;
-  let InstantAssetLockProof;
-  let AssetLockOutputNotFoundError;
-  let fetchAssetLockPublicKeyHashDPP;
-
-  before(async () => {
-    ({
-      StateTransitionExecutionContext,
-      InstantAssetLockProof,
-      AssetLockOutputNotFoundError,
-      fetchAssetLockPublicKeyHash: fetchAssetLockPublicKeyHashDPP,
-    } = await loadWasmpDpp());
-  });
-
-  beforeEach(function beforeEach() {
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-
-    executionContext = new StateTransitionExecutionContext();
-
-    fetchAssetLockPublicKeyHash = (proof) => fetchAssetLockPublicKeyHashDPP(
-      stateRepositoryMock,
-      proof,
-      executionContext,
-    );
-  });
-
-  it('should return public key hash for specified asset lock proof', async () => {
-    const assetLockProof = new InstantAssetLockProof(
-      getInstantAssetLockProofFixture().toObject(),
-    );
-
-    const result = await fetchAssetLockPublicKeyHash(assetLockProof);
-
-    expect(result).to
-      .deep.equal(new Script(assetLockProof.getOutput().script).getData());
-  });
-
-  it('should throw AssetLockOutputNotFoundError if output is not found', async () => {
-    try {
-      const assetLockProofJS = getInstantAssetLockProofFixture();
-      // Mess up TX outputs
-      assetLockProofJS.transaction.outputs = [];
-
-      const assetLockProof = new InstantAssetLockProof(assetLockProofJS.toObject());
-      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

@@ -1,47 +0,0 @@
-const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
-
-const validateRequiredPurposeAndSecurityLevelFactory = require('@dashevo/dpp/lib/identity/validation/validateRequiredPurposeAndSecurityLevelFactory');
-
-const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
-
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-
-const MissingMasterPublicKeyError = require('@dashevo/dpp/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();
-  });
-});