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

package/test/integration/identity/stateTransition/IdentityCreateTransition/validation/basic/validateIdentityCreateTransitionBasicFactory.spec.js

@@ -1,83 +1,94 @@
-const { getRE2Class } = require('@dashevo/wasm-re2');
-
-const createAjv = require('@dashevo/dpp/lib/ajv/createAjv');
-
-const JsonSchemaValidator = require('@dashevo/dpp/lib/validation/JsonSchemaValidator');
+const { PrivateKey } = require('@dashevo/dashcore-lib');
 
 const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
 
-const validateIdentityCreateTransitionBasicFactory = require(
-  '@dashevo/dpp/lib/identity/stateTransition/IdentityCreateTransition/validation/basic/validateIdentityCreateTransitionBasicFactory',
-);
-
-const {
-  expectJsonSchemaError,
-  expectValidationError,
-} = require('@dashevo/dpp/lib/test/expect/expectError');
-
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-const InstantAssetLockProof = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/instant/InstantAssetLockProof');
-const ChainAssetLockProof = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/chain/ChainAssetLockProof');
-const SomeConsensusError = require('@dashevo/dpp/lib/test/mocks/SomeConsensusError');
-const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+const { expectValidationError, expectJsonSchemaError } = require('../../../../../../../lib/test/expect/expectError');
+const { default: loadWasmDpp } = require('../../../../../../../dist');
+const getBlsAdapterMock = require('../../../../../../../lib/test/mocks/getBlsAdapterMock');
 
 describe('validateIdentityCreateTransitionBasicFactory', () => {
-  let validateIdentityCreateTransitionBasic;
   let rawStateTransition;
   let stateTransition;
-  let validatePublicKeysMock;
-  let validatePublicKeysInIdentityCreateTransition;
-  let assetLockPublicKeyHash;
-  let proofValidationFunctionsByTypeMock;
-  let validateProtocolVersionMock;
-  let validatePublicKeySignaturesMock;
 
-  beforeEach(async function beforeEach() {
-    validatePublicKeysMock = this.sinonSandbox.stub()
-      .returns(new ValidationResult());
+  let stateRepositoryMock;
+  let mockIdentityPublicKeyCreateTransition;
+  let executionContext;
+
+  let validateIdentityCreateTransitionBasic;
 
-    validatePublicKeysInIdentityCreateTransition = this.sinonSandbox.stub()
-      .returns(new ValidationResult());
+  let StateTransitionExecutionContext;
+  let IdentityCreateTransition;
+  let IdentityPublicKey;
+  let UnsupportedProtocolVersionError;
+  let InvalidInstantAssetLockProofSignatureError;
+  let InvalidIdentityPublicKeySecurityLevelError;
+  let InvalidIdentityPublicKeyDataError;
+  let InvalidIdentityKeySignatureError;
+  let IdentityCreateTransitionBasicValidator;
+  let IdentityPublicKeyCreateTransition;
+
+  before(async () => {
+    ({
+      IdentityCreateTransition,
+      StateTransitionExecutionContext,
+      UnsupportedProtocolVersionError,
+      InvalidInstantAssetLockProofSignatureError,
+      InvalidIdentityPublicKeySecurityLevelError,
+      InvalidIdentityPublicKeyDataError,
+      InvalidIdentityKeySignatureError,
+      IdentityPublicKeyCreateTransition,
+      IdentityCreateTransitionBasicValidator,
+      IdentityPublicKey,
+    } = await loadWasmDpp());
+
+    mockIdentityPublicKeyCreateTransition = (publicKey, opts = {}) => (
+      new IdentityPublicKeyCreateTransition({
+        id: 0,
+        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+        data: publicKey,
+        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+        readOnly: false,
+        signature: Buffer.alloc(0),
+        ...opts,
+      })
+    );
+  });
 
-    assetLockPublicKeyHash = Buffer.alloc(20, 1);
+  beforeEach(async function () {
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.verifyInstantLock.resolves(true);
+    stateRepositoryMock.isAssetLockTransactionOutPointAlreadyUsed.resolves(false);
 
-    const assetLockValidationResult = new ValidationResult();
+    executionContext = new StateTransitionExecutionContext();
 
-    assetLockValidationResult.setData(assetLockPublicKeyHash);
+    const blsAdapter = await getBlsAdapterMock();
 
-    const RE2 = await getRE2Class();
-    const ajv = createAjv(RE2);
+    const validator = new IdentityCreateTransitionBasicValidator(stateRepositoryMock, blsAdapter);
+    validateIdentityCreateTransitionBasic = (st, context) => validator.validate(st, context);
 
-    const jsonSchemaValidator = new JsonSchemaValidator(ajv);
+    const stateTransitionJS = getIdentityCreateTransitionFixture();
+    stateTransition = new IdentityCreateTransition(stateTransitionJS.toObject());
 
-    const proofValidationResult = new ValidationResult();
-    proofValidationResult.setData(assetLockPublicKeyHash);
+    const privateKey = new PrivateKey('9b67f852093bc61cea0eeca38599dbfba0de28574d2ed9b99d10d33dc1bde7b2');
+    const publicKey = privateKey.toPublicKey();
 
-    proofValidationFunctionsByTypeMock = {
-      [InstantAssetLockProof.type]: this.sinonSandbox.stub().resolves(proofValidationResult),
-      [ChainAssetLockProof.type]: this.sinonSandbox.stub().resolves(proofValidationResult),
-    };
+    const identityPublicKey = mockIdentityPublicKeyCreateTransition(publicKey.toBuffer());
 
-    validateProtocolVersionMock = this.sinonSandbox.stub().returns(new ValidationResult());
+    stateTransition.setPublicKeys([identityPublicKey]);
 
-    validatePublicKeySignaturesMock = this.sinonSandbox.stub()
-      .returns(new ValidationResult());
+    // Sign a new public key
 
-    validateIdentityCreateTransitionBasic = validateIdentityCreateTransitionBasicFactory(
-      jsonSchemaValidator,
-      validatePublicKeysMock,
-      validatePublicKeysInIdentityCreateTransition,
-      proofValidationFunctionsByTypeMock,
-      validateProtocolVersionMock,
-      validatePublicKeySignaturesMock,
+    await stateTransition.signByPrivateKey(
+      privateKey.toBuffer(),
+      identityPublicKey.type,
     );
 
-    stateTransition = getIdentityCreateTransitionFixture();
+    const publicKeySignature = stateTransition.getSignature();
+    identityPublicKey.setSignature(publicKeySignature);
 
-    const privateKey = '9b67f852093bc61cea0eeca38599dbfba0de28574d2ed9b99d10d33dc1bde7b2';
-
-    await stateTransition.signByPrivateKey(privateKey, IdentityPublicKey.TYPES.ECDSA_SECP256K1);
+    stateTransition.setPublicKeys([identityPublicKey]);
 
     rawStateTransition = stateTransition.toObject();
   });
@@ -86,9 +97,12 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
     it('should be present', async () => {
       delete rawStateTransition.protocolVersion;
 
-      const result = await validateIdentityCreateTransitionBasic(rawStateTransition);
+      const result = await validateIdentityCreateTransitionBasic(
+        rawStateTransition,
+        executionContext,
+      );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -100,9 +114,12 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
     it('should be an integer', async () => {
       rawStateTransition.protocolVersion = '1';
 
-      const result = await validateIdentityCreateTransitionBasic(rawStateTransition);
+      const result = await validateIdentityCreateTransitionBasic(
+        rawStateTransition,
+        executionContext,
+      );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -111,26 +128,14 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
     });
 
     it('should be valid', async () => {
-      rawStateTransition.protocolVersion = -1;
-
-      const protocolVersionError = new SomeConsensusError('test');
-      const protocolVersionResult = new ValidationResult([
-        protocolVersionError,
-      ]);
-
-      validateProtocolVersionMock.returns(protocolVersionResult);
-
-      const result = await validateIdentityCreateTransitionBasic(rawStateTransition);
-
-      expectValidationError(result, SomeConsensusError);
-
-      const [error] = result.getErrors();
-
-      expect(error).to.equal(protocolVersionError);
+      rawStateTransition.protocolVersion = 1000;
 
-      expect(validateProtocolVersionMock).to.be.calledOnceWith(
-        rawStateTransition.protocolVersion,
+      const result = await validateIdentityCreateTransitionBasic(
+        rawStateTransition,
+        executionContext,
       );
+
+      await expectValidationError(result, UnsupportedProtocolVersionError);
     });
   });
 
@@ -138,9 +143,12 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
     it('should be present', async () => {
       delete rawStateTransition.type;
 
-      const result = await validateIdentityCreateTransitionBasic(rawStateTransition);
+      const result = await validateIdentityCreateTransitionBasic(
+        rawStateTransition,
+        executionContext,
+      );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -152,9 +160,12 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
     it('should be equal to 2', async () => {
       rawStateTransition.type = 666;
 
-      const result = await validateIdentityCreateTransitionBasic(rawStateTransition);
+      const result = await validateIdentityCreateTransitionBasic(
+        rawStateTransition,
+        executionContext,
+      );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -170,9 +181,10 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
 
       const result = await validateIdentityCreateTransitionBasic(
         rawStateTransition,
+        executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -184,9 +196,12 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
     it('should be an object', async () => {
       rawStateTransition.assetLockProof = 1;
 
-      const result = await validateIdentityCreateTransitionBasic(rawStateTransition);
+      const result = await validateIdentityCreateTransitionBasic(
+        rawStateTransition,
+        executionContext,
+      );
 
-      expectJsonSchemaError(result, 1);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
@@ -195,31 +210,18 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
     });
 
     it('should be valid', async () => {
-      const assetLockError = new SomeConsensusError('test');
-      const assetLockResult = new ValidationResult([
-        assetLockError,
-      ]);
-
-      const executionContext = new StateTransitionExecutionContext();
-
-      proofValidationFunctionsByTypeMock[InstantAssetLockProof.type].resolves(assetLockResult);
+      stateRepositoryMock.verifyInstantLock.resolves(false);
 
       const result = await validateIdentityCreateTransitionBasic(
         rawStateTransition,
         executionContext,
       );
 
-      expectValidationError(result);
+      await expectValidationError(result);
 
       const [error] = result.getErrors();
 
-      expect(error).to.equal(assetLockError);
-
-      expect(proofValidationFunctionsByTypeMock[InstantAssetLockProof.type])
-        .to.be.calledOnceWithExactly(
-          rawStateTransition.assetLockProof,
-          executionContext,
-        );
+      expect(error).to.be.instanceOf(InvalidInstantAssetLockProofSignatureError);
     });
   });
 
@@ -229,9 +231,10 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
 
       const result = await validateIdentityCreateTransitionBasic(
         rawStateTransition,
+        executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -245,9 +248,10 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
 
       const result = await validateIdentityCreateTransitionBasic(
         rawStateTransition,
+        executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -259,14 +263,15 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
       const [key] = rawStateTransition.publicKeys;
 
       for (let i = 0; i < 10; i++) {
-        rawStateTransition.publicKeys.push(key);
+        rawStateTransition.publicKeys.push({ ...key, id: i + 1 });
       }
 
       const result = await validateIdentityCreateTransitionBasic(
         rawStateTransition,
+        executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -279,9 +284,10 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
 
       const result = await validateIdentityCreateTransitionBasic(
         rawStateTransition,
+        executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -290,66 +296,68 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
     });
 
     it('should be valid', async () => {
-      const publicKeysError = new SomeConsensusError('test');
-      const publicKeysResult = new ValidationResult([
-        publicKeysError,
-      ]);
+      const privateKey = new PrivateKey();
+
+      // Mess up public key
+      const identityPublicKey = mockIdentityPublicKeyCreateTransition(Buffer.alloc(33));
+
+      stateTransition.setPublicKeys([identityPublicKey]);
+      await stateTransition.signByPrivateKey(
+        privateKey.toBuffer(),
+        identityPublicKey.type,
+      );
+      identityPublicKey.setSignature(stateTransition.getSignature());
+      stateTransition.setPublicKeys([identityPublicKey]);
 
-      validatePublicKeysMock.returns(publicKeysResult);
+      rawStateTransition = stateTransition.toObject();
 
       const result = await validateIdentityCreateTransitionBasic(
         rawStateTransition,
+        executionContext,
       );
 
-      expectValidationError(result);
+      await expectValidationError(result, InvalidIdentityPublicKeyDataError);
+    });
 
-      const [error] = result.getErrors();
+    it('should have at least 1 master key', async () => {
+      const privateKey = new PrivateKey();
 
-      expect(error).to.equal(publicKeysError);
+      // Mess up public key's purpose
+      const identityPublicKey = mockIdentityPublicKeyCreateTransition(
+        privateKey.toPublicKey().toBuffer(),
+      );
 
-      expect(validatePublicKeysMock)
-        .to.be.calledOnceWithExactly(rawStateTransition.publicKeys);
-    });
+      identityPublicKey.setPurpose(2);
 
-    it('should have at least 1 master key', async () => {
-      const publicKeysError = new SomeConsensusError('test');
-      const publicKeysResult = new ValidationResult([
-        publicKeysError,
-      ]);
+      stateTransition.setPublicKeys([identityPublicKey]);
+      await stateTransition.signByPrivateKey(
+        privateKey.toBuffer(),
+        identityPublicKey.type,
+      );
+      identityPublicKey.setSignature(stateTransition.getSignature());
+      stateTransition.setPublicKeys([identityPublicKey]);
 
-      validatePublicKeysInIdentityCreateTransition.returns(publicKeysResult);
+      rawStateTransition = stateTransition.toObject();
 
       const result = await validateIdentityCreateTransitionBasic(
         rawStateTransition,
+        executionContext,
       );
 
-      expectValidationError(result);
-
-      const [error] = result.getErrors();
-
-      expect(error).to.equal(publicKeysError);
-
-      expect(validatePublicKeysInIdentityCreateTransition)
-        .to.be.calledOnceWithExactly(rawStateTransition.publicKeys);
+      await expectValidationError(result, InvalidIdentityPublicKeySecurityLevelError);
     });
 
     it('should have valid signatures', async () => {
-      const publicKeysError = new SomeConsensusError('test');
-      const publicKeysResult = new ValidationResult([
-        publicKeysError,
-      ]);
-
-      validatePublicKeySignaturesMock.resolves(publicKeysResult);
+      const invalidSignature = Buffer.alloc(65);
+      rawStateTransition.signature = invalidSignature;
+      rawStateTransition.publicKeys[0].signature = invalidSignature;
 
       const result = await validateIdentityCreateTransitionBasic(
         rawStateTransition,
+        executionContext,
       );
 
-      expectValidationError(result);
-
-      const [error] = result.getErrors();
-
-      expect(error).to.equal(publicKeysError);
+      await expectValidationError(result, InvalidIdentityKeySignatureError);
     });
   });
 
@@ -357,13 +365,16 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
     it('should be present', async () => {
       delete rawStateTransition.signature;
 
-      const result = await validateIdentityCreateTransitionBasic(rawStateTransition);
+      const result = await validateIdentityCreateTransitionBasic(
+        rawStateTransition,
+        executionContext,
+      );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('');
+      expect(error.getInstancePath()).to.equal('');
       expect(error.getKeyword()).to.equal('required');
       expect(error.getParams().missingProperty).to.equal('signature');
     });
@@ -371,52 +382,62 @@ describe('validateIdentityCreateTransitionBasicFactory', () => {
     it('should be a byte array', async () => {
       rawStateTransition.signature = new Array(65).fill('string');
 
-      const result = await validateIdentityCreateTransitionBasic(rawStateTransition);
+      const result = await validateIdentityCreateTransitionBasic(
+        rawStateTransition,
+        executionContext,
+      );
 
-      expectJsonSchemaError(result, 2);
+      await expectJsonSchemaError(result, 65);
 
-      const [error, byteArrayError] = result.getErrors();
+      const firstError = result.getErrors()[0];
+      const lastError = result.getErrors()[64];
 
-      expect(error.instancePath).to.equal('/signature/0');
-      expect(error.getKeyword()).to.equal('type');
+      expect(firstError.getInstancePath()).to.equal('/signature/0');
+      expect(firstError.getKeyword()).to.equal('type');
 
-      expect(byteArrayError.getKeyword()).to.equal('byteArray');
+      expect(lastError.getInstancePath()).to.equal('/signature/64');
+      expect(lastError.getKeyword()).to.equal('type');
     });
 
     it('should be not shorter than 65 bytes', async () => {
       rawStateTransition.signature = Buffer.alloc(64);
 
-      const result = await validateIdentityCreateTransitionBasic(rawStateTransition);
+      const result = await validateIdentityCreateTransitionBasic(
+        rawStateTransition,
+        executionContext,
+      );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/signature');
+      expect(error.getInstancePath()).to.equal('/signature');
       expect(error.getKeyword()).to.equal('minItems');
     });
 
     it('should be not longer than 65 bytes', async () => {
       rawStateTransition.signature = Buffer.alloc(66);
 
-      const result = await validateIdentityCreateTransitionBasic(rawStateTransition);
+      const result = await validateIdentityCreateTransitionBasic(
+        rawStateTransition,
+        executionContext,
+      );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/signature');
+      expect(error.getInstancePath()).to.equal('/signature');
       expect(error.getKeyword()).to.equal('maxItems');
     });
   });
 
   it('should return valid result', async () => {
-    const result = await validateIdentityCreateTransitionBasic(rawStateTransition);
+    const result = await validateIdentityCreateTransitionBasic(
+      rawStateTransition,
+      executionContext,
+    );
 
     expect(result.isValid()).to.be.true();
-
-    expect(validatePublicKeysMock).to.be.calledOnceWithExactly(
-      rawStateTransition.publicKeys,
-    );
   });
 });