@dashevo/wasm-dpp 0.24.0-dev.12 → 0.24.0-dev.14

package/test/integration/identity/stateTransition/IdentityUpdateTransition/validation/state/validateIdentityUpdateTransitionStateFactory.spec.js

@@ -1,50 +1,77 @@
+const identitySchema = require('@dashevo/dpp/schema/identity/identity.json');
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-const validateIdentityUpdateTransitionStateFactory = require('@dashevo/dpp/lib/identity/stateTransition/IdentityUpdateTransition/validation/state/validateIdentityUpdateTransitionStateFactory');
 const getIdentityUpdateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityUpdateTransitionFixture');
-const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
 const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
 const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
-const InvalidIdentityRevisionError = require('@dashevo/dpp/lib/errors/consensus/state/identity/InvalidIdentityRevisionError');
-const IdentityPublicKeyIsReadOnlyError = require('@dashevo/dpp/lib/errors/consensus/state/identity/IdentityPublicKeyIsReadOnlyError');
-const IdentityPublicKeyDisabledAtWindowViolationError = require('@dashevo/dpp/lib/errors/consensus/state/identity/IdentityPublicKeyDisabledAtWindowViolationError');
-const InvalidIdentityPublicKeyIdError = require('@dashevo/dpp/lib/errors/consensus/state/identity/InvalidIdentityPublicKeyIdError');
 const SomeConsensusError = require('@dashevo/dpp/lib/test/mocks/SomeConsensusError');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
-const IdentityPublicKeyIsDisabledError = require('@dashevo/dpp/lib/errors/consensus/state/identity/IdentityPublicKeyIsDisabledError');
+
+const { default: loadWasmDpp } = require('../../../../../../../dist');
+const { expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
+const generateRandomIdentifierAsync = require('../../../../../../../lib/test/utils/generateRandomIdentifierAsync');
+const getBlsAdapterMock = require('../../../../../../../lib/test/mocks/getBlsAdapterMock');
 
 describe('validateIdentityUpdateTransitionStateFactory', () => {
   let validateIdentityUpdateTransitionState;
   let stateRepositoryMock;
   let stateTransition;
   let identity;
+  let rawIdentity;
   let validatePublicKeysMock;
-  let fakeTime;
   let blockTime;
-  let validateRequiredPurposeAndSecurityLevelMock;
   let executionContext;
 
+  let Identity;
+  let IdentityPublicKey;
+  let IdentityUpdateTransition;
+  let InvalidIdentityRevisionError;
+  let IdentityPublicKeyIsReadOnlyError;
+  let IdentityPublicKeyIsDisabledError;
+  let InvalidIdentityPublicKeyIdError;
+  let MissingMasterPublicKeyError;
+  let IdentityPublicKeyDisabledAtWindowViolationError;
+  let MaxIdentityPublicKeyLimitReachedError;
+  let StateTransitionExecutionContext;
+  let IdentityUpdateTransitionStateValidator;
+
+  before(async () => {
+    ({
+      Identity,
+      IdentityPublicKey,
+      IdentityUpdateTransition,
+      InvalidIdentityRevisionError,
+      IdentityPublicKeyIsReadOnlyError,
+      IdentityPublicKeyIsDisabledError,
+      InvalidIdentityPublicKeyIdError,
+      IdentityPublicKeyDisabledAtWindowViolationError,
+      MaxIdentityPublicKeyLimitReachedError,
+      StateTransitionExecutionContext,
+      IdentityUpdateTransitionStateValidator,
+      MissingMasterPublicKeyError,
+    } = await loadWasmDpp());
+  });
+
   beforeEach(async function beforeEach() {
-    identity = getIdentityFixture();
-    validatePublicKeysMock = this.sinonSandbox.stub()
-      .returns(new ValidationResult());
-    validateRequiredPurposeAndSecurityLevelMock = this.sinonSandbox.stub()
-      .returns(new ValidationResult());
+    rawIdentity = getIdentityFixture().toObject();
+    // Patch identity id to be acceptable by wasm-dpp
+    rawIdentity.id = await generateRandomIdentifierAsync();
+    identity = new Identity(rawIdentity);
 
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
     stateRepositoryMock.fetchIdentity.resolves(identity);
 
     blockTime = Date.now();
+    const blsAdapter = await getBlsAdapterMock();
 
+    stateRepositoryMock.fetchLatestPlatformBlockTime = this.sinonSandbox.stub();
     stateRepositoryMock.fetchLatestPlatformBlockTime.resolves(blockTime);
 
-    validateIdentityUpdateTransitionState = validateIdentityUpdateTransitionStateFactory(
-      stateRepositoryMock,
-      validatePublicKeysMock,
-      validateRequiredPurposeAndSecurityLevelMock,
+    const validator = new IdentityUpdateTransitionStateValidator(stateRepositoryMock, blsAdapter);
+    validateIdentityUpdateTransitionState = (st) => validator.validate(st);
+
+    stateTransition = new IdentityUpdateTransition(
+      getIdentityUpdateTransitionFixture().toObject(),
     );
 
-    stateTransition = getIdentityUpdateTransitionFixture();
     stateTransition.setRevision(identity.getRevision() + 1);
     stateTransition.setPublicKeyIdsToDisable(undefined);
     stateTransition.setPublicKeysDisabledAt(undefined);
@@ -55,46 +82,47 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
 
     const privateKey = '9b67f852093bc61cea0eeca38599dbfba0de28574d2ed9b99d10d33dc1bde7b2';
 
-    await stateTransition.signByPrivateKey(privateKey, IdentityPublicKey.TYPES.ECDSA_SECP256K1);
-
-    fakeTime = this.sinonSandbox.useFakeTimers(new Date());
-  });
-
-  afterEach(() => {
-    fakeTime.reset();
+    await stateTransition.signByPrivateKey(
+      Buffer.from(privateKey, 'hex'), IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+    );
   });
 
   it('should return InvalidIdentityRevisionError if new revision is not incremented by 1', async () => {
-    stateTransition.setRevision(identity.getRevision() + 2);
+    stateTransition.setRevision(rawIdentity.revision + 2);
 
     const result = await validateIdentityUpdateTransitionState(stateTransition);
 
-    expectValidationError(result, InvalidIdentityRevisionError);
+    await expectValidationError(result, InvalidIdentityRevisionError);
 
     const [error] = result.getErrors();
-    expect(error.getIdentityId()).to.deep.equal(stateTransition.getIdentityId());
-    expect(error.getCurrentRevision()).to.equal(identity.getRevision());
+    expect(error.getIdentityId()).to.deep.equal(stateTransition.getIdentityId().toBuffer());
+    expect(error.getCurrentRevision()).to.equal(rawIdentity.revision);
   });
 
   it('should return IdentityPublicKeyIsReadOnlyError if disabling public key is readOnly', async () => {
-    identity.getPublicKeyById(0).setReadOnly(true);
+    const keys = identity.getPublicKeys();
+    keys[0].setReadOnly(true);
+    identity.setPublicKeys(keys);
+
     stateTransition.setPublicKeyIdsToDisable([0]);
 
     const result = await validateIdentityUpdateTransitionState(stateTransition);
 
-    expectValidationError(result, IdentityPublicKeyIsReadOnlyError);
+    await expectValidationError(result, IdentityPublicKeyIsReadOnlyError);
 
     const [error] = result.getErrors();
     expect(error.getPublicKeyIndex()).to.equal(0);
   });
 
   it('should return IdentityPublicKeyIsDisabledError if disabling public key is already disabled', async () => {
-    identity.getPublicKeyById(0).setDisabledAt(new Date().getTime());
+    const keys = identity.getPublicKeys();
+    keys[0].setDisabledAt(new Date().getTime());
+    identity.setPublicKeys(keys);
     stateTransition.setPublicKeyIdsToDisable([0]);
 
     const result = await validateIdentityUpdateTransitionState(stateTransition);
 
-    expectValidationError(result, IdentityPublicKeyIsDisabledError);
+    await expectValidationError(result, IdentityPublicKeyIsDisabledError);
 
     const [error] = result.getErrors();
     expect(error.getPublicKeyIndex()).to.equal(0);
@@ -103,7 +131,8 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
   it('should return invalid result if disabledAt has violated time window', async () => {
     stateTransition.setPublicKeyIdsToDisable([1]);
     // blockTime - 10 minutes
-    stateTransition.setPublicKeysDisabledAt(new Date(blockTime - 1000 * 60 * 60 * 10));
+    const disabledAt = new Date(blockTime - 1000 * 60 * 60 * 10);
+    stateTransition.setPublicKeysDisabledAt(disabledAt);
 
     const timeWindowStart = new Date(blockTime);
     timeWindowStart.setMinutes(
@@ -117,12 +146,12 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
 
     const result = await validateIdentityUpdateTransitionState(stateTransition);
 
-    expectValidationError(result, IdentityPublicKeyDisabledAtWindowViolationError);
+    await expectValidationError(result, IdentityPublicKeyDisabledAtWindowViolationError);
 
     const [error] = result.getErrors();
-    expect(error.getDisabledAt()).to.deep.equal(stateTransition.publicKeysDisabledAt);
-    expect(error.getTimeWindowStart()).to.deep.equal(timeWindowStart);
-    expect(error.getTimeWindowEnd()).to.deep.equal(timeWindowEnd);
+    expect(error.getDisabledAt()).to.deep.equal(disabledAt);
+    expect(error.getTimeWindowStart()).to.be.instanceOf(Date);
+    expect(error.getTimeWindowEnd()).to.be.instanceOf(Date);
   });
 
   it('should throw InvalidIdentityPublicKeyIdError if identity does not contain public key with disabling ID', async () => {
@@ -131,13 +160,13 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
 
     const result = await validateIdentityUpdateTransitionState(stateTransition);
 
-    expectValidationError(result, InvalidIdentityPublicKeyIdError);
+    await expectValidationError(result, InvalidIdentityPublicKeyIdError);
 
     const [error] = result.getErrors();
     expect(error.getId()).to.equal(3);
   });
 
-  it('should pass when disabling public key', async () => {
+  it('should pass when disabling public key', async function () {
     stateTransition.setPublicKeyIdsToDisable([1]);
     stateTransition.setPublicKeysDisabledAt(new Date());
     stateTransition.setPublicKeysToAdd(undefined);
@@ -146,17 +175,18 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
 
     expect(result.isValid()).to.be.true();
 
+    const { match } = this.sinonSandbox;
     expect(stateRepositoryMock.fetchIdentity)
       .to.be.calledOnceWithExactly(
-        stateTransition.getIdentityId(),
-        executionContext,
+        match((val) => val.toBuffer().equals(stateTransition.getIdentityId().toBuffer())),
+        match.instanceOf(StateTransitionExecutionContext),
       );
 
     expect(stateRepositoryMock.fetchLatestPlatformBlockTime)
       .to.be.calledOnce();
   });
 
-  it('should pass when adding public key', async () => {
+  it('should pass when adding public key', async function () {
     stateTransition.setPublicKeyIdsToDisable(undefined);
     stateTransition.setPublicKeysDisabledAt(undefined);
 
@@ -164,23 +194,18 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
 
     expect(result.isValid()).to.be.true();
 
+    const { match } = this.sinonSandbox;
     expect(stateRepositoryMock.fetchIdentity)
       .to.be.calledOnceWithExactly(
-        stateTransition.getIdentityId(),
-        executionContext,
+        match((val) => val.toBuffer().equals(stateTransition.getIdentityId().toBuffer())),
+        match.instanceOf(StateTransitionExecutionContext),
       );
 
     expect(stateRepositoryMock.fetchLatestPlatformBlockTime)
       .to.not.be.called();
-
-    expect(validatePublicKeysMock).to.be.calledOnceWithExactly(
-      [...identity.getPublicKeys(), ...stateTransition.getPublicKeysToAdd()].map(
-        (pk) => pk.toObject(),
-      ),
-    );
   });
 
-  it('should pass when both adding and disabling public keys', async () => {
+  it('should pass when both adding and disabling public keys', async function () {
     stateTransition.setPublicKeyIdsToDisable([1]);
     stateTransition.setPublicKeysDisabledAt(new Date());
 
@@ -188,10 +213,11 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
 
     expect(result.isValid()).to.be.true();
 
+    const { match } = this.sinonSandbox;
     expect(stateRepositoryMock.fetchIdentity)
       .to.be.calledOnceWithExactly(
-        stateTransition.getIdentityId(),
-        executionContext,
+        match((val) => val.toBuffer().equals(stateTransition.getIdentityId().toBuffer())),
+        match.instanceOf(StateTransitionExecutionContext),
       );
 
     expect(stateRepositoryMock.fetchLatestPlatformBlockTime)
@@ -199,43 +225,36 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
   });
 
   it('should validate purpose and security level', async () => {
-    const now = new Date();
-
-    stateTransition.setPublicKeyIdsToDisable([1]);
-    stateTransition.setPublicKeysDisabledAt(now);
-
-    const publicKeysError = new SomeConsensusError('test');
+    const identityKeys = identity.getPublicKeys();
+    identityKeys.forEach((key) => key.setSecurityLevel(1));
+    identity.setPublicKeys(identityKeys);
 
-    validateRequiredPurposeAndSecurityLevelMock.onCall(0)
-      .returns(new ValidationResult([publicKeysError]));
+    const keysToAdd = stateTransition.getPublicKeysToAdd();
+    keysToAdd.forEach((key) => key.setSecurityLevel(1));
+    stateTransition.setPublicKeysToAdd(keysToAdd);
 
     const result = await validateIdentityUpdateTransitionState(stateTransition);
 
-    expectValidationError(result, SomeConsensusError);
-
-    expect(validateRequiredPurposeAndSecurityLevelMock).to.be.calledOnceWithExactly([
-      identity.getPublicKeys()[0].toObject(),
-      { ...identity.getPublicKeys()[1].toObject(), disabledAt: now.getTime() },
-      stateTransition.getPublicKeysToAdd()[0].toObject(),
-    ]);
+    await expectValidationError(result, MissingMasterPublicKeyError);
   });
 
   it('should validate public keys to add', async () => {
-    const publicKeysError = new SomeConsensusError('test');
+    // Reach max allowed public keys to fail validation
+    const { maxItems } = identitySchema.properties.publicKeys;
 
-    validatePublicKeysMock.onCall(0).returns(new ValidationResult([publicKeysError]));
+    const firstKey = identity.getPublicKeys()[0].toObject();
+    const keys = Array.from({ length: maxItems + 1 })
+      .map((_, index) => new IdentityPublicKey({ ...firstKey, id: index }));
+    identity.setPublicKeys(keys);
 
     const result = await validateIdentityUpdateTransitionState(stateTransition);
 
-    expectValidationError(result, SomeConsensusError);
-
-    expect(validatePublicKeysMock).to.be.calledOnceWithExactly(
-      [...identity.getPublicKeys(), ...stateTransition.getPublicKeysToAdd()]
-        .map((pk) => pk.toObject()),
-    );
+    await expectValidationError(result, MaxIdentityPublicKeyLimitReachedError);
   });
 
-  it('should validate resulting identity public keys', async () => {
+  // TODO: remove?
+  // Skipped, because two tests above are seem to be enough
+  it.skip('should validate resulting identity public keys', async () => {
     const publicKeysError = new SomeConsensusError('test');
 
     validatePublicKeysMock.returns(new ValidationResult([publicKeysError]));
@@ -253,29 +272,25 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
     );
   });
 
-  it('should return valid result on dry run', async () => {
+  it('should return valid result on dry run', async function () {
     stateTransition.setPublicKeyIdsToDisable([3]);
     stateTransition.setPublicKeysDisabledAt(new Date());
 
-    const publicKeysError = new SomeConsensusError('test');
-
-    validateRequiredPurposeAndSecurityLevelMock.onCall(0)
-      .returns(new ValidationResult([publicKeysError]));
+    // Make code that executes after dry run check to fail
+    stateRepositoryMock.fetchLatestPlatformBlockTime.resolves({});
 
     stateTransition.getExecutionContext().enableDryRun();
-
     const result = await validateIdentityUpdateTransitionState(stateTransition);
 
     stateTransition.getExecutionContext().disableDryRun();
 
     expect(result.isValid()).to.be.true();
 
-    expect(validatePublicKeysMock).to.not.be.called();
-    expect(validateRequiredPurposeAndSecurityLevelMock).to.not.be.called();
+    const { match } = this.sinonSandbox;
     expect(stateRepositoryMock.fetchIdentity)
       .to.be.calledOnceWithExactly(
-        stateTransition.getIdentityId(),
-        executionContext,
+        match((val) => val.toBuffer().equals(stateTransition.getIdentityId().toBuffer())),
+        match.instanceOf(StateTransitionExecutionContext),
       );
 
     expect(stateRepositoryMock.fetchLatestPlatformBlockTime)

package/test/integration/identity/stateTransition/IdentityUpdateTransition/validation/state/validatePublicKeysState.spec.js

@@ -1,26 +1,60 @@
-const validatePublicKeys = require(
-  '@dashevo/dpp/lib/identity/stateTransition/IdentityUpdateTransition/validation/state/validatePublicKeysState',
-);
-const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
-const DuplicatedIdentityPublicKeyIdError = require('@dashevo/dpp/lib/errors/consensus/state/identity/DuplicatedIdentityPublicKeyIdError');
-const DuplicatedIdentityPublicKeyError = require('@dashevo/dpp/lib/errors/consensus/state/identity/DuplicatedIdentityPublicKeyError');
 const identitySchema = require('@dashevo/dpp/schema/identity/identity.json');
-const MaxIdentityPublicKeyLimitReachedError = require('@dashevo/dpp/lib/errors/consensus/state/identity/MaxIdentityPublicKeyLimitReachedError');
-const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
+const { expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
+
+const { default: loadWasmDpp } = require('../../../../../../../dist');
 
 describe('validatePublicKeysState', () => {
+  let IdentityUpdatePublicKeysValidator;
+  let DuplicatedIdentityPublicKeyIdStateError;
+  let DuplicatedIdentityPublicKeyStateError;
+  let IdentityPublicKey;
+  let MaxIdentityPublicKeyLimitReachedError;
+
+  let validatePublicKeys;
   let rawPublicKeys;
 
+  before(async () => {
+    ({
+      IdentityPublicKey,
+      IdentityUpdatePublicKeysValidator,
+      DuplicatedIdentityPublicKeyStateError,
+      DuplicatedIdentityPublicKeyIdStateError,
+      MaxIdentityPublicKeyLimitReachedError,
+    } = await loadWasmDpp());
+  });
+
   beforeEach(() => {
-    ({ publicKeys: rawPublicKeys } = getIdentityFixture().toObject());
+    rawPublicKeys = [
+      {
+        id: 0,
+        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+        data: Buffer.from('AuryIuMtRrl/VviQuyLD1l4nmxi9ogPzC9LT7tdpo0di', 'base64'),
+        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+        signature: Buffer.alloc(0),
+        readOnly: false,
+      },
+      {
+        id: 1,
+        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+        data: Buffer.from('A8AK95PYMVX5VQKzOhcVQRCUbc9pyg3RiL7jttEMDU+L', 'base64'),
+        purpose: IdentityPublicKey.PURPOSES.ENCRYPTION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MEDIUM,
+        signature: Buffer.alloc(0),
+        readOnly: false,
+      },
+    ];
+
+    const validator = new IdentityUpdatePublicKeysValidator();
+    validatePublicKeys = (keys) => validator.validate(keys);
   });
 
-  it('should return invalid result if there are duplicate key ids', () => {
+  it('should return invalid result if there are duplicate key ids', async () => {
     rawPublicKeys[1].id = rawPublicKeys[0].id;
 
     const result = validatePublicKeys(rawPublicKeys);
 
-    expectValidationError(result, DuplicatedIdentityPublicKeyIdError);
+    await expectValidationError(result, DuplicatedIdentityPublicKeyIdStateError);
 
     const [error] = result.getErrors();
 
@@ -28,12 +62,12 @@ describe('validatePublicKeysState', () => {
     expect(error.getDuplicatedIds()).to.deep.equal([rawPublicKeys[1].id]);
   });
 
-  it('should return invalid result if there are duplicate keys', () => {
+  it('should return invalid result if there are duplicate keys', async () => {
     rawPublicKeys[1].data = rawPublicKeys[0].data;
 
     const result = validatePublicKeys(rawPublicKeys);
 
-    expectValidationError(result, DuplicatedIdentityPublicKeyError);
+    await expectValidationError(result, DuplicatedIdentityPublicKeyStateError);
 
     const [error] = result.getErrors();
 
@@ -47,7 +81,7 @@ describe('validatePublicKeysState', () => {
     expect(result.isValid()).to.be.true();
   });
 
-  it('should return invalid result if number of public keys is bigger than 32', () => {
+  it('should return invalid result if number of public keys is bigger than 32', async () => {
     const { maxItems } = identitySchema.properties.publicKeys;
     const numToAdd = maxItems - rawPublicKeys.length;
 
@@ -57,10 +91,10 @@ describe('validatePublicKeysState', () => {
 
     const result = validatePublicKeys(rawPublicKeys);
 
-    expectValidationError(result, MaxIdentityPublicKeyLimitReachedError);
+    await expectValidationError(result, MaxIdentityPublicKeyLimitReachedError);
 
     const [error] = result.getErrors();
     expect(error.getCode()).to.equal(4020);
-    expect(error.geMaxItems()).to.equal(maxItems);
+    expect(error.getMaxItems()).to.equal(maxItems);
   });
 });