@dashevo/wasm-dpp 0.23.0-dev.10

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

@@ -0,0 +1,184 @@
+const IdentityPublicKey = require('../../../../../lib/identity/IdentityPublicKey');
+
+const stateTransitionTypes = require(
+  '../../../../../lib/stateTransition/stateTransitionTypes',
+);
+
+const protocolVersion = require('../../../../../lib/version/protocolVersion');
+const IdentityCreateTransition = require('../../../../../lib/identity/stateTransition/IdentityCreateTransition/IdentityCreateTransition');
+const Identifier = require('../../../../../lib/identifier/Identifier');
+
+const getIdentityCreateTransitionFixture = require('../../../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
+const InstantAssetLockProof = require('../../../../../lib/identity/stateTransition/assetLockProof/instant/InstantAssetLockProof');
+
+describe('IdentityCreateTransition', () => {
+  let rawStateTransition;
+  let stateTransition;
+
+  beforeEach(() => {
+    stateTransition = getIdentityCreateTransitionFixture();
+    rawStateTransition = stateTransition.toObject();
+  });
+
+  describe('#constructor', () => {
+    it('should create an instance with specified data', () => {
+      expect(stateTransition.getAssetLockProof().toObject()).to.deep.equal(
+        rawStateTransition.assetLockProof,
+      );
+
+      expect(stateTransition.publicKeys).to.deep.equal([
+        new IdentityPublicKey(rawStateTransition.publicKeys[0]),
+      ]);
+    });
+  });
+
+  describe('#getType', () => {
+    it('should return IDENTITY_CREATE type', () => {
+      expect(stateTransition.getType()).to.equal(stateTransitionTypes.IDENTITY_CREATE);
+    });
+  });
+
+  describe('#setAssetLockProof', () => {
+    it('should set asset lock proof', () => {
+      stateTransition.setAssetLockProof(
+        new InstantAssetLockProof(rawStateTransition.assetLockProof),
+      );
+
+      expect(stateTransition.assetLockProof.toObject())
+        .to.deep.equal(rawStateTransition.assetLockProof);
+    });
+
+    it('should set `identityId`', () => {
+      stateTransition.setAssetLockProof(
+        new InstantAssetLockProof(rawStateTransition.assetLockProof),
+      );
+
+      expect(stateTransition.identityId).to.deep.equal(
+        stateTransition.getAssetLockProof().createIdentifier(),
+      );
+    });
+  });
+
+  describe('#getAssetLockProof', () => {
+    it('should return currently set locked OutPoint', () => {
+      expect(stateTransition.getAssetLockProof().toObject()).to.deep.equal(
+        rawStateTransition.assetLockProof,
+      );
+    });
+  });
+
+  describe('#setPublicKeys', () => {
+    it('should set public keys', () => {
+      const publicKeys = [new IdentityPublicKey(), new IdentityPublicKey()];
+
+      stateTransition.setPublicKeys(publicKeys);
+
+      expect(stateTransition.publicKeys).to.have.deep.members(publicKeys);
+    });
+  });
+
+  describe('#getPublicKeys', () => {
+    it('should return set public keys', () => {
+      expect(stateTransition.getPublicKeys()).to.deep.equal(
+        rawStateTransition.publicKeys.map((rawPublicKey) => new IdentityPublicKey(rawPublicKey)),
+      );
+    });
+  });
+
+  describe('#addPublicKeys', () => {
+    it('should add more public keys', () => {
+      const publicKeys = [new IdentityPublicKey(), new IdentityPublicKey()];
+
+      stateTransition.publicKeys = [];
+      stateTransition.addPublicKeys(publicKeys);
+      expect(stateTransition.getPublicKeys()).to.have.deep.members(publicKeys);
+    });
+  });
+
+  describe('#getIdentityId', () => {
+    it('should return identity id', () => {
+      expect(stateTransition.getIdentityId()).to.deep.equal(
+        stateTransition.getAssetLockProof().createIdentifier(),
+      );
+    });
+  });
+
+  describe('#getOwnerId', () => {
+    it('should return owner id', () => {
+      expect(stateTransition.getOwnerId()).to.equal(
+        stateTransition.getIdentityId(),
+      );
+    });
+  });
+
+  describe('#toObject', () => {
+    it('should return raw state transition', () => {
+      rawStateTransition = stateTransition.toObject();
+
+      expect(rawStateTransition).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.IDENTITY_CREATE,
+        assetLockProof: rawStateTransition.assetLockProof,
+        publicKeys: rawStateTransition.publicKeys,
+        signature: undefined,
+      });
+    });
+
+    it('should return raw state transition without signature', () => {
+      rawStateTransition = stateTransition.toObject({ skipSignature: true });
+
+      expect(rawStateTransition).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.IDENTITY_CREATE,
+        assetLockProof: rawStateTransition.assetLockProof,
+        publicKeys: rawStateTransition.publicKeys,
+      });
+    });
+  });
+
+  describe('#toJSON', () => {
+    it('should return JSON representation of state transition', () => {
+      const jsonStateTransition = stateTransition.toJSON();
+
+      expect(jsonStateTransition).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.IDENTITY_CREATE,
+        assetLockProof: stateTransition.getAssetLockProof().toJSON(),
+        publicKeys: stateTransition.getPublicKeys().map((k) => k.toJSON()),
+        signature: undefined,
+      });
+    });
+  });
+
+  describe('#getModifiedDataIds', () => {
+    it('should return ids of created identities', () => {
+      const result = stateTransition.getModifiedDataIds();
+
+      expect(result.length).to.be.equal(1);
+      const identityId = result[0];
+
+      expect(identityId).to.be.an.instanceOf(Identifier);
+      expect(identityId).to.be.deep.equal(
+        new IdentityCreateTransition(rawStateTransition).getIdentityId(),
+      );
+    });
+  });
+
+  describe('#isDataContractStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransition.isDataContractStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isDocumentStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransition.isDocumentStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isIdentityStateTransition', () => {
+    it('should return true', () => {
+      expect(stateTransition.isIdentityStateTransition()).to.be.true();
+    });
+  });
+});

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

@@ -0,0 +1,90 @@
+const Identity = require('../../../../../lib/identity/Identity');
+
+const applyIdentityCreateTransitionFactory = require(
+  '../../../../../lib/identity/stateTransition/IdentityCreateTransition/applyIdentityCreateTransitionFactory',
+);
+
+const getIdentityCreateTransitionFixture = require('../../../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
+
+const { convertSatoshiToCredits } = require('../../../../../lib/identity/creditsConverter');
+
+const createStateRepositoryMock = require('../../../../../lib/test/mocks/createStateRepositoryMock');
+
+const protocolVersion = require('../../../../../lib/version/protocolVersion');
+const StateTransitionExecutionContext = require('../../../../../lib/stateTransition/StateTransitionExecutionContext');
+const ReadOperation = require('../../../../../lib/stateTransition/fee/operations/ReadOperation');
+
+describe('applyIdentityCreateTransitionFactory', () => {
+  let stateTransition;
+  let applyIdentityCreateTransition;
+  let stateRepositoryMock;
+  let fetchAssetLockTransactionOutputMock;
+  let output;
+  let executionContext;
+
+  beforeEach(function beforeEach() {
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+
+    stateTransition = getIdentityCreateTransitionFixture();
+
+    executionContext = new StateTransitionExecutionContext();
+
+    stateTransition.setExecutionContext(executionContext);
+
+    output = stateTransition.getAssetLockProof().getOutput();
+
+    fetchAssetLockTransactionOutputMock = this.sinonSandbox.stub().resolves(output);
+
+    applyIdentityCreateTransition = applyIdentityCreateTransitionFactory(
+      stateRepositoryMock,
+      fetchAssetLockTransactionOutputMock,
+    );
+  });
+
+  it('should store identity created from state transition', async () => {
+    executionContext.addOperation(
+      new ReadOperation(1),
+    );
+
+    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()),
+      balance,
+      revision: 0,
+    });
+
+    expect(stateRepositoryMock.createIdentity).to.have.been.calledOnceWithExactly(
+      identity,
+      executionContext,
+    );
+
+    const publicKeyHashes = identity
+      .getPublicKeys()
+      .map((publicKey) => publicKey.hash());
+
+    expect(stateRepositoryMock.storeIdentityPublicKeyHashes).to.have.been.calledOnceWithExactly(
+      identity.getId(),
+      publicKeyHashes,
+      executionContext,
+    );
+
+    expect(stateRepositoryMock.markAssetLockTransactionOutPointAsUsed).to.have.been
+      .calledOnceWithExactly(
+        stateTransition.getAssetLockProof().getOutPoint(),
+        executionContext,
+      );
+
+    expect(fetchAssetLockTransactionOutputMock)
+      .to.be.calledOnceWithExactly(
+        stateTransition.getAssetLockProof(),
+        executionContext,
+      );
+  });
+});

package/test/unit/identity/stateTransition/IdentityCreateTransition/validation/state/validateIdentityCreateTransitionStateFactory.spec.js

@@ -0,0 +1,71 @@
+const { expectValidationError } = require(
+  '../../../../../../../lib/test/expect/expectError',
+);
+
+const validateIdentityCreateTransitionStateFactory = require(
+  '../../../../../../../lib/identity/stateTransition/IdentityCreateTransition/validation/state/validateIdentityCreateTransitionStateFactory',
+);
+
+const getIdentityCreateTransitionFixture = require('../../../../../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
+
+const IdentityAlreadyExistsError = require(
+  '../../../../../../../lib/errors/consensus/state/identity/IdentityAlreadyExistsError',
+);
+
+const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/createStateRepositoryMock');
+const IdentityPublicKey = require('../../../../../../../lib/identity/IdentityPublicKey');
+
+describe('validateIdentityCreateTransitionStateFactory', () => {
+  let validateIdentityCreateTransitionState;
+  let stateTransition;
+  let stateRepositoryMock;
+
+  beforeEach(async function beforeEach() {
+    const privateKey = 'af432c476f65211f45f48f1d42c9c0b497e56696aa1736b40544ef1a496af837';
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+
+    validateIdentityCreateTransitionState = validateIdentityCreateTransitionStateFactory(
+      stateRepositoryMock,
+    );
+
+    stateTransition = getIdentityCreateTransitionFixture();
+
+    await stateTransition.signByPrivateKey(privateKey, IdentityPublicKey.TYPES.ECDSA_SECP256K1);
+
+    const rawTransaction = '030000000137feb5676d0851337ea3c9a992496aab7a0b3eee60aeeb9774000b7f4bababa5000000006b483045022100d91557de37645c641b948c6cd03b4ae3791a63a650db3e2fee1dcf5185d1b10402200e8bd410bf516ca61715867666d31e44495428ce5c1090bf2294a829ebcfa4ef0121025c3cc7fbfc52f710c941497fd01876c189171ea227458f501afcb38a297d65b4ffffffff021027000000000000166a14152073ca2300a86b510fa2f123d3ea7da3af68dcf77cb0090a0000001976a914152073ca2300a86b510fa2f123d3ea7da3af68dc88ac00000000';
+
+    stateRepositoryMock.fetchTransaction.resolves(rawTransaction);
+  });
+
+  it('should return invalid result if identity already exists', async () => {
+    stateRepositoryMock.fetchIdentity.resolves({});
+
+    const result = await validateIdentityCreateTransitionState(stateTransition);
+
+    expectValidationError(result, IdentityAlreadyExistsError, 1);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(4011);
+    expect(Buffer.isBuffer(error.getIdentityId())).to.be.true();
+    expect(error.getIdentityId()).to.deep.equal(stateTransition.getIdentityId());
+  });
+
+  it('should return valid result if state transition is valid', async () => {
+    const result = await validateIdentityCreateTransitionState(stateTransition);
+
+    expect(result.isValid()).to.be.true();
+  });
+
+  it('should return valid result on dry run', async () => {
+    stateRepositoryMock.fetchIdentity.resolves({});
+
+    stateTransition.getExecutionContext().enableDryRun();
+
+    const result = await validateIdentityCreateTransitionState(stateTransition);
+
+    stateTransition.getExecutionContext().disableDryRun();
+
+    expect(result.isValid()).to.be.true();
+  });
+});

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

@@ -0,0 +1,137 @@
+const stateTransitionTypes = require(
+  '../../../../../lib/stateTransition/stateTransitionTypes',
+);
+
+const Identifier = require('../../../../../lib/identifier/Identifier');
+
+const getIdentityTopUpTransitionFixture = require('../../../../../lib/test/fixtures/getIdentityTopUpTransitionFixture');
+
+const protocolVersion = require('../../../../../lib/version/protocolVersion');
+
+describe('IdentityTopUpTransition', () => {
+  let rawStateTransition;
+  let stateTransition;
+
+  beforeEach(() => {
+    stateTransition = getIdentityTopUpTransitionFixture();
+    rawStateTransition = stateTransition.toObject();
+  });
+
+  describe('#constructor', () => {
+    it('should create an instance with specified data from specified raw transition', () => {
+      expect(stateTransition.getAssetLockProof().toObject()).to.be.deep.equal(
+        rawStateTransition.assetLockProof,
+      );
+      expect(stateTransition.getIdentityId()).to.be.deep.equal(
+        rawStateTransition.identityId,
+      );
+    });
+  });
+
+  describe('#getType', () => {
+    it('should return IDENTITY_TOP_UP type', () => {
+      expect(stateTransition.getType()).to.equal(stateTransitionTypes.IDENTITY_TOP_UP);
+    });
+  });
+
+  describe('#setAssetLockProof', () => {
+    it('should set asset lock proof', () => {
+      stateTransition.setAssetLockProof(rawStateTransition.assetLockProof);
+
+      expect(stateTransition.assetLockProof).to.deep.equal(rawStateTransition.assetLockProof);
+    });
+  });
+
+  describe('#getAssetLock', () => {
+    it('should return currently set asset lock proof', () => {
+      expect(stateTransition.getAssetLockProof().toObject()).to.deep.equal(
+        rawStateTransition.assetLockProof,
+      );
+    });
+  });
+
+  describe('#getIdentityId', () => {
+    it('should return identity id', () => {
+      expect(stateTransition.getIdentityId()).to.deep.equal(
+        rawStateTransition.identityId,
+      );
+    });
+  });
+
+  describe('#getOwnerId', () => {
+    it('should return owner id', () => {
+      expect(stateTransition.getOwnerId()).to.deep.equal(
+        rawStateTransition.identityId,
+      );
+    });
+  });
+
+  describe('#toObject', () => {
+    it('should return raw state transition', () => {
+      rawStateTransition = stateTransition.toObject();
+
+      expect(rawStateTransition).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.IDENTITY_TOP_UP,
+        assetLockProof: rawStateTransition.assetLockProof,
+        identityId: rawStateTransition.identityId,
+        signature: undefined,
+      });
+    });
+
+    it('should return raw state transition', () => {
+      rawStateTransition = stateTransition.toObject({ skipSignature: true });
+
+      expect(rawStateTransition).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.IDENTITY_TOP_UP,
+        assetLockProof: rawStateTransition.assetLockProof,
+        identityId: rawStateTransition.identityId,
+      });
+    });
+  });
+
+  describe('#toJSON', () => {
+    it('should return JSON representation of state transition', () => {
+      const jsonStateTransition = stateTransition.toJSON();
+
+      expect(jsonStateTransition).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.IDENTITY_TOP_UP,
+        assetLockProof: stateTransition.getAssetLockProof().toJSON(),
+        identityId: Identifier(rawStateTransition.identityId).toString(),
+        signature: undefined,
+      });
+    });
+  });
+
+  describe('#getModifiedDataIds', () => {
+    it('should return ids of topped up identity', () => {
+      const result = stateTransition.getModifiedDataIds();
+
+      expect(result.length).to.be.equal(1);
+      const identityId = result[0];
+
+      expect(identityId).to.be.an.instanceOf(Identifier);
+      expect(identityId).to.be.deep.equal(rawStateTransition.identityId);
+    });
+  });
+
+  describe('#isDataContractStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransition.isDataContractStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isDocumentStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransition.isDocumentStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isIdentityStateTransition', () => {
+    it('should return true', () => {
+      expect(stateTransition.isIdentityStateTransition()).to.be.true();
+    });
+  });
+});

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

@@ -0,0 +1,108 @@
+const applyIdentityTopUpTransitionFactory = require(
+  '../../../../../lib/identity/stateTransition/IdentityTopUpTransition/applyIdentityTopUpTransitionFactory',
+);
+
+const getIdentityFixture = require('../../../../../lib/test/fixtures/getIdentityFixture');
+const getIdentityTopUpTransitionFixture = require('../../../../../lib/test/fixtures/getIdentityTopUpTransitionFixture');
+
+const { convertSatoshiToCredits } = require('../../../../../lib/identity/creditsConverter');
+
+const createStateRepositoryMock = require('../../../../../lib/test/mocks/createStateRepositoryMock');
+const StateTransitionExecutionContext = require('../../../../../lib/stateTransition/StateTransitionExecutionContext');
+const getBiggestPossibleIdentity = require('../../../../../lib/identity/getBiggestPossibleIdentity');
+
+describe('applyIdentityTopUpTransitionFactory', () => {
+  let stateTransition;
+  let applyIdentityTopUpTransition;
+  let stateRepositoryMock;
+  let identity;
+  let fetchAssetLockTransactionOutputMock;
+  let executionContext;
+
+  beforeEach(function beforeEach() {
+    identity = getIdentityFixture();
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchIdentity.resolves(identity);
+
+    stateTransition = getIdentityTopUpTransitionFixture();
+
+    executionContext = new StateTransitionExecutionContext();
+
+    stateTransition.setExecutionContext(executionContext);
+
+    const output = stateTransition.getAssetLockProof().getOutput();
+
+    fetchAssetLockTransactionOutputMock = this.sinonSandbox.stub().resolves(output);
+
+    applyIdentityTopUpTransition = applyIdentityTopUpTransitionFactory(
+      stateRepositoryMock,
+      fetchAssetLockTransactionOutputMock,
+    );
+  });
+
+  it('should store identity created from state transition', async () => {
+    const balanceBeforeTopUp = identity.getBalance();
+
+    const balanceToTopUp = convertSatoshiToCredits(
+      stateTransition.getAssetLockProof().getOutput().satoshis,
+    );
+
+    await applyIdentityTopUpTransition(stateTransition);
+
+    expect(identity.getBalance()).to.be.equal(balanceBeforeTopUp + balanceToTopUp);
+    expect(identity.getBalance()).to.be.greaterThan(balanceBeforeTopUp);
+
+    expect(stateRepositoryMock.updateIdentity).to.have.been.calledOnceWithExactly(
+      identity,
+      executionContext,
+    );
+
+    expect(stateRepositoryMock.markAssetLockTransactionOutPointAsUsed).to.have.been
+      .calledOnceWithExactly(
+        stateTransition.getAssetLockProof().getOutPoint(),
+        executionContext,
+      );
+
+    expect(fetchAssetLockTransactionOutputMock)
+      .to.be.calledOnceWithExactly(
+        stateTransition.getAssetLockProof(),
+        executionContext,
+      );
+  });
+
+  it('should store biggest possible identity on dry run', async () => {
+    const biggestPossibleIdentity = getBiggestPossibleIdentity();
+
+    const balanceBeforeTopUp = biggestPossibleIdentity.getBalance();
+
+    const balanceToTopUp = convertSatoshiToCredits(
+      stateTransition.getAssetLockProof().getOutput().satoshis,
+    );
+
+    executionContext.enableDryRun();
+
+    await applyIdentityTopUpTransition(stateTransition);
+
+    executionContext.disableDryRun();
+
+    expect(biggestPossibleIdentity.getBalance()).to.be.equal(balanceBeforeTopUp + balanceToTopUp);
+
+    expect(stateRepositoryMock.updateIdentity).to.have.been.calledOnceWithExactly(
+      biggestPossibleIdentity,
+      executionContext,
+    );
+
+    expect(stateRepositoryMock.markAssetLockTransactionOutPointAsUsed).to.have.been
+      .calledOnceWithExactly(
+        stateTransition.getAssetLockProof().getOutPoint(),
+        executionContext,
+      );
+
+    expect(fetchAssetLockTransactionOutputMock)
+      .to.be.calledOnceWithExactly(
+        stateTransition.getAssetLockProof(),
+        executionContext,
+      );
+  });
+});

package/test/unit/identity/stateTransition/IdentityTopUpTransition/validation/state/validateIdentityTopUpTransitionStateFactory.spec.js

@@ -0,0 +1,22 @@
+const getIdentityTopUpTransitionFixture = require('../../../../../../../lib/test/fixtures/getIdentityTopUpTransitionFixture');
+
+const validateIdentityTopUpTransitionStateFactory = require(
+  '../../../../../../../lib/identity/stateTransition/IdentityTopUpTransition/validation/state/validateIdentityTopUpTransitionStateFactory',
+);
+
+describe('validateIdentityTopUpTransitionStateFactory', () => {
+  let validateIdentityTopUpTransitionState;
+  let stateTransition;
+
+  beforeEach(() => {
+    validateIdentityTopUpTransitionState = validateIdentityTopUpTransitionStateFactory();
+
+    stateTransition = getIdentityTopUpTransitionFixture();
+  });
+
+  it('should return valid result', async () => {
+    const result = await validateIdentityTopUpTransitionState(stateTransition);
+
+    expect(result.isValid()).to.be.true();
+  });
+});