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

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

@@ -1,66 +1,76 @@
-const { Transaction } = require('@dashevo/dashcore-lib');
+const { Transaction, PrivateKey, Script } = require('@dashevo/dashcore-lib');
 
-const DashCoreLib = require('@dashevo/dashcore-lib');
-const validateAssetLockTransactionFactory = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/validateAssetLockTransactionFactory');
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-
-const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
-
-const InvalidIdentityAssetLockTransactionError = require('@dashevo/dpp/lib/errors/consensus/basic/identity/InvalidIdentityAssetLockTransactionError');
-const IdentityAssetLockTransactionOutputNotFoundError = require('@dashevo/dpp/lib/errors/consensus/basic/identity/IdentityAssetLockTransactionOutputNotFoundError');
-const IdentityAssetLockTransactionOutPointAlreadyExistsError = require('@dashevo/dpp/lib/errors/consensus/basic/identity/IdentityAssetLockTransactionOutPointAlreadyExistsError');
-const InvalidIdentityAssetLockTransactionOutputError = require('@dashevo/dpp/lib/errors/consensus/basic/identity/InvalidIdentityAssetLockTransactionOutputError');
-const InvalidAssetLockTransactionOutputReturnSizeError = require('@dashevo/dpp/lib/errors/consensus/basic/identity/InvalidAssetLockTransactionOutputReturnSizeError');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+const { expect } = require('chai');
+const { default: loadWasmDpp } = require('../../../../../dist');
+const { expectValidationError } = require('../../../../../lib/test/expect/expectError');
 
 describe('validateAssetLockTransactionFactory', () => {
   let stateRepositoryMock;
-  let validateAssetLockTransaction;
   let rawTransaction;
   let outputIndex;
-  let transactionInstance;
-  let transactionMock;
   let executionContext;
 
+  let StateTransitionExecutionContext;
+  let InvalidIdentityAssetLockTransactionError;
+  let IdentityAssetLockTransactionOutputNotFoundError;
+  let InvalidIdentityAssetLockTransactionOutputError;
+  let InvalidAssetLockTransactionOutputReturnSizeError;
+  let IdentityAssetLockTransactionOutPointAlreadyExistsError;
+  let TransactionDecodeError;
+  let ValidationResult;
+
+  let validateAssetLockTransaction;
+  let validateAssetLockTransactionDPP;
+
+  before(async () => {
+    ({
+      StateTransitionExecutionContext,
+      ValidationResult,
+      TransactionDecodeError,
+      InvalidIdentityAssetLockTransactionError,
+      IdentityAssetLockTransactionOutputNotFoundError,
+      InvalidIdentityAssetLockTransactionOutputError,
+      InvalidAssetLockTransactionOutputReturnSizeError,
+      IdentityAssetLockTransactionOutPointAlreadyExistsError,
+      validateAssetLockTransaction: validateAssetLockTransactionDPP,
+    } = await loadWasmDpp());
+  });
+
   beforeEach(function beforeEach() {
     rawTransaction = '030000000137feb5676d0851337ea3c9a992496aab7a0b3eee60aeeb9774000b7f4bababa5000000006b483045022100d91557de37645c641b948c6cd03b4ae3791a63a650db3e2fee1dcf5185d1b10402200e8bd410bf516ca61715867666d31e44495428ce5c1090bf2294a829ebcfa4ef0121025c3cc7fbfc52f710c941497fd01876c189171ea227458f501afcb38a297d65b4ffffffff021027000000000000166a14152073ca2300a86b510fa2f123d3ea7da3af68dcf77cb0090a0000001976a914152073ca2300a86b510fa2f123d3ea7da3af68dc88ac00000000';
     outputIndex = 0;
-    transactionInstance = new Transaction(rawTransaction);
 
     executionContext = new StateTransitionExecutionContext();
 
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
 
-    stateRepositoryMock.isAssetLockTransactionOutPointAlreadyUsed.returns(false);
+    stateRepositoryMock.isAssetLockTransactionOutPointAlreadyUsed.resolves(false);
 
-    validateAssetLockTransaction = validateAssetLockTransactionFactory(stateRepositoryMock);
-  });
-
-  afterEach(() => {
-    if (transactionMock) {
-      transactionMock.restore();
-    }
+    validateAssetLockTransaction = (tx, index, context) => validateAssetLockTransactionDPP(
+      stateRepositoryMock,
+      tx,
+      index,
+      context,
+    );
   });
 
   it('should be valid transaction', async () => {
     rawTransaction = '030000000137feb5676d085133';
 
-    validateAssetLockTransaction = validateAssetLockTransactionFactory(stateRepositoryMock);
-
     const result = await validateAssetLockTransaction(
       rawTransaction,
       outputIndex,
       executionContext,
     );
 
-    expectValidationError(result, InvalidIdentityAssetLockTransactionError);
+    await expectValidationError(result, InvalidIdentityAssetLockTransactionError);
 
     const [error] = result.getErrors();
 
     expect(error.getCode()).to.equal(1038);
-    expect(error.getValidationError()).to.be.instanceOf(Error);
+    expect(error.getValidationError()).to.be.instanceOf(TransactionDecodeError);
 
     expect(result.getData()).to.be.undefined();
     expect(stateRepositoryMock.isAssetLockTransactionOutPointAlreadyUsed).to.not.be.called();
@@ -75,7 +85,7 @@ describe('validateAssetLockTransactionFactory', () => {
       executionContext,
     );
 
-    expectValidationError(result, IdentityAssetLockTransactionOutputNotFoundError);
+    await expectValidationError(result, IdentityAssetLockTransactionOutputNotFoundError);
 
     const [error] = result.getErrors();
 
@@ -86,30 +96,19 @@ describe('validateAssetLockTransactionFactory', () => {
     expect(stateRepositoryMock.isAssetLockTransactionOutPointAlreadyUsed).to.not.be.called();
   });
 
-  it('should point to output with OR_RETURN', async function it() {
-    const isDataOut = this.sinonSandbox.stub().returns(false);
-
-    const stubInstance = this.sinonSandbox.createStubInstance(Transaction);
-
-    stubInstance.outputs = [{
-      script: {
-        isDataOut,
-      },
-    }];
-
-    stubInstance.getOutPointBuffer.returns(transactionInstance.getOutPointBuffer(outputIndex));
-
-    transactionMock = this.sinonSandbox.stub(DashCoreLib, 'Transaction').returns(
-      stubInstance,
-    );
+  it('should point to output with OR_RETURN', async () => {
+    const regularTransaction = new Transaction(Buffer.from(rawTransaction, 'hex'));
+    // Mess up expected TX output script
+    regularTransaction.outputs[0]
+      .setScript(Script.buildPublicKeyHashOut(new PrivateKey().toAddress()).toString());
 
     const result = await validateAssetLockTransaction(
-      rawTransaction,
+      regularTransaction.toBuffer().toString('hex'),
       outputIndex,
       executionContext,
     );
 
-    expectValidationError(result, InvalidIdentityAssetLockTransactionOutputError);
+    await expectValidationError(result, InvalidIdentityAssetLockTransactionOutputError);
 
     const [error] = result.getErrors();
 
@@ -117,30 +116,18 @@ describe('validateAssetLockTransactionFactory', () => {
     expect(error.getOutputIndex()).to.equal(outputIndex);
   });
 
-  it('should contain valid public key hash', async function it() {
-    const isDataOut = this.sinonSandbox.stub().returns(true);
-    const getData = this.sinonSandbox.stub().returns(Buffer.alloc(0));
-
-    const stubInstance = this.sinonSandbox.createStubInstance(Transaction);
-    stubInstance.outputs = [{
-      script: {
-        isDataOut,
-        getData,
-      },
-    }];
-    stubInstance.getOutPointBuffer.returns(transactionInstance.getOutPointBuffer(outputIndex));
-
-    transactionMock = this.sinonSandbox.stub(DashCoreLib, 'Transaction').returns(
-      stubInstance,
-    );
+  it('should contain valid public key hash', async () => {
+    const regularTransaction = new Transaction(Buffer.from(rawTransaction, 'hex'));
+    regularTransaction.outputs[0]
+      .setScript(Script.buildDataOut(Buffer.alloc(0)));
 
     const result = await validateAssetLockTransaction(
-      rawTransaction,
+      regularTransaction.toBuffer().toString('hex'),
       outputIndex,
       executionContext,
     );
 
-    expectValidationError(result, InvalidAssetLockTransactionOutputReturnSizeError);
+    await expectValidationError(result, InvalidAssetLockTransactionOutputReturnSizeError);
 
     const [error] = result.getErrors();
 
@@ -148,8 +135,8 @@ describe('validateAssetLockTransactionFactory', () => {
     expect(error.getOutputIndex()).to.equal(outputIndex);
   });
 
-  it('should return IdentityAssetLockTransactionOutPointAlreadyExistsError if outPoint was already used', async () => {
-    stateRepositoryMock.isAssetLockTransactionOutPointAlreadyUsed.returns(true);
+  it('should return IdentityAssetLockTransactionOutPointAlreadyExistsError if outPoint was already used', async function () {
+    stateRepositoryMock.isAssetLockTransactionOutPointAlreadyUsed.resolves(true);
 
     const result = await validateAssetLockTransaction(
       rawTransaction,
@@ -157,7 +144,7 @@ describe('validateAssetLockTransactionFactory', () => {
       executionContext,
     );
 
-    expectValidationError(result, IdentityAssetLockTransactionOutPointAlreadyExistsError);
+    await expectValidationError(result, IdentityAssetLockTransactionOutPointAlreadyExistsError);
 
     const [error] = result.getErrors();
 
@@ -165,19 +152,19 @@ describe('validateAssetLockTransactionFactory', () => {
 
     const transaction = new Transaction(rawTransaction);
 
-    expect(Buffer.isBuffer(error.getTransactionId())).to.be.true();
     expect(error.getTransactionId()).to.deep.equal(Buffer.from(transaction.id, 'hex'));
     expect(error.getOutputIndex()).to.deep.equal(outputIndex);
 
     expect(result.getData()).to.be.undefined();
     expect(stateRepositoryMock.isAssetLockTransactionOutPointAlreadyUsed)
       .to.be.calledOnceWithExactly(
-        transaction.getOutPointBuffer(outputIndex),
-        executionContext,
+        this.sinonSandbox.match((val) => Buffer.from(val)
+          .equals(transaction.getOutPointBuffer(outputIndex))),
+        this.sinonSandbox.match.instanceOf(StateTransitionExecutionContext),
       );
   });
 
-  it('should return valid result', async () => {
+  it('should return valid result', async function () {
     const result = await validateAssetLockTransaction(
       rawTransaction,
       outputIndex,
@@ -193,13 +180,14 @@ describe('validateAssetLockTransactionFactory', () => {
 
     expect(stateRepositoryMock.isAssetLockTransactionOutPointAlreadyUsed)
       .to.be.calledOnceWithExactly(
-        initialTransaction.getOutPointBuffer(outputIndex),
-        executionContext,
+        this.sinonSandbox.match((val) => Buffer.from(val)
+          .equals(initialTransaction.getOutPointBuffer(outputIndex))),
+        this.sinonSandbox.match.instanceOf(StateTransitionExecutionContext),
       );
 
     const { transaction, publicKeyHash } = result.getData();
     expect(publicKeyHash).to.deep.equal(initialPublicKeyHash);
-    expect(transaction).to.be.an.instanceOf(Transaction);
-    expect(transaction.toJSON()).to.deep.equal(initialTransaction.toJSON());
+    expect(new Transaction(Buffer.from(transaction)).toJSON())
+      .to.deep.equal(initialTransaction.toJSON());
   });
 });

package/test/integration/identity/stateTransition/validatePublicKeySignaturesFactory.spec.js

@@ -3,59 +3,86 @@ const { PrivateKey, crypto: { Hash } } = require('@dashevo/dashcore-lib');
 const crypto = require('crypto');
 
 const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
-const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
 const BlsSignatures = require('@dashevo/dpp/lib/bls/bls');
-const validatePublicKeySignaturesFactory = require('@dashevo/dpp/lib/identity/stateTransition/validatePublicKeySignaturesFactory');
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
-const InvalidIdentityKeySignatureError = require('@dashevo/dpp/lib/errors/consensus/basic/identity/InvalidIdentityKeySignatureError');
+
+const { expect } = require('chai');
+const { expectValidationError } = require('../../../../lib/test/expect/expectError');
+const getBlsAdapterMock = require('../../../../lib/test/mocks/getBlsAdapterMock');
+
+const { default: loadWasmDpp } = require('../../../../dist');
 
 describe('validatePublicKeySignaturesFactory', () => {
   let identityCreateTransition;
   let rawIdentityCreateTransition;
   let validatePublicKeySignatures;
 
-  beforeEach(async function beforeEach() {
-    identityCreateTransition = getIdentityCreateTransitionFixture();
+  let IdentityCreateTransition;
+  let IdentityPublicKey;
+  let IdentityPublicKeyCreateTransition;
+  let InvalidIdentityKeySignatureError;
+  let ValidationResult;
+  let PublicKeysSignaturesValidator;
+  let blsAdapter;
+
+  before(async () => {
+    ({
+      IdentityCreateTransition,
+      IdentityPublicKey,
+      IdentityPublicKeyCreateTransition,
+      InvalidIdentityKeySignatureError,
+      PublicKeysSignaturesValidator,
+      ValidationResult,
+    } = await loadWasmDpp());
+  });
+
+  beforeEach(async () => {
+    identityCreateTransition = new IdentityCreateTransition(
+      getIdentityCreateTransitionFixture().toObject(),
+    );
 
-    const privateKey1 = new PrivateKey();
+    const privateKey1 = new PrivateKey('17e0b1703e226204c557bce68b0871683ea409ae90c7a733b72a33f7c129c959');
     const publicKey1 = privateKey1.toPublicKey();
 
-    const identityPublicKey1 = new IdentityPublicKey({
+    const identityPublicKey1 = new IdentityPublicKeyCreateTransition({
       id: 0,
       type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
       data: publicKey1.toBuffer(),
       purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
       securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
       readOnly: false,
+      signature: Buffer.alloc(0),
     });
 
-    const privateKey2 = new PrivateKey();
+    const privateKey2 = new PrivateKey('afc20afac882f676af5a268a2eca9c763996c36dbeb3660648df2108006820c7');
     const publicKey2 = privateKey2.toPublicKey();
 
-    const identityPublicKey2 = new IdentityPublicKey({
+    const identityPublicKey2 = new IdentityPublicKeyCreateTransition({
       id: 1,
       type: IdentityPublicKey.TYPES.ECDSA_HASH160,
       data: Hash.sha256ripemd160(publicKey2.toBuffer()),
       purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
       securityLevel: IdentityPublicKey.SECURITY_LEVELS.CRITICAL,
       readOnly: false,
+      signature: Buffer.alloc(0),
     });
 
-    const { PrivateKey: BlsPrivateKey } = await BlsSignatures.getInstance();
+    const blsModule = await BlsSignatures.getInstance();
+    blsAdapter = await getBlsAdapterMock();
+
+    const { BasicSchemeMPL } = blsModule;
 
     const randomBytes = new Uint8Array(crypto.randomBytes(256));
-    const privateKey3 = BlsPrivateKey.fromBytes(randomBytes, true);
-    // blsPrivateKeyHex = Buffer.from(blsPrivateKey.serialize()).toString('hex');
-    const publicKey3 = privateKey3.getPublicKey();
+    const privateKey3 = BasicSchemeMPL.keyGen(randomBytes);
+    const publicKey3 = privateKey3.getG1();
 
-    const identityPublicKey3 = new IdentityPublicKey({
+    const identityPublicKey3 = new IdentityPublicKeyCreateTransition({
       id: 2,
       type: IdentityPublicKey.TYPES.BLS12_381,
       data: Buffer.from(publicKey3.serialize()),
       purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
       securityLevel: IdentityPublicKey.SECURITY_LEVELS.CRITICAL,
       readOnly: false,
+      signature: Buffer.alloc(0),
     });
 
     identityCreateTransition.setPublicKeys([
@@ -65,14 +92,14 @@ describe('validatePublicKeySignaturesFactory', () => {
     ]);
 
     await identityCreateTransition.signByPrivateKey(
-      privateKey1,
+      privateKey1.toBuffer(),
       IdentityPublicKey.TYPES.ECDSA_SECP256K1,
     );
 
     const signature1 = identityCreateTransition.getSignature();
 
     await identityCreateTransition.signByPrivateKey(
-      privateKey2,
+      privateKey2.toBuffer(),
       IdentityPublicKey.TYPES.ECDSA_HASH160,
     );
 
@@ -81,6 +108,7 @@ describe('validatePublicKeySignaturesFactory', () => {
     await identityCreateTransition.signByPrivateKey(
       Buffer.from(privateKey3.serialize()),
       IdentityPublicKey.TYPES.BLS12_381,
+      blsAdapter,
     );
 
     const signature3 = identityCreateTransition.getSignature();
@@ -89,11 +117,21 @@ describe('validatePublicKeySignaturesFactory', () => {
     identityPublicKey2.setSignature(signature2);
     identityPublicKey3.setSignature(signature3);
 
+    identityCreateTransition.setPublicKeys([
+      identityPublicKey1,
+      identityPublicKey2,
+      identityPublicKey3,
+    ]);
+
     rawIdentityCreateTransition = identityCreateTransition.toObject();
 
-    const createStateTransitionMock = this.sinonSandbox.stub().resolves(identityCreateTransition);
+    const validator = new PublicKeysSignaturesValidator(blsAdapter);
+    validatePublicKeySignatures = (
+      stateTransition, keys,
+    ) => validator.validate(stateTransition, keys);
 
-    validatePublicKeySignatures = validatePublicKeySignaturesFactory(createStateTransitionMock);
+    privateKey3.delete();
+    publicKey3.delete();
   });
 
   it('should return InvalidIdentityKeySignatureError if signature is not valid', async () => {
@@ -104,10 +142,9 @@ describe('validatePublicKeySignaturesFactory', () => {
     const result = await validatePublicKeySignatures(
       rawIdentityCreateTransition,
       rawIdentityCreateTransition.publicKeys,
-      identityCreateTransition.getExecutionContext(),
     );
 
-    expectValidationError(result, InvalidIdentityKeySignatureError);
+    await expectValidationError(result, InvalidIdentityKeySignatureError);
 
     const error = result.getFirstError();
 
@@ -118,7 +155,7 @@ describe('validatePublicKeySignaturesFactory', () => {
     const result = await validatePublicKeySignatures(
       rawIdentityCreateTransition,
       rawIdentityCreateTransition.publicKeys,
-      identityCreateTransition.getExecutionContext(),
+      blsAdapter,
     );
 
     expect(result).to.be.instanceOf(ValidationResult);