@dashevo/wasm-dpp 0.24.0-dev.11 → 0.24.0-dev.13

package/test/integration/identity/stateTransition/assetLockProof/chain/validateChainAssetLockProofStructureFactory.spec.js

@@ -1,53 +1,59 @@
-const { getRE2Class } = require('@dashevo/wasm-re2');
-
-const createAjv = require('@dashevo/dpp/lib/ajv/createAjv');
+const { Transaction, Script, PrivateKey } = require('@dashevo/dashcore-lib');
 
 const getChainAssetLockFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
-const JsonSchemaValidator = require('@dashevo/dpp/lib/validation/JsonSchemaValidator');
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 
-const { expectValidationError, expectJsonSchemaError } = require(
-  '@dashevo/dpp/lib/test/expect/expectError',
-);
+const { expect } = require('chai');
+const { expectJsonSchemaError, expectValidationError } = require('../../../../../../lib/test/expect/expectError');
 
-const validateChainAssetLockProofStructureFactory = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/chain/validateChainAssetLockProofStructureFactory');
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-const IdentityAssetLockTransactionIsNotFoundError = require('@dashevo/dpp/lib/errors/consensus/basic/identity/IdentityAssetLockTransactionIsNotFoundError');
-const InvalidAssetLockProofCoreChainHeightError = require('@dashevo/dpp/lib/errors/consensus/basic/identity/InvalidAssetLockProofCoreChainHeightError');
-const InvalidAssetLockProofTransactionHeightError = require('@dashevo/dpp/lib/errors/consensus/basic/identity/InvalidAssetLockProofTransactionHeightError');
-const SomeConsensusError = require('@dashevo/dpp/lib/test/mocks/SomeConsensusError');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+const { default: loadWasmDpp } = require('../../../../../../dist');
 
 describe('validateChainAssetLockProofStructureFactory', () => {
   let rawProof;
   let stateRepositoryMock;
-  let validateChainAssetLockProofStructure;
-  let jsonSchemaValidator;
-  let validateAssetLockTransactionMock;
-  let validateAssetLockTransactionResult;
   let publicKeyHash;
   let rawTransaction;
   let transactionHash;
   let executionContext;
+  let validateChainAssetLockProofStructure;
+
+  let StateTransitionExecutionContext;
+  let ValidationResult;
+  let InvalidAssetLockProofCoreChainHeightError;
+  let IdentityAssetLockTransactionIsNotFoundError;
+  let InvalidIdentityAssetLockTransactionOutputError;
+  let InvalidAssetLockProofTransactionHeightError;
+  let ChainAssetLockProofStructureValidator;
+
+  before(async () => {
+    ({
+      StateTransitionExecutionContext,
+      ValidationResult,
+      InvalidAssetLockProofCoreChainHeightError,
+      IdentityAssetLockTransactionIsNotFoundError,
+      InvalidIdentityAssetLockTransactionOutputError,
+      InvalidAssetLockProofTransactionHeightError,
+      ChainAssetLockProofStructureValidator,
+    } = await loadWasmDpp());
+  });
 
   beforeEach(async function beforeEach() {
     rawTransaction = '030000000137feb5676d0851337ea3c9a992496aab7a0b3eee60aeeb9774000b7f4bababa5000000006b483045022100d91557de37645c641b948c6cd03b4ae3791a63a650db3e2fee1dcf5185d1b10402200e8bd410bf516ca61715867666d31e44495428ce5c1090bf2294a829ebcfa4ef0121025c3cc7fbfc52f710c941497fd01876c189171ea227458f501afcb38a297d65b4ffffffff021027000000000000166a14152073ca2300a86b510fa2f123d3ea7da3af68dcf77cb0090a0000001976a914152073ca2300a86b510fa2f123d3ea7da3af68dc88ac00000000';
     transactionHash = '6e200d059fb567ba19e92f5c2dcd3dde522fd4e0a50af223752db16158dabb1d';
 
-    const assetLock = getChainAssetLockFixture();
-
-    rawProof = assetLock.toObject();
-
-    const RE2 = await getRE2Class();
-    const ajv = createAjv(RE2);
+    rawProof = getChainAssetLockFixture().toObject();
 
-    jsonSchemaValidator = new JsonSchemaValidator(ajv);
+    // Change endianness of raw txId bytes in outPoint to match expectation of dashcore-rust
+    const txId = rawProof.outPoint.slice(0, 32);
+    const outputIndex = rawProof.outPoint.slice(32);
+    txId.reverse();
+    rawProof.outPoint = Buffer.concat([txId, outputIndex]);
 
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
 
-    stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight.resolves(42);
+    stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight.returns(42);
 
-    stateRepositoryMock.fetchTransaction.resolves({
+    stateRepositoryMock.fetchTransaction.returns({
       data: Buffer.from(rawTransaction, 'hex'),
       height: 42,
     });
@@ -56,18 +62,14 @@ describe('validateChainAssetLockProofStructureFactory', () => {
 
     publicKeyHash = Buffer.from('152073ca2300a86b510fa2f123d3ea7da3af68dc', 'hex');
 
-    validateAssetLockTransactionResult = new ValidationResult();
-    validateAssetLockTransactionResult.setData({
-      publicKeyHash,
-    });
-    validateAssetLockTransactionMock = this.sinonSandbox.stub().resolves(
-      validateAssetLockTransactionResult,
+    const validator = new ChainAssetLockProofStructureValidator(
+      stateRepositoryMock,
     );
 
-    validateChainAssetLockProofStructure = validateChainAssetLockProofStructureFactory(
-      jsonSchemaValidator,
-      stateRepositoryMock,
-      validateAssetLockTransactionMock,
+    validateChainAssetLockProofStructure = (
+      proof, context,
+    ) => validator.validate(
+      rawProof, context,
     );
   });
 
@@ -80,7 +82,7 @@ describe('validateChainAssetLockProofStructureFactory', () => {
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -89,7 +91,6 @@ describe('validateChainAssetLockProofStructureFactory', () => {
       expect(error.getParams().missingProperty).to.equal('type');
 
       expect(stateRepositoryMock.fetchTransaction).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
       expect(stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight).to.not.be.called();
     });
 
@@ -101,7 +102,7 @@ describe('validateChainAssetLockProofStructureFactory', () => {
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -122,7 +123,7 @@ describe('validateChainAssetLockProofStructureFactory', () => {
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -131,7 +132,6 @@ describe('validateChainAssetLockProofStructureFactory', () => {
       expect(error.getParams().missingProperty).to.equal('coreChainLockedHeight');
 
       expect(stateRepositoryMock.fetchTransaction).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
       expect(stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight).to.not.be.called();
     });
 
@@ -143,7 +143,7 @@ describe('validateChainAssetLockProofStructureFactory', () => {
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -151,7 +151,6 @@ describe('validateChainAssetLockProofStructureFactory', () => {
       expect(error.getKeyword()).to.equal('type');
 
       expect(stateRepositoryMock.fetchTransaction).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
       expect(stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight).to.not.be.called();
     });
 
@@ -163,7 +162,7 @@ describe('validateChainAssetLockProofStructureFactory', () => {
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -171,7 +170,6 @@ describe('validateChainAssetLockProofStructureFactory', () => {
       expect(error.getKeyword()).to.equal('type');
 
       expect(stateRepositoryMock.fetchTransaction).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
       expect(stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight).to.not.be.called();
     });
 
@@ -183,7 +181,7 @@ describe('validateChainAssetLockProofStructureFactory', () => {
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -191,7 +189,6 @@ describe('validateChainAssetLockProofStructureFactory', () => {
       expect(error.getKeyword()).to.equal('minimum');
 
       expect(stateRepositoryMock.fetchTransaction).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
       expect(stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight).to.not.be.called();
     });
 
@@ -203,20 +200,19 @@ describe('validateChainAssetLockProofStructureFactory', () => {
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/coreChainLockedHeight');
+      expect(error.getInstancePath()).to.equal('/coreChainLockedHeight');
       expect(error.getKeyword()).to.equal('maximum');
 
       expect(stateRepositoryMock.fetchTransaction).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
       expect(stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight).to.not.be.called();
     });
 
     it('should be less or equal to consensus core height', async () => {
-      stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight.resolves(41);
+      stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight.returns(41);
 
       const result = await validateChainAssetLockProofStructure(
         rawProof,
@@ -242,16 +238,15 @@ describe('validateChainAssetLockProofStructureFactory', () => {
         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('outPoint');
 
       expect(stateRepositoryMock.fetchTransaction).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
       expect(stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight).to.not.be.called();
     });
 
@@ -263,17 +258,14 @@ describe('validateChainAssetLockProofStructureFactory', () => {
         executionContext,
       );
 
-      expectJsonSchemaError(result, 2);
+      await expectJsonSchemaError(result, 36);
 
-      const [error, byteArrayError] = result.getErrors();
+      const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/outPoint/0');
+      expect(error.getInstancePath()).to.equal('/outPoint/0');
       expect(error.getKeyword()).to.equal('type');
 
-      expect(byteArrayError.getKeyword()).to.equal('byteArray');
-
       expect(stateRepositoryMock.fetchTransaction).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
       expect(stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight).to.not.be.called();
     });
 
@@ -285,15 +277,14 @@ describe('validateChainAssetLockProofStructureFactory', () => {
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/outPoint');
+      expect(error.getInstancePath()).to.equal('/outPoint');
       expect(error.getKeyword()).to.equal('minItems');
 
       expect(stateRepositoryMock.fetchTransaction).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
       expect(stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight).to.not.be.called();
     });
 
@@ -305,27 +296,26 @@ describe('validateChainAssetLockProofStructureFactory', () => {
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/outPoint');
+      expect(error.getInstancePath()).to.equal('/outPoint');
       expect(error.getKeyword()).to.equal('maxItems');
 
       expect(stateRepositoryMock.fetchTransaction).to.not.be.called();
-      expect(validateAssetLockTransactionMock).to.not.be.called();
       expect(stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight).to.not.be.called();
     });
 
-    it('should point to existing transaction', async () => {
-      stateRepositoryMock.fetchTransaction.resolves(null);
+    it('should point to existing transaction', async function () {
+      stateRepositoryMock.fetchTransaction.returns(null);
 
       const result = await validateChainAssetLockProofStructure(
         rawProof,
         executionContext,
       );
 
-      expectValidationError(result, IdentityAssetLockTransactionIsNotFoundError);
+      await expectValidationError(result, IdentityAssetLockTransactionIsNotFoundError);
 
       const [error] = result.getErrors();
 
@@ -336,39 +326,45 @@ describe('validateChainAssetLockProofStructureFactory', () => {
 
       expect(stateRepositoryMock.fetchTransaction).to.be.calledOnceWithExactly(
         transactionHash,
-        executionContext,
+        this.sinonSandbox.match.instanceOf(StateTransitionExecutionContext),
       );
-      expect(validateAssetLockTransactionMock).to.not.be.called();
       expect(stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight).to.be.calledOnce();
     });
 
     it('should point to valid transaction', async () => {
-      const consensusError = new SomeConsensusError('test');
+      // Validator expects asset lock proof TX to have OP_RETURN in it's first output, break it
+      const parsedTx = new Transaction(Buffer.from(rawTransaction, 'hex'));
+      const fromAddress = new PrivateKey().toAddress();
+      parsedTx.outputs[0].setScript(Script.buildPublicKeyHashOut(fromAddress).toString());
 
-      validateAssetLockTransactionResult.addError(consensusError);
+      stateRepositoryMock.fetchTransaction.returns({
+        data: parsedTx.toBuffer(),
+        height: 42,
+      });
 
       const result = await validateChainAssetLockProofStructure(
         rawProof,
         executionContext,
       );
 
-      expectValidationError(result, SomeConsensusError);
-
-      const [error] = result.getErrors();
-
-      expect(error).to.deep.equal(consensusError);
+      await expectValidationError(
+        result,
+        InvalidIdentityAssetLockTransactionOutputError,
+      );
     });
 
-    it('should point to transaction from block lower than core chain locked height', async () => {
+    it('should point to transaction from block lower than core chain locked height', async function () {
       rawProof.coreChainLockedHeight = 41;
-      stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight.resolves(41);
+      stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight.returns(41);
 
       const result = await validateChainAssetLockProofStructure(
         rawProof,
         executionContext,
       );
 
-      expectValidationError(result, InvalidAssetLockProofTransactionHeightError);
+      await expectValidationError(
+        result, InvalidAssetLockProofTransactionHeightError,
+      );
 
       const [error] = result.getErrors();
 
@@ -378,14 +374,13 @@ describe('validateChainAssetLockProofStructureFactory', () => {
 
       expect(stateRepositoryMock.fetchTransaction).to.be.calledOnceWithExactly(
         transactionHash,
-        executionContext,
+        this.sinonSandbox.match.instanceOf(StateTransitionExecutionContext),
       );
-      expect(validateAssetLockTransactionMock).to.not.be.called();
       expect(stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight).to.be.calledOnce();
     });
   });
 
-  it('should return valid result', async () => {
+  it('should return valid result', async function () {
     const result = await validateChainAssetLockProofStructure(
       rawProof,
       executionContext,
@@ -397,13 +392,9 @@ describe('validateChainAssetLockProofStructureFactory', () => {
 
     expect(stateRepositoryMock.fetchTransaction).to.be.calledOnceWithExactly(
       transactionHash,
-      executionContext,
-    );
-    expect(validateAssetLockTransactionMock).to.be.calledOnceWithExactly(
-      Buffer.from(rawTransaction, 'hex'),
-      0,
-      executionContext,
+      this.sinonSandbox.match.instanceOf(StateTransitionExecutionContext),
     );
+
     expect(stateRepositoryMock.fetchLatestPlatformCoreChainLockedHeight).to.be.calledOnce();
   });
 });

package/test/integration/identity/stateTransition/assetLockProof/fetchAssetLockTransactionOutputFactory.spec.js

@@ -1,32 +1,52 @@
-const { Transaction, Script } = require('@dashevo/dashcore-lib');
-const Output = require('@dashevo/dashcore-lib/lib/transaction/output');
+const { Transaction } = require('@dashevo/dashcore-lib');
 
-const fetchAssetLockTransactionOutputFactory = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/fetchAssetLockTransactionOutputFactory');
 const getChainAssetLockFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
 const getInstantAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-
-const UnknownAssetLockProofError = require('@dashevo/dpp/lib/identity/errors/UnknownAssetLockProofTypeError');
-const AssetLockTransactionIsNotFoundError = require('@dashevo/dpp/lib/identity/errors/AssetLockTransactionIsNotFoundError');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('fetchAssetLockTransactionOutputFactory', () => {
   let fetchAssetLockTransactionOutput;
   let stateRepositoryMock;
   let executionContext;
 
+  let StateTransitionExecutionContext;
+  let InstantAssetLockProof;
+  let ChainAssetLockProof;
+  let AssetLockTransactionIsNotFoundError;
+  let UnknownAssetLockProofTypeError;
+
+  let fetchAssetLockTransactionOutputDPP;
+
+  before(async () => {
+    ({
+      StateTransitionExecutionContext,
+      fetchAssetLockTransactionOutput: fetchAssetLockTransactionOutputDPP,
+      InstantAssetLockProof,
+      ChainAssetLockProof,
+      AssetLockTransactionIsNotFoundError,
+      UnknownAssetLockProofTypeError,
+    } = await loadWasmDpp());
+  });
+
   beforeEach(function beforeEach() {
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-    fetchAssetLockTransactionOutput = fetchAssetLockTransactionOutputFactory(stateRepositoryMock);
 
     executionContext = new StateTransitionExecutionContext();
+
+    fetchAssetLockTransactionOutput = (proof, context) => fetchAssetLockTransactionOutputDPP(
+      stateRepositoryMock,
+      proof,
+      context,
+    );
   });
 
   describe('InstantAssetLockProof', () => {
     let assetLockProofFixture;
 
     beforeEach(() => {
-      assetLockProofFixture = getInstantAssetLockProofFixture();
+      const assetLockProofFixtureJS = getInstantAssetLockProofFixture();
+      assetLockProofFixture = new InstantAssetLockProof(assetLockProofFixtureJS.toObject());
     });
 
     it('should return asset lock output', async () => {
@@ -47,34 +67,46 @@ describe('fetchAssetLockTransactionOutputFactory', () => {
 
     beforeEach(() => {
       const rawTransaction = '030000000137feb5676d0851337ea3c9a992496aab7a0b3eee60aeeb9774000b7f4bababa5000000006b483045022100d91557de37645c641b948c6cd03b4ae3791a63a650db3e2fee1dcf5185d1b10402200e8bd410bf516ca61715867666d31e44495428ce5c1090bf2294a829ebcfa4ef0121025c3cc7fbfc52f710c941497fd01876c189171ea227458f501afcb38a297d65b4ffffffff021027000000000000166a14152073ca2300a86b510fa2f123d3ea7da3af68dcf77cb0090a0000001976a914152073ca2300a86b510fa2f123d3ea7da3af68dc88ac00000000';
-      assetLockProofFixture = getChainAssetLockFixture();
-      stateRepositoryMock.fetchTransaction.resolves({
+      const assetLockProofFixtureJS = getChainAssetLockFixture();
+
+      const outPoint = Transaction
+        .parseOutPointBuffer(Buffer.from(assetLockProofFixtureJS.getOutPoint()));
+      ({ transactionHash } = outPoint);
+
+      const rawProof = assetLockProofFixtureJS.toObject();
+
+      // Change endianness of raw txId bytes in outPoint to match expectation of dashcore-rust
+      const txId = rawProof.outPoint.slice(0, 32);
+      const outputIndex = rawProof.outPoint.slice(32);
+      txId.reverse();
+      rawProof.outPoint = Buffer.concat([txId, outputIndex]);
+
+      assetLockProofFixture = new ChainAssetLockProof(rawProof);
+
+      stateRepositoryMock.fetchTransaction.returns({
         data: Buffer.from(rawTransaction, 'hex'),
         height: 42,
       });
 
       const transaction = new Transaction(rawTransaction);
       ([output] = transaction.outputs);
-
-      const outPoint = Transaction.parseOutPointBuffer(assetLockProofFixture.getOutPoint());
-      ({ transactionHash } = outPoint);
     });
 
-    it('should fetch output from state repository', async () => {
+    it('should fetch output from state repository', async function () {
       const assetLockTransactionOutput = await fetchAssetLockTransactionOutput(
         assetLockProofFixture,
         executionContext,
       );
 
-      expect(assetLockTransactionOutput).to.deep.equal(output);
+      expect(assetLockTransactionOutput).to.deep.equal(output.toObject());
 
       expect(stateRepositoryMock.fetchTransaction).to.be.calledOnceWithExactly(
         transactionHash,
-        executionContext,
+        this.sinonSandbox.match.instanceOf(StateTransitionExecutionContext),
       );
     });
 
-    it('should throw IdentityAssetLockTransactionIsNotFoundError when transaction is not found', async () => {
+    it('should throw AssetLockTransactionIsNotFoundError when transaction is not found', async () => {
       stateRepositoryMock.fetchTransaction.resolves(null);
 
       try {
@@ -83,14 +115,14 @@ describe('fetchAssetLockTransactionOutputFactory', () => {
           executionContext,
         );
 
-        expect.fail('should throw IdentityAssetLockTransactionIsNotFoundError');
+        expect.fail('should throw AssetLockTransactionIsNotFoundError');
       } catch (e) {
         expect(e).to.be.an.instanceOf(AssetLockTransactionIsNotFoundError);
         expect(e.getTransactionId()).to.deep.equal(transactionHash);
       }
     });
 
-    it('should return mocked output on dry run', async () => {
+    it('should return mocked output on dry run', async function () {
       executionContext.enableDryRun();
 
       const result = await fetchAssetLockTransactionOutput(
@@ -100,24 +132,36 @@ describe('fetchAssetLockTransactionOutputFactory', () => {
 
       executionContext.disableDryRun();
 
-      expect(result).to.deep.equal(new Output({
+      expect(result).to.deep.equal({
         satoshis: 1000,
-        script: new Script(),
-      }));
+        script: '',
+      });
 
       expect(stateRepositoryMock.fetchTransaction).to.be.calledOnceWithExactly(
         transactionHash,
-        executionContext,
+        this.sinonSandbox.match.instanceOf(StateTransitionExecutionContext),
       );
     });
   });
 
-  it('should throw UnknownAssetLockProofError for unknown assetLockProof', async function it() {
-    const type = 666;
+  it('should throw UnknownAssetLockProofTypeError for unknown assetLockProof', async () => {
+    try {
+      await fetchAssetLockTransactionOutput(
+        {},
+        executionContext,
+      );
+
+      expect.fail('should throw UnknownAssetLockProofTypeError');
+    } catch (e) {
+      expect(e).to.be.an.instanceOf(UnknownAssetLockProofTypeError);
+    }
+  });
+
+  it('should throw UnknownAssetLockProofTypeError for unknown assetLockProof type', async () => {
+    const type = 100;
 
-    const assetLockProofFixture = {
-      getType: this.sinonSandbox.stub().returns(type),
-    };
+    const assetLockProofFixture = new ChainAssetLockProof(getChainAssetLockFixture().toObject());
+    assetLockProofFixture.getType = () => type;
 
     try {
       await fetchAssetLockTransactionOutput(
@@ -125,9 +169,9 @@ describe('fetchAssetLockTransactionOutputFactory', () => {
         executionContext,
       );
 
-      expect.fail('should throw UnknownAssetLockProofError');
+      expect.fail('should throw UnknownAssetLockProofTypeError');
     } catch (e) {
-      expect(e).to.be.an.instanceOf(UnknownAssetLockProofError);
+      expect(e).to.be.an.instanceOf(UnknownAssetLockProofTypeError);
       expect(e.getType()).to.equal(type);
     }
   });