@dashevo/wasm-dpp 0.23.0-dev.10

package/test/integration/identity/stateTransition/validatePublicKeySignaturesFactory.spec.js

@@ -0,0 +1,127 @@
+const { PrivateKey, crypto: { Hash } } = require('@dashevo/dashcore-lib');
+
+const crypto = require('crypto');
+
+const getIdentityCreateTransitionFixture = require('../../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
+const IdentityPublicKey = require('../../../../lib/identity/IdentityPublicKey');
+const BlsSignatures = require('../../../../lib/bls/bls');
+const validatePublicKeySignaturesFactory = require('../../../../lib/identity/stateTransition/validatePublicKeySignaturesFactory');
+const ValidationResult = require('../../../../lib/validation/ValidationResult');
+const { expectValidationError } = require('../../../../lib/test/expect/expectError');
+const InvalidIdentityKeySignatureError = require('../../../../lib/errors/consensus/basic/identity/InvalidIdentityKeySignatureError');
+
+describe('validatePublicKeySignaturesFactory', () => {
+  let identityCreateTransition;
+  let rawIdentityCreateTransition;
+  let validatePublicKeySignatures;
+
+  beforeEach(async function beforeEach() {
+    identityCreateTransition = getIdentityCreateTransitionFixture();
+
+    const privateKey1 = new PrivateKey();
+    const publicKey1 = privateKey1.toPublicKey();
+
+    const identityPublicKey1 = new IdentityPublicKey({
+      id: 0,
+      type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+      data: publicKey1.toBuffer(),
+      purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+      securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+      readOnly: false,
+    });
+
+    const privateKey2 = new PrivateKey();
+    const publicKey2 = privateKey2.toPublicKey();
+
+    const identityPublicKey2 = new IdentityPublicKey({
+      id: 1,
+      type: IdentityPublicKey.TYPES.ECDSA_HASH160,
+      data: Hash.sha256ripemd160(publicKey2.toBuffer()),
+      purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+      securityLevel: IdentityPublicKey.SECURITY_LEVELS.CRITICAL,
+      readOnly: false,
+    });
+
+    const { PrivateKey: BlsPrivateKey } = await BlsSignatures.getInstance();
+
+    const randomBytes = new Uint8Array(crypto.randomBytes(256));
+    const privateKey3 = BlsPrivateKey.fromBytes(randomBytes, true);
+    // blsPrivateKeyHex = Buffer.from(blsPrivateKey.serialize()).toString('hex');
+    const publicKey3 = privateKey3.getPublicKey();
+
+    const identityPublicKey3 = new IdentityPublicKey({
+      id: 2,
+      type: IdentityPublicKey.TYPES.BLS12_381,
+      data: Buffer.from(publicKey3.serialize()),
+      purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+      securityLevel: IdentityPublicKey.SECURITY_LEVELS.CRITICAL,
+      readOnly: false,
+    });
+
+    identityCreateTransition.setPublicKeys([
+      identityPublicKey1,
+      identityPublicKey2,
+      identityPublicKey3,
+    ]);
+
+    await identityCreateTransition.signByPrivateKey(
+      privateKey1,
+      IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+    );
+
+    const signature1 = identityCreateTransition.getSignature();
+
+    await identityCreateTransition.signByPrivateKey(
+      privateKey2,
+      IdentityPublicKey.TYPES.ECDSA_HASH160,
+    );
+
+    const signature2 = identityCreateTransition.getSignature();
+
+    await identityCreateTransition.signByPrivateKey(
+      Buffer.from(privateKey3.serialize()),
+      IdentityPublicKey.TYPES.BLS12_381,
+    );
+
+    const signature3 = identityCreateTransition.getSignature();
+
+    identityPublicKey1.setSignature(signature1);
+    identityPublicKey2.setSignature(signature2);
+    identityPublicKey3.setSignature(signature3);
+
+    rawIdentityCreateTransition = identityCreateTransition.toObject();
+
+    const createStateTransitionMock = this.sinonSandbox.stub().resolves(identityCreateTransition);
+
+    validatePublicKeySignatures = validatePublicKeySignaturesFactory(createStateTransitionMock);
+  });
+
+  it('should return InvalidIdentityKeySignatureError if signature is not valid', async () => {
+    const rawPublicKey2 = rawIdentityCreateTransition.publicKeys[1];
+
+    rawPublicKey2.signature = crypto.randomBytes(65);
+
+    const result = await validatePublicKeySignatures(
+      rawIdentityCreateTransition,
+      rawIdentityCreateTransition.publicKeys,
+      identityCreateTransition.getExecutionContext(),
+    );
+
+    expectValidationError(result, InvalidIdentityKeySignatureError);
+
+    const error = result.getFirstError();
+
+    expect(error.getPublicKeyId()).to.equals(rawPublicKey2.id);
+  });
+
+  it('should return valid result', async () => {
+    const result = await validatePublicKeySignatures(
+      rawIdentityCreateTransition,
+      rawIdentityCreateTransition.publicKeys,
+      identityCreateTransition.getExecutionContext(),
+    );
+
+    expect(result).to.be.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+  });
+});

package/test/integration/identity/validation/validateIdentityFactory.spec.js

@@ -0,0 +1,370 @@
+const { getRE2Class } = require('@dashevo/wasm-re2');
+
+const createAjv = require('../../../../lib/ajv/createAjv');
+
+const getIdentityFixture = require('../../../../lib/test/fixtures/getIdentityFixture');
+
+const JsonSchemaValidator = require(
+  '../../../../lib/validation/JsonSchemaValidator',
+);
+
+const { expectValidationError, expectJsonSchemaError } = require(
+  '../../../../lib/test/expect/expectError',
+);
+
+const validateIdentityFactory = require(
+  '../../../../lib/identity/validation/validateIdentityFactory',
+);
+
+const JsonSchemaError = require(
+  '../../../../lib/errors/consensus/basic/JsonSchemaError',
+);
+
+const ValidationResult = require('../../../../lib/validation/ValidationResult');
+const SomeConsensusError = require('../../../../lib/test/mocks/SomeConsensusError');
+
+describe('validateIdentityFactory', () => {
+  let rawIdentity;
+  let validateIdentity;
+  let identity;
+  let validatePublicKeysMock;
+  let validateProtocolVersionMock;
+
+  beforeEach(async function beforeEach() {
+    const RE2 = await getRE2Class();
+    const ajv = createAjv(RE2);
+
+    const schemaValidator = new JsonSchemaValidator(ajv);
+
+    validatePublicKeysMock = this.sinonSandbox.stub().returns(new ValidationResult());
+
+    validateProtocolVersionMock = this.sinonSandbox.stub().returns(new ValidationResult());
+
+    validateIdentity = validateIdentityFactory(
+      schemaValidator,
+      validatePublicKeysMock,
+      validateProtocolVersionMock,
+    );
+
+    identity = getIdentityFixture();
+
+    rawIdentity = identity.toObject();
+  });
+
+  describe('protocolVersion', () => {
+    it('should be present', async () => {
+      delete rawIdentity.protocolVersion;
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getInstancePath()).to.equal('');
+      expect(error.getKeyword()).to.equal('required');
+      expect(error.getParams().missingProperty).to.equal('protocolVersion');
+    });
+
+    it('should be an integer', async () => {
+      rawIdentity.protocolVersion = '1';
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getInstancePath()).to.equal('/protocolVersion');
+      expect(error.getKeyword()).to.equal('type');
+    });
+
+    it('should be valid', async () => {
+      rawIdentity.protocolVersion = -1;
+
+      const protocolVersionError = new SomeConsensusError('test');
+      const protocolVersionResult = new ValidationResult([
+        protocolVersionError,
+      ]);
+
+      validateProtocolVersionMock.returns(protocolVersionResult);
+
+      const result = validateIdentity(rawIdentity);
+
+      expectValidationError(result, SomeConsensusError);
+
+      const [error] = result.getErrors();
+
+      expect(error).to.equal(protocolVersionError);
+
+      expect(validateProtocolVersionMock).to.be.calledOnceWith(
+        rawIdentity.protocolVersion,
+      );
+    });
+  });
+
+  describe('id', () => {
+    it('should be present', () => {
+      rawIdentity.id = undefined;
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getInstancePath()).to.equal('');
+      expect(error.getParams().missingProperty).to.equal('id');
+      expect(error.getKeyword()).to.equal('required');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+    });
+
+    it('should be a byte array', () => {
+      rawIdentity.id = new Array(32).fill('string');
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result, 2);
+
+      const [error, byteArrayError] = result.getErrors();
+
+      expect(error.getInstancePath()).to.equal('/id/0');
+      expect(error.getKeyword()).to.equal('type');
+
+      expect(byteArrayError.getKeyword()).to.equal('byteArray');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+    });
+
+    it('should not be less than 32 bytes', () => {
+      rawIdentity.id = Buffer.alloc(31);
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getKeyword()).to.equal('minItems');
+      expect(error.getInstancePath()).to.equal('/id');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+    });
+
+    it('should not be more than 32 bytes', () => {
+      rawIdentity.id = Buffer.alloc(33);
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getKeyword()).to.equal('maxItems');
+      expect(error.getInstancePath()).to.equal('/id');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+    });
+  });
+
+  describe('balance', () => {
+    it('should be present', async () => {
+      rawIdentity.balance = undefined;
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getInstancePath()).to.equal('');
+      expect(error.getParams().missingProperty).to.equal('balance');
+      expect(error.getKeyword()).to.equal('required');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+    });
+
+    it('should be an integer', async () => {
+      rawIdentity.balance = 1.2;
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getKeyword()).to.equal('type');
+      expect(error.getInstancePath()).to.equal('/balance');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+    });
+
+    it('should be greater or equal 0', async () => {
+      rawIdentity.balance = -1;
+
+      let result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getKeyword()).to.equal('minimum');
+      expect(error.getInstancePath()).to.equal('/balance');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+
+      rawIdentity.balance = 0;
+
+      result = validateIdentity(rawIdentity);
+
+      expect(result.isValid()).to.be.true();
+    });
+  });
+
+  describe('publicKeys', () => {
+    it('should be present', () => {
+      rawIdentity.publicKeys = undefined;
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getInstancePath()).to.equal('');
+      expect(error.getParams().missingProperty).to.equal('publicKeys');
+      expect(error.getKeyword()).to.equal('required');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+    });
+
+    it('should be an array', () => {
+      rawIdentity.publicKeys = 1;
+
+      const result = validateIdentity(rawIdentity);
+
+      expectValidationError(result, JsonSchemaError, 1);
+
+      const [error] = result.getErrors();
+
+      expect(error.getCode()).to.equal(1005);
+      expect(error.getInstancePath()).to.equal('/publicKeys');
+      expect(error.getKeyword()).to.equal('type');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+    });
+
+    it('should not be empty', () => {
+      rawIdentity.publicKeys = [];
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getKeyword()).to.equal('minItems');
+      expect(error.getInstancePath()).to.equal('/publicKeys');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+    });
+
+    it('should be unique', async () => {
+      rawIdentity.publicKeys.push(rawIdentity.publicKeys[0]);
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getKeyword()).to.equal('uniqueItems');
+      expect(error.getInstancePath()).to.equal('/publicKeys');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+    });
+
+    it('should throw an error if publicKeys have more than 100 keys', () => {
+      const [key] = rawIdentity.publicKeys;
+
+      rawIdentity.publicKeys = [];
+      for (let i = 0; i < 101; i++) {
+        rawIdentity.publicKeys.push(key);
+      }
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getKeyword()).to.equal('maxItems');
+      expect(error.getInstancePath()).to.equal('/publicKeys');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+    });
+  });
+
+  describe('revision', () => {
+    it('should be present', async () => {
+      rawIdentity.revision = undefined;
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getInstancePath()).to.equal('');
+      expect(error.getParams().missingProperty).to.equal('revision');
+      expect(error.getKeyword()).to.equal('required');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+    });
+
+    it('should be an integer', async () => {
+      rawIdentity.revision = 1.2;
+
+      const result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getKeyword()).to.equal('type');
+      expect(error.getInstancePath()).to.equal('/revision');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+    });
+
+    it('should be greater or equal 0', async () => {
+      rawIdentity.revision = -1;
+
+      let result = validateIdentity(rawIdentity);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.getKeyword()).to.equal('minimum');
+      expect(error.getInstancePath()).to.equal('/revision');
+
+      expect(validatePublicKeysMock).to.not.be.called();
+
+      rawIdentity.revision = 0;
+
+      result = validateIdentity(rawIdentity);
+
+      expect(result.isValid()).to.be.true();
+    });
+  });
+
+  it('should return valid result if a raw identity is valid', () => {
+    const result = validateIdentity(rawIdentity);
+
+    expect(validatePublicKeysMock).to.be.calledOnceWithExactly(rawIdentity.publicKeys);
+
+    expect(result.isValid()).to.be.true();
+  });
+});