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

package/test/unit/identity/stateTransition/IdentityUpdateTransition/applyIdentityUpdateTransitionFactory.spec.js

@@ -1,97 +1,77 @@
-const applyIdentityUpdateTransitionFactory = require('@dashevo/dpp/lib/identity/stateTransition/IdentityUpdateTransition/applyIdentityUpdateTransitionFactory');
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 const getIdentityUpdateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityUpdateTransitionFixture');
-const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
-const getBiggestPossibleIdentity = require('@dashevo/dpp/lib/identity/getBiggestPossibleIdentity');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('applyIdentityUpdateTransition', () => {
   let applyIdentityUpdateTransition;
   let stateRepositoryMock;
   let stateTransition;
-  let identity;
   let executionContext;
 
-  beforeEach(function beforeEach() {
-    stateTransition = getIdentityUpdateTransitionFixture();
+  let StateTransitionExecutionContext;
+  let IdentityUpdateTransition;
+
+  let applyIdentityUpdateTransitionDPP;
+
+  before(async () => {
+    ({
+      StateTransitionExecutionContext,
+      IdentityUpdateTransition,
+      applyIdentityUpdateTransition: applyIdentityUpdateTransitionDPP,
+    } = await loadWasmDpp());
+  });
+
+  beforeEach(async function beforeEach() {
+    stateTransition = new IdentityUpdateTransition(
+      getIdentityUpdateTransitionFixture().toObject(),
+    );
     stateTransition.setRevision(stateTransition.getRevision() + 1);
-    identity = getIdentityFixture();
 
     executionContext = new StateTransitionExecutionContext();
-
     stateTransition.setExecutionContext(executionContext);
 
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-    stateRepositoryMock.fetchIdentity.resolves(identity);
+    stateRepositoryMock.updateIdentityRevision.resolves();
+    stateRepositoryMock.disableIdentityKeys.resolves();
+    stateRepositoryMock.addKeysToIdentity.resolves();
 
-    applyIdentityUpdateTransition = applyIdentityUpdateTransitionFactory(
+    applyIdentityUpdateTransition = (st) => applyIdentityUpdateTransitionDPP(
       stateRepositoryMock,
+      st,
     );
   });
 
-  it('should add public keys', async () => {
-    stateTransition.setPublicKeysDisabledAt(undefined);
-    stateTransition.setPublicKeyIdsToDisable(undefined);
-
+  it('should add and disable public keys', async function () {
     await applyIdentityUpdateTransition(stateTransition);
 
-    expect(identity.getPublicKeys()).to.have.lengthOf(3);
+    const { match } = this.sinonSandbox;
 
-    expect(identity.getPublicKeyById(3).toObject())
-      .to.deep.equal(stateTransition.getPublicKeysToAdd()[0]);
-
-    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
-      stateTransition.getIdentityId(),
-      executionContext,
+    expect(stateRepositoryMock.updateIdentityRevision).to.be.calledOnceWithExactly(
+      match((id) => id.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
+      stateTransition.getRevision(),
+      match.instanceOf(StateTransitionExecutionContext),
     );
 
-    expect(stateRepositoryMock.updateIdentity).to.be.calledOnceWithExactly(
-      identity,
-      executionContext,
+    expect(stateRepositoryMock.disableIdentityKeys).to.be.calledOnceWithExactly(
+      match((id) => id.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
+      stateTransition.getPublicKeyIdsToDisable(),
+      stateTransition.getPublicKeysDisabledAt().getTime(),
+      match.instanceOf(StateTransitionExecutionContext),
     );
 
-    const publicKeyHashes = stateTransition.getPublicKeysToAdd()
-      .map((publicKey) => publicKey.hash());
+    const publicKeysToAdd = stateTransition.getPublicKeysToAdd()
+      .map((publicKey) => publicKey.toObject({ skipSignature: true }));
 
-    expect(stateRepositoryMock.storeIdentityPublicKeyHashes).to.be.calledOnceWithExactly(
-      identity.getId(),
-      publicKeyHashes,
-      executionContext,
+    expect(stateRepositoryMock.addKeysToIdentity).to.be.calledOnceWithExactly(
+      match((id) => id.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
+      match((args) => expect(args.map((k) => k.toObject())).to.deep.equals(publicKeysToAdd)),
+      match.instanceOf(StateTransitionExecutionContext),
     );
-
-    expect(identity.getRevision()).to.equal(stateTransition.getRevision());
   });
 
-  it('should disable public key', async () => {
-    stateTransition.setPublicKeysToAdd(undefined);
-
-    await applyIdentityUpdateTransition(stateTransition);
-
-    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
-      stateTransition.getIdentityId(),
-      executionContext,
-    );
-
-    expect(stateRepositoryMock.storeIdentityPublicKeyHashes).to.not.be.called();
-
-    expect(stateRepositoryMock.updateIdentity).to.be.calledOnceWithExactly(
-      identity,
-      executionContext,
-    );
-
-    const [id] = stateTransition.getPublicKeyIdsToDisable();
-
-    expect(identity.getPublicKeyById(id).getDisabledAt())
-      .to.equal(stateTransition.getPublicKeysDisabledAt().getTime());
-
-    expect(identity.getRevision()).to.equal(stateTransition.getRevision());
-  });
-
-  it('should not add public keys on dry run', async () => {
-    const biggestPossibleIdentity = getBiggestPossibleIdentity();
-
-    stateTransition.setPublicKeysDisabledAt(undefined);
-    stateTransition.setPublicKeyIdsToDisable(undefined);
+  it('should add and disable public keys on dry run', async function () {
+    const { match } = this.sinonSandbox;
 
     stateTransition.getExecutionContext().enableDryRun();
 
@@ -99,51 +79,26 @@ describe('applyIdentityUpdateTransition', () => {
 
     stateTransition.getExecutionContext().disableDryRun();
 
-    expect(identity.getPublicKeys()).to.have.lengthOf(2);
-
-    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
-      stateTransition.getIdentityId(),
-      executionContext,
-    );
-
-    expect(stateRepositoryMock.updateIdentity).to.be.calledOnceWithExactly(
-      biggestPossibleIdentity,
-      executionContext,
+    expect(stateRepositoryMock.updateIdentityRevision).to.be.calledOnceWithExactly(
+      match((id) => id.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
+      stateTransition.getRevision(),
+      match.instanceOf(StateTransitionExecutionContext),
     );
 
-    const publicKeyHashes = stateTransition.getPublicKeysToAdd()
-      .map((publicKey) => publicKey.hash());
-
-    expect(stateRepositoryMock.storeIdentityPublicKeyHashes).to.be.calledOnceWithExactly(
-      biggestPossibleIdentity.getId(),
-      publicKeyHashes,
-      executionContext,
-    );
-
-    expect(biggestPossibleIdentity.getRevision()).to.equal(stateTransition.getRevision());
-  });
-
-  it('should use biggestPossibleIdentity on dry run', async () => {
-    const biggestPossibleIdentity = getBiggestPossibleIdentity();
-
-    stateTransition.setPublicKeysToAdd(undefined);
-
-    stateTransition.getExecutionContext().enableDryRun();
-
-    await applyIdentityUpdateTransition(stateTransition);
-
-    stateTransition.getExecutionContext().disableDryRun();
-
-    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
-      stateTransition.getIdentityId(),
-      executionContext,
+    expect(stateRepositoryMock.disableIdentityKeys).to.be.calledOnceWithExactly(
+      match((id) => id.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
+      stateTransition.getPublicKeyIdsToDisable(),
+      stateTransition.getPublicKeysDisabledAt().getTime(),
+      match.instanceOf(StateTransitionExecutionContext),
     );
 
-    expect(stateRepositoryMock.storeIdentityPublicKeyHashes).to.not.be.called();
+    const publicKeysToAdd = stateTransition.getPublicKeysToAdd()
+      .map((publicKey) => publicKey.toObject({ skipSignature: true }));
 
-    expect(stateRepositoryMock.updateIdentity).to.be.calledOnceWithExactly(
-      biggestPossibleIdentity,
-      executionContext,
+    expect(stateRepositoryMock.addKeysToIdentity).to.be.calledOnceWithExactly(
+      match((id) => id.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
+      match((args) => expect(args.map((k) => k.toObject())).to.deep.equals(publicKeysToAdd)),
+      match.instanceOf(StateTransitionExecutionContext),
     );
   });
 });

package/test/unit/identity/stateTransition/assetLockProof/ChainAssetLockProof.spec.js

@@ -0,0 +1,63 @@
+const getChainAssetLockFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
+
+describe('ChainAssetLockProof', () => {
+  let ChainAssetLockProof;
+  let chainAssetLockProof;
+  let chainAssetLockProofJS;
+
+  before(async () => {
+    ({ ChainAssetLockProof } = await loadWasmDpp());
+
+    chainAssetLockProofJS = getChainAssetLockFixture();
+    chainAssetLockProof = new ChainAssetLockProof(
+      chainAssetLockProofJS.toObject(),
+    );
+  });
+
+  describe('#getType', () => {
+    it('should return correct type', () => {
+      expect(chainAssetLockProof.getType())
+        .to.equal(chainAssetLockProofJS.getType());
+    });
+  });
+
+  describe('#getCoreChainLockedHeight', () => {
+    it('should return correct coreChainLockedHeight', () => {
+      expect(chainAssetLockProof.getCoreChainLockedHeight())
+        .to.equal(chainAssetLockProofJS.getCoreChainLockedHeight());
+    });
+  });
+
+  describe('#getOutPoint', () => {
+    it('should return correct outPoint', () => {
+      expect(chainAssetLockProof.getOutPoint())
+        .to.deep.equal(chainAssetLockProofJS.getOutPoint());
+    });
+  });
+
+  describe('#toJSON', () => {
+    it('should return correct JSON', () => {
+      expect(chainAssetLockProof.toJSON())
+        .to.deep.equal(chainAssetLockProofJS.toJSON());
+    });
+  });
+
+  describe('#toObject', () => {
+    it('should return correct object', () => {
+      expect(chainAssetLockProof.toObject())
+        .to.deep.equal(chainAssetLockProofJS.toObject());
+    });
+  });
+
+  describe('#createIdentifier', () => {
+    it('should return correct identifier', () => {
+      const identifier = chainAssetLockProof.createIdentifier();
+      const identifierJS = chainAssetLockProofJS.createIdentifier();
+
+      expect(identifier.toBuffer())
+        .to.deep.equal(identifierJS.toBuffer());
+    });
+  });
+});

package/test/unit/identity/stateTransition/assetLockProof/InstantAssetLockProof.spec.js

@@ -0,0 +1,90 @@
+const getInstantAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
+
+describe('InstantAssetLockProof', () => {
+  let InstantAssetLockProof;
+  let instantAssetLockProof;
+  let instantAssetLockProofJS;
+
+  before(async () => {
+    ({ InstantAssetLockProof } = await loadWasmDpp());
+
+    instantAssetLockProofJS = getInstantAssetLockProofFixture();
+    instantAssetLockProof = new InstantAssetLockProof(
+      instantAssetLockProofJS.toObject(),
+    );
+  });
+
+  describe('#getType', () => {
+    it('should return correct type', () => {
+      expect(instantAssetLockProof.getType())
+        .to.equal(instantAssetLockProofJS.getType());
+    });
+  });
+
+  describe('#getOutputIndex', () => {
+    it('should return correct type', () => {
+      expect(instantAssetLockProof.getOutputIndex())
+        .to.equal(instantAssetLockProofJS.getOutputIndex());
+    });
+  });
+
+  describe('#getOutPoint', () => {
+    it('should return correct outPoint', () => {
+      expect(instantAssetLockProof.getOutPoint())
+        .to.deep.equal(instantAssetLockProofJS.getOutPoint());
+    });
+  });
+
+  describe('#getOutput', () => {
+    it('should return correct output', () => {
+      expect(instantAssetLockProof.getOutput())
+        .to.deep.equal(instantAssetLockProofJS.getOutput().toObject());
+    });
+  });
+
+  describe('#createIdentifier', () => {
+    it('should return correct identifier', () => {
+      const identifier = instantAssetLockProof.createIdentifier();
+      const identifierJS = instantAssetLockProofJS.createIdentifier();
+
+      expect(identifier.toBuffer())
+        .to.deep.equal(identifierJS.toBuffer());
+    });
+  });
+
+  describe('#getInstantLock', () => {
+    it('should return correct instant lock', () => {
+      const instantLock = instantAssetLockProof.getInstantLock();
+      const instantLockJS = instantAssetLockProofJS.getInstantLock();
+
+      expect(instantLock)
+        .to.deep.equal(instantLockJS.toBuffer());
+    });
+  });
+
+  describe('#getTransaction', () => {
+    it('should return correct transaction', () => {
+      const transaction = instantAssetLockProof.getTransaction();
+      const transactionJS = instantAssetLockProofJS.getTransaction();
+
+      expect(transaction)
+        .to.deep.equal(transactionJS.toBuffer());
+    });
+  });
+
+  describe('#toObject', () => {
+    it('should return correct object', () => {
+      expect(instantAssetLockProof.toObject())
+        .to.deep.equal(instantAssetLockProofJS.toObject());
+    });
+  });
+
+  describe('#toJSON', () => {
+    it('should return correct JSON', () => {
+      expect(instantAssetLockProof.toJSON())
+        .to.deep.equal(instantAssetLockProofJS.toJSON());
+    });
+  });
+});

package/test/unit/identity/stateTransition/assetLockProof/createAssetLockProofInstance.spec.js

@@ -1,21 +1,36 @@
-const createAssetLockProofInstance = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/createAssetLockProofInstance');
+const createAssetLockProofInstanceJS = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/createAssetLockProofInstance');
 const getChainAssetLockFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
 const getInstantAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
-const ChainAssetLockProof = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/chain/ChainAssetLockProof');
-const InstantAssetLockProof = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/instant/InstantAssetLockProof');
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('createAssetLockProofInstance', () => {
+  let createAssetLockProofInstance;
+  let InstantAssetLockProof;
+  let ChainAssetLockProof;
+
+  before(async () => {
+    ({
+      createAssetLockProofInstance,
+      InstantAssetLockProof,
+      ChainAssetLockProof,
+    } = await loadWasmDpp());
+  });
+
   it('should create an instance of InstantAssetLockProof', () => {
     const assetLockProofFixture = getInstantAssetLockProofFixture();
     const instance = createAssetLockProofInstance(assetLockProofFixture.toObject());
+    const instanceJS = createAssetLockProofInstanceJS(assetLockProofFixture.toObject());
 
+    expect(instance.toObject()).to.deep.equal(instanceJS.toObject());
     expect(instance).to.be.an.instanceOf(InstantAssetLockProof);
   });
 
   it('should create an instance of ChainAssetLockProof', () => {
     const assetLockProofFixture = getChainAssetLockFixture();
     const instance = createAssetLockProofInstance(assetLockProofFixture.toObject());
+    const instanceJS = createAssetLockProofInstanceJS(assetLockProofFixture.toObject());
 
+    expect(instance.toObject()).to.deep.equal(instanceJS.toObject());
     expect(instance).to.be.an.instanceOf(ChainAssetLockProof);
   });
 });

package/test/unit/identity/stateTransition/assetLockProof/fetchAssetLockPublicKeyHashFactory.spec.js

@@ -1,32 +1,59 @@
-const fetchAssetLockPublicKeyHashFactory = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/fetchAssetLockPublicKeyHashFactory');
+const { Script } = require('@dashevo/dashcore-lib');
+
 const getInstantAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
-const AssetLockOutputNotFoundError = require('@dashevo/dpp/lib/identity/errors/AssetLockOutputNotFoundError');
+
+const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+const { default: loadWasmpDpp } = require('../../../../../dist');
 
 describe('fetchAssetLockPublicKeyHashFactory', () => {
   let fetchAssetLockPublicKeyHash;
-  let fetchAssetLockTransactionOutputMock;
-  let assetLockProof;
+  let stateRepositoryMock;
+  let executionContext;
+
+  let StateTransitionExecutionContext;
+  let InstantAssetLockProof;
+  let AssetLockOutputNotFoundError;
+  let fetchAssetLockPublicKeyHashDPP;
+
+  before(async () => {
+    ({
+      StateTransitionExecutionContext,
+      InstantAssetLockProof,
+      AssetLockOutputNotFoundError,
+      fetchAssetLockPublicKeyHash: fetchAssetLockPublicKeyHashDPP,
+    } = await loadWasmpDpp());
+  });
 
   beforeEach(function beforeEach() {
-    fetchAssetLockTransactionOutputMock = this.sinonSandbox.stub();
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
 
-    fetchAssetLockPublicKeyHash = fetchAssetLockPublicKeyHashFactory(
-      fetchAssetLockTransactionOutputMock,
-    );
+    executionContext = new StateTransitionExecutionContext();
 
-    assetLockProof = getInstantAssetLockProofFixture();
+    fetchAssetLockPublicKeyHash = (proof) => fetchAssetLockPublicKeyHashDPP(
+      stateRepositoryMock,
+      proof,
+      executionContext,
+    );
   });
 
   it('should return public key hash for specified asset lock proof', async () => {
-    fetchAssetLockTransactionOutputMock.resolves(assetLockProof.getOutput());
+    const assetLockProof = new InstantAssetLockProof(
+      getInstantAssetLockProofFixture().toObject(),
+    );
 
     const result = await fetchAssetLockPublicKeyHash(assetLockProof);
 
-    expect(result).to.deep.equal(assetLockProof.getOutput().script.getData());
+    expect(result).to
+      .deep.equal(new Script(assetLockProof.getOutput().script).getData());
   });
 
   it('should throw AssetLockOutputNotFoundError if output is not found', async () => {
     try {
+      const assetLockProofJS = getInstantAssetLockProofFixture();
+      // Mess up TX outputs
+      assetLockProofJS.transaction.outputs = [];
+
+      const assetLockProof = new InstantAssetLockProof(assetLockProofJS.toObject());
       await fetchAssetLockPublicKeyHash(assetLockProof);
       expect.fail('should throw AssetLockOutputNotFoundError');
     } catch (e) {