@dashevo/wasm-dpp 0.23.0-dev.10

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

@@ -0,0 +1,274 @@
+const { PublicKey } = require('@dashevo/dashcore-lib');
+const Identity = require('../../../lib/identity/Identity');
+const IdentityCreateTransition = require('../../../lib/identity/stateTransition/IdentityCreateTransition/IdentityCreateTransition');
+const IdentityTopUpTransition = require('../../../lib/identity/stateTransition/IdentityTopUpTransition/IdentityTopUpTransition');
+
+const getIdentityFixture = require('../../../lib/test/fixtures/getIdentityFixture');
+
+const ValidationResult = require('../../../lib/validation/ValidationResult');
+const SerializedObjectParsingError = require('../../../lib/errors/consensus/basic/decode/SerializedObjectParsingError');
+
+const InvalidIdentityError = require(
+  '../../../lib/identity/errors/InvalidIdentityError',
+);
+const getInstantAssetLockProofFixture = require('../../../lib/test/fixtures/getInstantAssetLockProofFixture');
+const InstantAssetLockProof = require('../../../lib/identity/stateTransition/assetLockProof/instant/InstantAssetLockProof');
+const getChainAssetLockProofFixture = require('../../../lib/test/fixtures/getChainAssetLockProofFixture');
+const createDPPMock = require('../../../lib/test/mocks/createDPPMock');
+const SomeConsensusError = require('../../../lib/test/mocks/SomeConsensusError');
+const IdentityFactory = require('../../../lib/identity/IdentityFactory');
+const IdentityUpdateTransition = require('../../../lib/identity/stateTransition/IdentityUpdateTransition/IdentityUpdateTransition');
+const IdentityPublicKey = require('../../../lib/identity/IdentityPublicKey');
+
+describe('IdentityFactory', () => {
+  let factory;
+  let validateIdentityMock;
+  let decodeProtocolEntityMock;
+  let identity;
+  let instantAssetLockProof;
+  let chainAssetLockProof;
+  let dppMock;
+  let fakeTime;
+
+  beforeEach(function beforeEach() {
+    validateIdentityMock = this.sinonSandbox.stub();
+    decodeProtocolEntityMock = this.sinonSandbox.stub();
+
+    instantAssetLockProof = getInstantAssetLockProofFixture();
+    chainAssetLockProof = getChainAssetLockProofFixture();
+
+    dppMock = createDPPMock();
+
+    factory = new IdentityFactory(
+      dppMock,
+      validateIdentityMock,
+      decodeProtocolEntityMock,
+    );
+
+    identity = getIdentityFixture();
+    identity.id = instantAssetLockProof.createIdentifier();
+    identity.setAssetLockProof(instantAssetLockProof);
+    identity.setBalance(0);
+
+    fakeTime = this.sinonSandbox.useFakeTimers(new Date());
+  });
+
+  afterEach(() => {
+    fakeTime.reset();
+  });
+
+  describe('#constructor', () => {
+    it('should set validator', () => {
+      expect(factory.validateIdentity).to.equal(validateIdentityMock);
+    });
+  });
+
+  describe('#create', () => {
+    it('should create Identity from asset lock transaction, output index, proof and public keys', () => {
+      const publicKeys = identity
+        .getPublicKeys()
+        .map((identityPublicKey) => ({
+          ...identityPublicKey.toObject(),
+          key: new PublicKey(identityPublicKey.getData()),
+          readonly: true,
+        }));
+
+      const result = factory.create(
+        instantAssetLockProof,
+        publicKeys,
+      );
+
+      expect(result).to.be.an.instanceOf(Identity);
+      expect(result.toObject()).to.deep.equal(identity.toObject());
+    });
+  });
+
+  describe('#createFromObject', () => {
+    it('should skip validation if options is set', () => {
+      factory.createFromObject({}, { skipValidation: true });
+
+      expect(validateIdentityMock).to.have.not.been.called();
+    });
+
+    it('should throw an error if validation have failed', () => {
+      const errors = [new SomeConsensusError('error')];
+
+      validateIdentityMock.returns(new ValidationResult(errors));
+
+      try {
+        factory.createFromObject(identity.toObject());
+
+        expect.fail('error was not thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(InvalidIdentityError);
+        expect(e.getErrors()).to.have.deep.members(errors);
+        expect(e.getRawIdentity()).to.deep.equal(identity.toObject());
+      }
+    });
+
+    it('should create an identity if validation passed', () => {
+      validateIdentityMock.returns(new ValidationResult());
+
+      const result = factory.createFromObject(identity.toObject());
+
+      expect(result).to.be.an.instanceOf(Identity);
+      expect(result.toObject()).to.deep.equal(identity.toObject());
+    });
+  });
+
+  describe('#createFromBuffer', () => {
+    let serializedIdentity;
+    let rawIdentity;
+
+    beforeEach(function beforeEach() {
+      this.sinonSandbox.stub(factory, 'createFromObject');
+
+      serializedIdentity = identity.toBuffer();
+      rawIdentity = identity.toObject();
+    });
+
+    afterEach(() => {
+      factory.createFromObject.restore();
+    });
+
+    it('should return new Identity from serialized one', () => {
+      decodeProtocolEntityMock.returns([rawIdentity.protocolVersion, rawIdentity]);
+
+      factory.createFromObject.returns(identity);
+
+      const result = factory.createFromBuffer(serializedIdentity);
+
+      expect(result).to.equal(identity);
+
+      expect(factory.createFromObject).to.have.been.calledOnceWith(rawIdentity);
+
+      expect(decodeProtocolEntityMock).to.have.been.calledOnceWithExactly(
+        serializedIdentity,
+      );
+    });
+
+    it('should throw InvalidIdentityError if the decoding fails with consensus error', () => {
+      const parsingError = new SerializedObjectParsingError(
+        serializedIdentity,
+        new Error(),
+      );
+
+      decodeProtocolEntityMock.throws(parsingError);
+
+      try {
+        factory.createFromBuffer(serializedIdentity);
+
+        expect.fail('should throw InvalidIdentityError');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(InvalidIdentityError);
+
+        const [innerError] = e.getErrors();
+        expect(innerError).to.equal(parsingError);
+      }
+    });
+
+    it('should throw an error if decoding fails with any other error', () => {
+      const parsingError = new Error('Something failed during parsing');
+
+      decodeProtocolEntityMock.throws(parsingError);
+
+      try {
+        factory.createFromBuffer(serializedIdentity);
+
+        expect.fail('should throw an error');
+      } catch (e) {
+        expect(e).to.equal(parsingError);
+      }
+    });
+  });
+
+  describe('#createInstantAssetLockProof', () => {
+    it('should create instant asset lock proof from InstantLock', () => {
+      const instantLock = instantAssetLockProof.getInstantLock();
+      const assetLockTransaction = instantAssetLockProof.getTransaction();
+      const outputIndex = instantAssetLockProof.getOutputIndex();
+
+      const result = factory.createInstantAssetLockProof(
+        instantLock,
+        assetLockTransaction,
+        outputIndex,
+      );
+
+      expect(result).to.be.instanceOf(InstantAssetLockProof);
+      expect(result.getInstantLock()).to.deep.equal(instantLock);
+    });
+  });
+
+  describe('#createIdentityCreateTransition', () => {
+    it('should create IdentityCreateTransition from Identity model', () => {
+      const stateTransition = factory.createIdentityCreateTransition(identity);
+
+      expect(stateTransition).to.be.instanceOf(IdentityCreateTransition);
+      expect(stateTransition.getPublicKeys()).to.deep.equal(identity.getPublicKeys());
+      expect(stateTransition.getAssetLockProof().toObject())
+        .to.deep.equal(instantAssetLockProof.toObject());
+    });
+  });
+
+  describe('createChainAssetLockProof', () => {
+    it('should create IdentityCreateTransition from Identity model', () => {
+      identity = getIdentityFixture();
+      identity.id = chainAssetLockProof.createIdentifier();
+      identity.setAssetLockProof(chainAssetLockProof);
+      identity.setBalance(0);
+
+      const stateTransition = factory.createIdentityCreateTransition(identity);
+
+      expect(stateTransition).to.be.instanceOf(IdentityCreateTransition);
+      expect(stateTransition.getPublicKeys()).deep.to.equal(identity.getPublicKeys());
+      expect(stateTransition.getAssetLockProof().toObject())
+        .to.deep.equal(chainAssetLockProof.toObject());
+    });
+  });
+
+  describe('#createIdentityTopUpTransition', () => {
+    it('should create IdentityTopUpTransition from identity id and outpoint', () => {
+      const stateTransition = factory
+        .createIdentityTopUpTransition(
+          identity.getId(),
+          instantAssetLockProof,
+        );
+
+      expect(stateTransition).to.be.instanceOf(IdentityTopUpTransition);
+      expect(stateTransition.getIdentityId()).to.deep.equal(identity.getId());
+      expect(stateTransition.getAssetLockProof().toObject())
+        .to.deep.equal(instantAssetLockProof.toObject());
+    });
+  });
+
+  describe('createIdentityUpdateTransition', () => {
+    it('should create IdentityUpdateTransition', () => {
+      const revision = 1;
+      const disablePublicKeys = [identity.getPublicKeyById(0)];
+      const addPublicKeys = [new IdentityPublicKey({
+        id: 0,
+        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+        data: Buffer.from('AuryIuMtRrl/VviQuyLD1l4nmxi9ogPzC9LT7tdpo0di', 'base64'),
+        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+        readOnly: false,
+      })];
+
+      const stateTransition = factory
+        .createIdentityUpdateTransition(
+          identity,
+          {
+            add: addPublicKeys,
+            disable: disablePublicKeys,
+          },
+        );
+
+      expect(stateTransition).to.be.instanceOf(IdentityUpdateTransition);
+      expect(stateTransition.getIdentityId()).to.deep.equal(identity.getId());
+      expect(stateTransition.getRevision()).to.deep.equal(revision);
+      expect(stateTransition.getPublicKeysToAdd()).to.deep.equal(addPublicKeys);
+      expect(stateTransition.getPublicKeyIdsToDisable()).to.deep.equal([0]);
+      expect(stateTransition.getPublicKeysDisabledAt()).to.deep.equal(new Date());
+    });
+  });
+});

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

@@ -0,0 +1,273 @@
+const IdentityPublicKey = require('../../../lib/identity/IdentityPublicKey');
+const EmptyPublicKeyDataError = require('../../../lib/identity/errors/EmptyPublicKeyDataError');
+
+describe('IdentityPublicKey', () => {
+  let rawPublicKey;
+  let publicKey;
+
+  beforeEach(() => {
+    rawPublicKey = {
+      id: 0,
+      type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+      data: Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'),
+      purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+      securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+      readOnly: false,
+    };
+
+    publicKey = new IdentityPublicKey(rawPublicKey);
+  });
+
+  describe('#constructor', () => {
+    it('should not set anything if nothing passed', () => {
+      const instance = new IdentityPublicKey();
+
+      expect(instance.id).to.be.undefined();
+      expect(instance.type).to.be.undefined();
+      expect(instance.data).to.be.undefined();
+    });
+
+    it('should set variables from raw model', () => {
+      const instance = new IdentityPublicKey(rawPublicKey);
+
+      expect(instance.id).to.equal(rawPublicKey.id);
+      expect(instance.type).to.equal(rawPublicKey.type);
+      expect(instance.data).to.equal(rawPublicKey.data);
+    });
+  });
+
+  describe('#getId', () => {
+    it('should return set id', () => {
+      expect(publicKey.getId()).to.equal(rawPublicKey.id);
+    });
+  });
+
+  describe('#setId', () => {
+    it('should set id', () => {
+      publicKey.setId(42);
+
+      expect(publicKey.id).to.equal(42);
+    });
+  });
+
+  describe('#getType', () => {
+    it('should return set type', () => {
+      publicKey.type = 42;
+
+      expect(publicKey.getType()).to.equal(42);
+    });
+  });
+
+  describe('#setType', () => {
+    it('should set type', () => {
+      publicKey.setType(42);
+
+      expect(publicKey.type).to.equal(42);
+    });
+  });
+
+  describe('#getData', () => {
+    it('should return set data', () => {
+      expect(publicKey.getData()).to.equal(rawPublicKey.data);
+    });
+  });
+
+  describe('#setData', () => {
+    it('should set data', () => {
+      const buffer = Buffer.alloc(36);
+
+      publicKey.setData(buffer);
+
+      expect(publicKey.data).to.equal(buffer);
+    });
+  });
+
+  describe('#getPurpose', () => {
+    it('should return set data', () => {
+      expect(publicKey.getPurpose()).to.equal(rawPublicKey.purpose);
+    });
+  });
+
+  describe('#setPurpose', () => {
+    it('should set data', () => {
+      publicKey.setPurpose(IdentityPublicKey.PURPOSES.DECRYPTION);
+
+      expect(publicKey.purpose).to.equal(IdentityPublicKey.PURPOSES.DECRYPTION);
+    });
+  });
+
+  describe('#getSecurityLevel', () => {
+    it('should return set data', () => {
+      expect(publicKey.getSecurityLevel()).to.equal(rawPublicKey.securityLevel);
+    });
+  });
+
+  describe('#setSecurityLevel', () => {
+    it('should set data', () => {
+      publicKey.setSecurityLevel(IdentityPublicKey.SECURITY_LEVELS.MEDIUM);
+
+      expect(publicKey.securityLevel).to.equal(IdentityPublicKey.SECURITY_LEVELS.MEDIUM);
+    });
+  });
+
+  describe('#isReadOnly', () => {
+    it('should return readOnly', () => {
+      expect(publicKey.isReadOnly()).to.equal(rawPublicKey.readOnly);
+    });
+  });
+
+  describe('#setReadOnly', () => {
+    it('should set readOnly', () => {
+      publicKey.setReadOnly(true);
+
+      expect(publicKey.readOnly).to.equal(true);
+    });
+  });
+
+  describe('#setDisabledAt', () => {
+    it('should set disabledAt', () => {
+      publicKey.setDisabledAt(123);
+
+      expect(publicKey.disabledAt).to.equal(123);
+    });
+  });
+
+  describe('#getDisabledAt', () => {
+    it('should return disabledAt', () => {
+      publicKey.disabledAt = 42;
+
+      expect(publicKey.getDisabledAt()).to.equal(42);
+    });
+  });
+
+  describe('#hash', () => {
+    it('should return original public key hash', () => {
+      const result = publicKey.hash();
+
+      const expectedHash = Buffer.from('Q/5mfilFPdZt+Fr5JWC1+tg0cPs=', 'base64');
+
+      expect(result).to.deep.equal(expectedHash);
+    });
+
+    it('should return data in case ECDSA_HASH160', () => {
+      rawPublicKey = {
+        id: 0,
+        type: IdentityPublicKey.TYPES.ECDSA_HASH160,
+        data: Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'),
+        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+      };
+
+      publicKey = new IdentityPublicKey(rawPublicKey);
+
+      const result = publicKey.hash();
+
+      const expectedHash = Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64');
+
+      expect(result).to.deep.equal(expectedHash);
+    });
+
+    it('should return original public key hash in case BLS12_381', () => {
+      rawPublicKey = {
+        id: 0,
+        type: IdentityPublicKey.TYPES.BLS12_381,
+        data: Buffer.from('01fac99ca2c8f39c286717c213e190aba4b7af76db320ec43f479b7d9a2012313a0ae59ca576edf801444bc694686694', 'hex'),
+        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+      };
+
+      publicKey = new IdentityPublicKey(rawPublicKey);
+
+      const result = publicKey.hash();
+
+      const expectedHash = Buffer.from('1de31a0a328e8822f9cb2c25141d7d80baee26ef', 'hex');
+
+      expect(result).to.deep.equal(expectedHash);
+    });
+
+    it('should return data in case BIP13_SCRIPT_HASH', () => {
+      rawPublicKey = {
+        id: 0,
+        type: IdentityPublicKey.TYPES.BIP13_SCRIPT_HASH,
+        data: Buffer.from('54c557e07dde5bb6cb791c7a540e0a4796f5e97e', 'hex'),
+        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+      };
+
+      publicKey = new IdentityPublicKey(rawPublicKey);
+
+      const result = publicKey.hash();
+
+      const expectedHash = Buffer.from('54c557e07dde5bb6cb791c7a540e0a4796f5e97e', 'hex');
+
+      expect(result).to.deep.equal(expectedHash);
+    });
+
+    it('should throw invalid argument error if data was not originally provided', async () => {
+      publicKey = new IdentityPublicKey({
+        id: 0,
+        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+      });
+
+      try {
+        publicKey.hash();
+
+        expect.fail('Error was not thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(EmptyPublicKeyDataError);
+        expect(e.message).to.equal(
+          'Public key data is not set',
+        );
+      }
+    });
+  });
+
+  describe('#toJSON', () => {
+    it('should return JSON representation', () => {
+      const jsonPublicKey = publicKey.toJSON();
+
+      expect(jsonPublicKey).to.deep.equal({
+        id: 0,
+        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+        data: 'AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH',
+        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+        readOnly: false,
+      });
+    });
+
+    it('should return JSON representation with optional properties', () => {
+      publicKey.setDisabledAt(42);
+
+      const jsonPublicKey = publicKey.toJSON();
+
+      expect(jsonPublicKey).to.deep.equal({
+        id: 0,
+        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+        data: 'AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH',
+        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+        readOnly: false,
+        disabledAt: 42,
+      });
+    });
+  });
+
+  describe('#isMaster', () => {
+    it('should return true when public key has MASTER security level', () => {
+      publicKey.securityLevel = IdentityPublicKey.SECURITY_LEVELS.MASTER;
+
+      const result = publicKey.isMaster();
+
+      expect(result).to.be.true();
+    });
+
+    it('should return false when public key doesn\'t have MASTER security level', () => {
+      publicKey.securityLevel = IdentityPublicKey.SECURITY_LEVELS.HIGH;
+
+      const result = publicKey.isMaster();
+
+      expect(result).to.be.false();
+    });
+  });
+});

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

@@ -0,0 +1,34 @@
+const {
+  convertSatoshiToCredits,
+  convertCreditsToSatoshi,
+  RATIO,
+} = require('../../../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

@@ -0,0 +1,46 @@
+const InvalidIdentityError = require('../../../../lib/identity/errors/InvalidIdentityError');
+const getIdentityFixture = require('../../../../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`);
+  });
+});