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

package/test/integration/identity/stateTransition/assetLockProof/instant/validateInstantAssetLockProofStructureFactory.spec.js

@@ -1,35 +1,40 @@
-const { getRE2Class } = require('@dashevo/wasm-re2');
-
 const DashCoreLib = require('@dashevo/dashcore-lib');
 
-const createAjv = require('@dashevo/dpp/lib/ajv/createAjv');
-
 const getInstantAssetLockFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
-const JsonSchemaValidator = require('@dashevo/dpp/lib/validation/JsonSchemaValidator');
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-const InvalidIdentityAssetLockProofError = require('@dashevo/dpp/lib/errors/consensus/basic/identity/InvalidInstantAssetLockProofError');
-const IdentityAssetLockProofLockedTransactionMismatchError = require('@dashevo/dpp/lib/errors/consensus/basic/identity/IdentityAssetLockProofLockedTransactionMismatchError');
-const InvalidIdentityAssetLockProofSignatureError = require('@dashevo/dpp/lib/errors/consensus/basic/identity/InvalidInstantAssetLockProofSignatureError');
 
-const { expectValidationError, expectJsonSchemaError } = require(
-  '@dashevo/dpp/lib/test/expect/expectError',
-);
+const { expect } = require('chai');
+const { expectJsonSchemaError, expectValidationError } = require('../../../../../../lib/test/expect/expectError');
 
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-const InvalidIdentityAssetLockTransactionError = require('@dashevo/dpp/lib/errors/consensus/basic/identity/InvalidIdentityAssetLockTransactionError');
-const validateInstantAssetLockProofStructureFactory = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/instant/validateInstantAssetLockProofStructureFactory');
+const { default: loadWasmDpp } = require('../../../../../../dist');
 
 describe('validateInstantAssetLockProofStructureFactory', () => {
   let rawProof;
   let transaction;
   let stateRepositoryMock;
-  let instantLockFromBufferMock;
-  let instantLockMock;
+  let executionContext;
+
+  let StateTransitionExecutionContext;
+  let ValidationResult;
+  let InvalidInstantAssetLockProofError;
+  let IdentityAssetLockProofLockedTransactionMismatchError;
+  let InvalidInstantAssetLockProofSignatureError;
+  let InvalidIdentityAssetLockTransactionError;
+  let InstantAssetLockProofStructureValidator;
+
   let validateInstantAssetLockProofStructure;
-  let jsonSchemaValidator;
-  let validateAssetLockTransactionResult;
-  let publicKeyHash;
-  let validateAssetLockTransactionMock;
+
+  before(async () => {
+    ({
+      StateTransitionExecutionContext,
+      ValidationResult,
+      InvalidInstantAssetLockProofError,
+      IdentityAssetLockProofLockedTransactionMismatchError,
+      InvalidInstantAssetLockProofSignatureError,
+      InvalidIdentityAssetLockTransactionError,
+      InstantAssetLockProofStructureValidator,
+    } = await loadWasmDpp());
+  });
 
   beforeEach(async function beforeEach() {
     const assetLock = getInstantAssetLockFixture();
@@ -37,50 +42,26 @@ describe('validateInstantAssetLockProofStructureFactory', () => {
 
     rawProof = assetLock.toObject();
 
-    const RE2 = await getRE2Class();
-    const ajv = createAjv(RE2);
-
-    jsonSchemaValidator = new JsonSchemaValidator(ajv);
-
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
     stateRepositoryMock.verifyInstantLock.resolves(true);
+    stateRepositoryMock.isAssetLockTransactionOutPointAlreadyUsed.resolves(false);
 
-    instantLockMock = {
-      txid: transaction.id,
-      verify: this.sinonSandbox.stub().resolves(true),
-    };
+    executionContext = new StateTransitionExecutionContext();
 
-    instantLockFromBufferMock = this.sinonSandbox.stub(DashCoreLib.InstantLock, 'fromBuffer').returns(instantLockMock);
-
-    publicKeyHash = Buffer.from('152073ca2300a86b510fa2f123d3ea7da3af68dc', 'hex');
-
-    validateAssetLockTransactionResult = new ValidationResult();
-    validateAssetLockTransactionResult.setData({
-      publicKeyHash,
-      transaction,
-    });
-    validateAssetLockTransactionMock = this.sinonSandbox.stub().resolves(
-      validateAssetLockTransactionResult,
-    );
-
-    validateInstantAssetLockProofStructure = validateInstantAssetLockProofStructureFactory(
-      jsonSchemaValidator,
-      stateRepositoryMock,
-      validateAssetLockTransactionMock,
+    const validator = new InstantAssetLockProofStructureValidator(stateRepositoryMock);
+    validateInstantAssetLockProofStructure = (proof, context) => validator.validate(
+      proof,
+      context,
     );
   });
 
-  afterEach(() => {
-    instantLockFromBufferMock.restore();
-  });
-
   describe('type', () => {
     it('should be present', async () => {
       delete rawProof.type;
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -89,16 +70,14 @@ describe('validateInstantAssetLockProofStructureFactory', () => {
       expect(error.getParams().missingProperty).to.equal('type');
 
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
     });
 
     it('should be equal to 0', async () => {
       rawProof.type = -1;
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -106,8 +85,6 @@ describe('validateInstantAssetLockProofStructureFactory', () => {
       expect(error.getKeyword()).to.equal('const');
 
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
     });
   });
 
@@ -115,9 +92,9 @@ describe('validateInstantAssetLockProofStructureFactory', () => {
     it('should be present', async () => {
       delete rawProof.instantLock;
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -126,35 +103,29 @@ describe('validateInstantAssetLockProofStructureFactory', () => {
       expect(error.getParams().missingProperty).to.equal('instantLock');
 
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
     });
 
     it('should be a byte array', async () => {
       rawProof.instantLock = new Array(165).fill('string');
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectJsonSchemaError(result, 2);
+      await expectJsonSchemaError(result, 165);
 
-      const [error, byteArrayError] = result.getErrors();
+      const [error] = result.getErrors();
 
       expect(error.getInstancePath()).to.equal('/instantLock/0');
       expect(error.getKeyword()).to.equal('type');
 
-      expect(byteArrayError.getKeyword()).to.equal('byteArray');
-
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
     });
 
     it('should not be shorter than 160 bytes', async () => {
       rawProof.instantLock = Buffer.alloc(159);
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -162,16 +133,14 @@ describe('validateInstantAssetLockProofStructureFactory', () => {
       expect(error.getKeyword()).to.equal('minItems');
 
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
     });
 
     it('should not be longer than 100 Kb', async () => {
       rawProof.instantLock = Buffer.alloc(100001);
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -179,37 +148,34 @@ describe('validateInstantAssetLockProofStructureFactory', () => {
       expect(error.getKeyword()).to.equal('maxItems');
 
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
     });
 
     it('should be valid', async () => {
-      const instantLockError = new Error('something is wrong');
-
-      instantLockFromBufferMock.throws(instantLockError);
-
       rawProof.instantLock = Buffer.alloc(200);
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
-      expectValidationError(result, InvalidIdentityAssetLockProofError);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
+      await expectValidationError(result, InvalidInstantAssetLockProofError);
 
       const [error] = result.getErrors();
 
       expect(error.getCode()).to.equal(1041);
-      expect(error.getValidationError()).to.equal(instantLockError);
 
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
     });
 
     it('should lock the same transaction', async () => {
       const txId = Buffer.alloc(32);
-      instantLockMock.txid = txId.toString('hex');
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const instantLockParsed = new DashCoreLib.InstantLock(rawProof.instantLock);
+      instantLockParsed.txid = txId.toString('hex');
+      rawProof.instantLock = instantLockParsed.toBuffer();
+
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectValidationError(result, IdentityAssetLockProofLockedTransactionMismatchError);
+      await expectValidationError(
+        result,
+        IdentityAssetLockProofLockedTransactionMismatchError,
+      );
 
       const [error] = result.getErrors();
 
@@ -217,24 +183,24 @@ describe('validateInstantAssetLockProofStructureFactory', () => {
       expect(error.getInstantLockTransactionId()).to.deep.equal(txId);
       expect(error.getAssetLockTransactionId()).to.deep.equal(Buffer.from(transaction.id, 'hex'));
 
-      // expect(stateRepositoryMock.verifyInstantLock).to.be.calledOnce();
-      expect(instantLockMock.verify).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.be.calledOnce();
+      expect(stateRepositoryMock.verifyInstantLock).to.be.calledOnce();
     });
 
     it('should have valid signature', async () => {
       stateRepositoryMock.verifyInstantLock.resolves(false);
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectValidationError(result, InvalidIdentityAssetLockProofSignatureError);
+      await expectValidationError(
+        result,
+        InvalidInstantAssetLockProofSignatureError,
+      );
 
       const [error] = result.getErrors();
 
       expect(error.getCode()).to.equal(1042);
 
       expect(stateRepositoryMock.verifyInstantLock).to.be.calledOnce();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
     });
   });
 
@@ -242,9 +208,9 @@ describe('validateInstantAssetLockProofStructureFactory', () => {
     it('should be present', async () => {
       delete rawProof.transaction;
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -253,88 +219,66 @@ describe('validateInstantAssetLockProofStructureFactory', () => {
       expect(error.getParams().missingProperty).to.equal('transaction');
 
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
     });
 
     it('should be a byte array', async () => {
       rawProof.transaction = new Array(65).fill('string');
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectJsonSchemaError(result, 2);
+      await expectJsonSchemaError(result, 65);
 
-      const [error, byteArrayError] = result.getErrors();
+      const [error] = result.getErrors();
 
       expect(error.getInstancePath()).to.equal('/transaction/0');
       expect(error.getKeyword()).to.equal('type');
 
-      expect(byteArrayError.getKeyword()).to.equal('byteArray');
-
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
     });
 
     it('should not be shorter than 1 byte', async () => {
       rawProof.transaction = Buffer.alloc(0);
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/transaction');
+      expect(error.getInstancePath()).to.equal('/transaction');
       expect(error.getKeyword()).to.equal('minItems');
 
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
     });
 
     it('should not be longer than 100 Kb', async () => {
       rawProof.transaction = Buffer.alloc(100001);
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/transaction');
+      expect(error.getInstancePath()).to.equal('/transaction');
       expect(error.getKeyword()).to.equal('maxItems');
 
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
     });
 
     it('should should be valid', async () => {
-      const validationError = new Error('parsing failed');
-
-      const consensusError = new InvalidIdentityAssetLockTransactionError(validationError.message);
+      rawProof.transaction = Buffer.alloc(1000);
 
-      consensusError.setValidationError(validationError);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      validateAssetLockTransactionResult.addError(consensusError);
-      validateAssetLockTransactionMock.resolves(validateAssetLockTransactionResult);
-
-      const result = await validateInstantAssetLockProofStructure(rawProof);
-
-      expectValidationError(result, InvalidIdentityAssetLockTransactionError);
+      await expectValidationError(result, InvalidIdentityAssetLockTransactionError);
 
       const [error] = result.getErrors();
 
       expect(error.getCode()).to.equal(1038);
+      expect(error.getValidationError()).to.exist();
 
-      expect(error).to.equal(consensusError);
-
-      expect(error.getValidationError()).to.equal(validationError);
-
-      // expect(stateRepositoryMock.verifyInstantLock).to.be.calledOnce();
-      expect(instantLockMock.verify).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.be.calledOnce();
+      expect(stateRepositoryMock.verifyInstantLock).to.be.calledOnce();
     });
   });
 
@@ -342,60 +286,62 @@ describe('validateInstantAssetLockProofStructureFactory', () => {
     it('should be present', async () => {
       delete rawProof.outputIndex;
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, 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('outputIndex');
 
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
     });
 
     it('should be an integer', async () => {
       rawProof.outputIndex = 1.1;
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectJsonSchemaError(result, 1);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/outputIndex');
+      expect(error.getInstancePath()).to.equal('/outputIndex');
       expect(error.getKeyword()).to.equal('type');
 
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
     });
 
     it('should not be less than 0', async () => {
       rawProof.outputIndex = -1;
 
-      const result = await validateInstantAssetLockProofStructure(rawProof);
+      const result = await validateInstantAssetLockProofStructure(rawProof, executionContext);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/outputIndex');
+      expect(error.getInstancePath()).to.equal('/outputIndex');
       expect(error.getKeyword()).to.equal('minimum');
 
       expect(stateRepositoryMock.verifyInstantLock).to.not.be.called();
-      expect(instantLockMock.verify).to.not.be.called();
     });
   });
 
   it('should return valid result', async () => {
-    const result = await validateInstantAssetLockProofStructure(rawProof);
+    const result = await validateInstantAssetLockProofStructure(
+      rawProof,
+      executionContext,
+    );
 
     expect(result).to.be.an.instanceOf(ValidationResult);
     expect(result.isValid()).to.be.true();
+
+    const publicKeyHash = transaction.outputs[0].script.getData();
     expect(result.getData()).to.deep.equal(publicKeyHash);
 
-    // expect(stateRepositoryMock.verifyInstantLock).to.be.calledOnce();
+    expect(stateRepositoryMock.verifyInstantLock).to.be.calledOnce();
   });
 });