@dashevo/wasm-dpp 0.25.0-dev.8 → 0.25.0-pr.1545.2

package/lib/bls/bls.js

@@ -0,0 +1,48 @@
+const EventEmitter = require('events');
+const BlsSignatures = require('@dashevo/bls');
+
+const eventNames = {
+  LOADED_EVENT: 'LOADED',
+};
+
+const events = new EventEmitter();
+let isLoading = false;
+let instance = null;
+
+function compileWasmModule() {
+  isLoading = true;
+  return BlsSignatures().then((loadedInstance) => {
+    instance = loadedInstance;
+    isLoading = false;
+    events.emit(eventNames.LOADED_EVENT);
+  });
+}
+
+const bls = {
+  /**
+   * Compiles BlsSignature instance if it wasn't compiled yet
+   * and returns module instance
+   * @return {Promise<BlsSignatures>}
+   */
+  getInstance() {
+    return new Promise((resolve) => {
+      if (instance) {
+        resolve(instance);
+
+        return;
+      }
+
+      if (isLoading) {
+        events.once(eventNames.LOADED_EVENT, () => {
+          resolve(instance);
+        });
+      } else {
+        compileWasmModule().then(() => {
+          resolve(instance);
+        });
+      }
+    });
+  },
+};
+
+module.exports = bls;

package/lib/dpp.ts

@@ -31,4 +31,4 @@ export declare class IdentityPublicKey extends dpp_module.IdentityPublicKey {
 
 // TypeScript voodoo to ensure Identifier and IdentifierError are exported
 export declare class Identifier extends _Identifier {}
-export declare class IdentifierError extends _IdentifierError {}
+export declare class IdentifierError extends _IdentifierError {}

package/lib/errors/patchConsensusErrors.ts

@@ -3,97 +3,98 @@ import { extend } from "../utils/extend";
 import { AbstractConsensusError } from "./AbstractConsensusError";
 
 export function patchConsensusErrors() {
-    extend(dpp_module.ProtocolVersionParsingError, AbstractConsensusError);
-    extend(dpp_module.UnsupportedProtocolVersionError, AbstractConsensusError);
-    extend(dpp_module.IncompatibleProtocolVersionError, AbstractConsensusError);
-    extend(dpp_module.SerializedObjectParsingError, AbstractConsensusError);
-    extend(dpp_module.JsonSchemaError, AbstractConsensusError);
-    extend(dpp_module.InvalidIdentifierError, AbstractConsensusError);
-    extend(dpp_module.DataContractMaxDepthExceedError, AbstractConsensusError);
-    extend(dpp_module.DuplicateIndexError, AbstractConsensusError);
-    extend(dpp_module.InvalidCompoundIndexError, AbstractConsensusError);
-    extend(dpp_module.InvalidDataContractIdError, AbstractConsensusError);
-    extend(dpp_module.InvalidIndexedPropertyConstraintError, AbstractConsensusError);
-    extend(dpp_module.InvalidIndexPropertyTypeError, AbstractConsensusError);
-    extend(dpp_module.SystemPropertyIndexAlreadyPresentError, AbstractConsensusError);
-    extend(dpp_module.UndefinedIndexPropertyError, AbstractConsensusError);
-    extend(dpp_module.UniqueIndicesLimitReachedError, AbstractConsensusError);
-    extend(dpp_module.InconsistentCompoundIndexDataError, AbstractConsensusError);
-    extend(dpp_module.InvalidDocumentTransitionActionError, AbstractConsensusError);
-    extend(dpp_module.InvalidDocumentTransitionIdError, AbstractConsensusError);
-    extend(dpp_module.DataContractNotPresentError, AbstractConsensusError);
-    extend(dpp_module.InvalidDocumentTypeError, AbstractConsensusError);
-    extend(dpp_module.MissingDataContractIdError, AbstractConsensusError);
-    extend(dpp_module.MissingDocumentTransitionActionError, AbstractConsensusError);
-    extend(dpp_module.MissingDocumentTransitionTypeError, AbstractConsensusError);
-    extend(dpp_module.MissingDocumentTypeError, AbstractConsensusError);
-    extend(dpp_module.DuplicatedIdentityPublicKeyError, AbstractConsensusError);
-    extend(dpp_module.DuplicatedIdentityPublicKeyIdError, AbstractConsensusError);
-    extend(dpp_module.MissingMasterPublicKeyError, AbstractConsensusError);
-    extend(dpp_module.IdentityAssetLockProofLockedTransactionMismatchError, AbstractConsensusError);
-    extend(dpp_module.IdentityAssetLockTransactionIsNotFoundError, AbstractConsensusError);
-    extend(dpp_module.IdentityAssetLockTransactionOutPointAlreadyExistsError, AbstractConsensusError);
-    extend(dpp_module.IdentityAssetLockTransactionOutputNotFoundError, AbstractConsensusError);
-    extend(dpp_module.InvalidAssetLockProofCoreChainHeightError, AbstractConsensusError);
-    extend(dpp_module.InvalidAssetLockProofTransactionHeightError, AbstractConsensusError);
-    extend(dpp_module.InvalidIdentityAssetLockTransactionError, AbstractConsensusError);
-    extend(dpp_module.InvalidIdentityAssetLockTransactionOutputError, AbstractConsensusError);
-    extend(dpp_module.InvalidIdentityPublicKeyDataError, AbstractConsensusError);
-    extend(dpp_module.InvalidIdentityPublicKeySecurityLevelError, AbstractConsensusError);
-    extend(dpp_module.InvalidStateTransitionTypeError, AbstractConsensusError);
-    extend(dpp_module.MissingStateTransitionTypeError, AbstractConsensusError);
-    extend(dpp_module.StateTransitionMaxSizeExceededError, AbstractConsensusError);
-    extend(dpp_module.IdentityNotFoundError, AbstractConsensusError);
-    extend(dpp_module.InvalidIdentityPublicKeyTypeError, AbstractConsensusError);
-    extend(dpp_module.InvalidStateTransitionSignatureError, AbstractConsensusError);
-    extend(dpp_module.MissingPublicKeyError, AbstractConsensusError);
-    extend(dpp_module.BalanceIsNotEnoughError, AbstractConsensusError);
-    extend(dpp_module.DataContractAlreadyPresentError, AbstractConsensusError);
-    extend(dpp_module.DataTriggerConditionError, AbstractConsensusError);
-    extend(dpp_module.DataTriggerExecutionError, AbstractConsensusError);
-    extend(dpp_module.DataTriggerInvalidResultError, AbstractConsensusError);
-    extend(dpp_module.DocumentAlreadyPresentError, AbstractConsensusError);
-    extend(dpp_module.DocumentNotFoundError, AbstractConsensusError);
-    extend(dpp_module.DocumentOwnerIdMismatchError, AbstractConsensusError);
-    extend(dpp_module.DocumentTimestampsMismatchError, AbstractConsensusError);
-    extend(dpp_module.DocumentTimestampWindowViolationError, AbstractConsensusError);
-    extend(dpp_module.DuplicateUniqueIndexError, AbstractConsensusError);
-    extend(dpp_module.InvalidDocumentRevisionError, AbstractConsensusError);
-    extend(dpp_module.IdentityAlreadyExistsError, AbstractConsensusError);
-    extend(dpp_module.InvalidJsonSchemaRefError, AbstractConsensusError);
-    extend(dpp_module.JsonSchemaCompilationError, AbstractConsensusError);
-    extend(dpp_module.DuplicateDocumentTransitionsWithIdsError, AbstractConsensusError);
-    extend(dpp_module.DuplicateDocumentTransitionsWithIndicesError, AbstractConsensusError);
-    extend(dpp_module.InvalidAssetLockTransactionOutputReturnSizeError, AbstractConsensusError);
-    extend(dpp_module.InvalidInstantAssetLockProofError, AbstractConsensusError);
-    extend(dpp_module.InvalidInstantAssetLockProofSignatureError, AbstractConsensusError);
-    extend(dpp_module.IncompatibleRe2PatternError, AbstractConsensusError);
-    extend(dpp_module.InvalidDataContractVersionError, AbstractConsensusError);
-    extend(dpp_module.IncompatibleDataContractSchemaError, AbstractConsensusError);
-    extend(dpp_module.DataContractImmutablePropertiesUpdateError, AbstractConsensusError);
-    extend(dpp_module.DataContractUniqueIndicesChangedError, AbstractConsensusError);
-    extend(dpp_module.DuplicateIndexNameError, AbstractConsensusError);
-    extend(dpp_module.DataContractInvalidIndexDefinitionUpdateError, AbstractConsensusError);
-    extend(dpp_module.DataContractHaveNewUniqueIndexError, AbstractConsensusError);
-    extend(dpp_module.IdentityPublicKeyDisabledAtWindowViolationError, AbstractConsensusError);
-    extend(dpp_module.IdentityPublicKeyIsReadOnlyError, AbstractConsensusError);
-    extend(dpp_module.InvalidIdentityPublicKeyIdError, AbstractConsensusError);
-    extend(dpp_module.InvalidIdentityRevisionError, AbstractConsensusError);
-    extend(dpp_module.MaxIdentityPublicKeyLimitReachedError, AbstractConsensusError);
-    extend(dpp_module.InvalidIdentityKeySignatureError, AbstractConsensusError);
-    extend(dpp_module.InvalidSignaturePublicKeySecurityLevelError, AbstractConsensusError);
-    extend(dpp_module.PublicKeyIsDisabledError, AbstractConsensusError);
-    extend(dpp_module.PublicKeySecurityLevelNotMetError, AbstractConsensusError);
-    extend(dpp_module.WrongPublicKeyPurposeError, AbstractConsensusError);
-    extend(dpp_module.IdentityPublicKeyIsDisabledError, AbstractConsensusError);
-    extend(dpp_module.ValueError, AbstractConsensusError);
-    extend(dpp_module.MissingDataContractIdError, AbstractConsensusError);
-    extend(dpp_module.DuplicatedIdentityPublicKeyError, AbstractConsensusError);
-    extend(dpp_module.DuplicatedIdentityPublicKeyIdError, AbstractConsensusError);
-    extend(dpp_module.IdentityInsufficientBalanceError, AbstractConsensusError);
-    extend(dpp_module.InvalidIdentityCreditWithdrawalTransitionCoreFeeError, AbstractConsensusError);
-    extend(dpp_module.InvalidIdentityCreditWithdrawalTransitionOutputScriptError, AbstractConsensusError);
-    extend(dpp_module.NotImplementedIdentityCreditWithdrawalTransitionPoolingError, AbstractConsensusError);
-    extend(dpp_module.DuplicatedIdentityPublicKeyIdStateError, AbstractConsensusError);
-    extend(dpp_module.DuplicatedIdentityPublicKeyStateError, AbstractConsensusError);
+    // TODO(versioning): restore this
+    // extend(dpp_module.ProtocolVersionParsingError, AbstractConsensusError);
+    // extend(dpp_module.UnsupportedProtocolVersionError, AbstractConsensusError);
+    // extend(dpp_module.IncompatibleProtocolVersionError, AbstractConsensusError);
+    // extend(dpp_module.SerializedObjectParsingError, AbstractConsensusError);
+    // extend(dpp_module.JsonSchemaError, AbstractConsensusError);
+    // extend(dpp_module.InvalidIdentifierError, AbstractConsensusError);
+    // extend(dpp_module.DataContractMaxDepthExceedError, AbstractConsensusError);
+    // extend(dpp_module.DuplicateIndexError, AbstractConsensusError);
+    // extend(dpp_module.InvalidCompoundIndexError, AbstractConsensusError);
+    // extend(dpp_module.InvalidDataContractIdError, AbstractConsensusError);
+    // extend(dpp_module.InvalidIndexedPropertyConstraintError, AbstractConsensusError);
+    // extend(dpp_module.InvalidIndexPropertyTypeError, AbstractConsensusError);
+    // extend(dpp_module.SystemPropertyIndexAlreadyPresentError, AbstractConsensusError);
+    // extend(dpp_module.UndefinedIndexPropertyError, AbstractConsensusError);
+    // extend(dpp_module.UniqueIndicesLimitReachedError, AbstractConsensusError);
+    // extend(dpp_module.InconsistentCompoundIndexDataError, AbstractConsensusError);
+    // extend(dpp_module.InvalidDocumentTransitionActionError, AbstractConsensusError);
+    // extend(dpp_module.InvalidDocumentTransitionIdError, AbstractConsensusError);
+    // extend(dpp_module.DataContractNotPresentError, AbstractConsensusError);
+    // extend(dpp_module.InvalidDocumentTypeError, AbstractConsensusError);
+    // extend(dpp_module.MissingDataContractIdError, AbstractConsensusError);
+    // extend(dpp_module.MissingDocumentTransitionActionError, AbstractConsensusError);
+    // extend(dpp_module.MissingDocumentTransitionTypeError, AbstractConsensusError);
+    // extend(dpp_module.MissingDocumentTypeError, AbstractConsensusError);
+    // extend(dpp_module.DuplicatedIdentityPublicKeyError, AbstractConsensusError);
+    // extend(dpp_module.DuplicatedIdentityPublicKeyIdError, AbstractConsensusError);
+    // extend(dpp_module.MissingMasterPublicKeyError, AbstractConsensusError);
+    // extend(dpp_module.IdentityAssetLockProofLockedTransactionMismatchError, AbstractConsensusError);
+    // extend(dpp_module.IdentityAssetLockTransactionIsNotFoundError, AbstractConsensusError);
+    // extend(dpp_module.IdentityAssetLockTransactionOutPointAlreadyExistsError, AbstractConsensusError);
+    // extend(dpp_module.IdentityAssetLockTransactionOutputNotFoundError, AbstractConsensusError);
+    // extend(dpp_module.InvalidAssetLockProofCoreChainHeightError, AbstractConsensusError);
+    // extend(dpp_module.InvalidAssetLockProofTransactionHeightError, AbstractConsensusError);
+    // extend(dpp_module.InvalidIdentityAssetLockTransactionError, AbstractConsensusError);
+    // extend(dpp_module.InvalidIdentityAssetLockTransactionOutputError, AbstractConsensusError);
+    // extend(dpp_module.InvalidIdentityPublicKeyDataError, AbstractConsensusError);
+    // extend(dpp_module.InvalidIdentityPublicKeySecurityLevelError, AbstractConsensusError);
+    // extend(dpp_module.InvalidStateTransitionTypeError, AbstractConsensusError);
+    // extend(dpp_module.MissingStateTransitionTypeError, AbstractConsensusError);
+    // extend(dpp_module.StateTransitionMaxSizeExceededError, AbstractConsensusError);
+    // extend(dpp_module.IdentityNotFoundError, AbstractConsensusError);
+    // extend(dpp_module.InvalidIdentityPublicKeyTypeError, AbstractConsensusError);
+    // extend(dpp_module.InvalidStateTransitionSignatureError, AbstractConsensusError);
+    // extend(dpp_module.MissingPublicKeyError, AbstractConsensusError);
+    // extend(dpp_module.BalanceIsNotEnoughError, AbstractConsensusError);
+    // extend(dpp_module.DataContractAlreadyPresentError, AbstractConsensusError);
+    // extend(dpp_module.DataTriggerConditionError, AbstractConsensusError);
+    // extend(dpp_module.DataTriggerExecutionError, AbstractConsensusError);
+    // extend(dpp_module.DataTriggerInvalidResultError, AbstractConsensusError);
+    // extend(dpp_module.DocumentAlreadyPresentError, AbstractConsensusError);
+    // extend(dpp_module.DocumentNotFoundError, AbstractConsensusError);
+    // extend(dpp_module.DocumentOwnerIdMismatchError, AbstractConsensusError);
+    // extend(dpp_module.DocumentTimestampsMismatchError, AbstractConsensusError);
+    // extend(dpp_module.DocumentTimestampWindowViolationError, AbstractConsensusError);
+    // extend(dpp_module.DuplicateUniqueIndexError, AbstractConsensusError);
+    // extend(dpp_module.InvalidDocumentRevisionError, AbstractConsensusError);
+    // extend(dpp_module.IdentityAlreadyExistsError, AbstractConsensusError);
+    // extend(dpp_module.InvalidJsonSchemaRefError, AbstractConsensusError);
+    // extend(dpp_module.JsonSchemaCompilationError, AbstractConsensusError);
+    // extend(dpp_module.DuplicateDocumentTransitionsWithIdsError, AbstractConsensusError);
+    // extend(dpp_module.DuplicateDocumentTransitionsWithIndicesError, AbstractConsensusError);
+    // extend(dpp_module.InvalidAssetLockTransactionOutputReturnSizeError, AbstractConsensusError);
+    // extend(dpp_module.InvalidInstantAssetLockProofError, AbstractConsensusError);
+    // extend(dpp_module.InvalidInstantAssetLockProofSignatureError, AbstractConsensusError);
+    // extend(dpp_module.IncompatibleRe2PatternError, AbstractConsensusError);
+    // extend(dpp_module.InvalidDataContractVersionError, AbstractConsensusError);
+    // extend(dpp_module.IncompatibleDataContractSchemaError, AbstractConsensusError);
+    // extend(dpp_module.DataContractImmutablePropertiesUpdateError, AbstractConsensusError);
+    // extend(dpp_module.DataContractUniqueIndicesChangedError, AbstractConsensusError);
+    // extend(dpp_module.DuplicateIndexNameError, AbstractConsensusError);
+    // extend(dpp_module.DataContractInvalidIndexDefinitionUpdateError, AbstractConsensusError);
+    // extend(dpp_module.DataContractHaveNewUniqueIndexError, AbstractConsensusError);
+    // extend(dpp_module.IdentityPublicKeyDisabledAtWindowViolationError, AbstractConsensusError);
+    // extend(dpp_module.IdentityPublicKeyIsReadOnlyError, AbstractConsensusError);
+    // extend(dpp_module.InvalidIdentityPublicKeyIdError, AbstractConsensusError);
+    // extend(dpp_module.InvalidIdentityRevisionError, AbstractConsensusError);
+    // extend(dpp_module.MaxIdentityPublicKeyLimitReachedError, AbstractConsensusError);
+    // extend(dpp_module.InvalidIdentityKeySignatureError, AbstractConsensusError);
+    // extend(dpp_module.InvalidSignaturePublicKeySecurityLevelError, AbstractConsensusError);
+    // extend(dpp_module.PublicKeyIsDisabledError, AbstractConsensusError);
+    // extend(dpp_module.PublicKeySecurityLevelNotMetError, AbstractConsensusError);
+    // extend(dpp_module.WrongPublicKeyPurposeError, AbstractConsensusError);
+    // extend(dpp_module.IdentityPublicKeyIsDisabledError, AbstractConsensusError);
+    // extend(dpp_module.ValueError, AbstractConsensusError);
+    // extend(dpp_module.MissingDataContractIdError, AbstractConsensusError);
+    // extend(dpp_module.DuplicatedIdentityPublicKeyError, AbstractConsensusError);
+    // extend(dpp_module.DuplicatedIdentityPublicKeyIdError, AbstractConsensusError);
+    // extend(dpp_module.IdentityInsufficientBalanceError, AbstractConsensusError);
+    // extend(dpp_module.InvalidIdentityCreditWithdrawalTransitionCoreFeeError, AbstractConsensusError);
+    // extend(dpp_module.InvalidIdentityCreditWithdrawalTransitionOutputScriptError, AbstractConsensusError);
+    // extend(dpp_module.NotImplementedIdentityCreditWithdrawalTransitionPoolingError, AbstractConsensusError);
+    // extend(dpp_module.DuplicatedIdentityPublicKeyIdStateError, AbstractConsensusError);
+    // extend(dpp_module.DuplicatedIdentityPublicKeyStateError, AbstractConsensusError);
 }

package/lib/test/bootstrap.js

@@ -6,6 +6,7 @@ const chaiAsPromised = require('chai-as-promised');
 const chaiString = require('chai-string');
 const chaiExclude = require('chai-exclude');
 const crypto = require('crypto');
+const { default: loadDpp } = require('@dashevo/wasm-dpp');
 
 use(sinonChai);
 use(chaiAsPromised);
@@ -17,6 +18,10 @@ use(chaiExclude);
 // TODO this should be loaded with library - not with tests.
 globalThis.crypto = crypto.webcrypto;
 
+before(async function before() {
+  await loadDpp();
+});
+
 beforeEach(function beforeEach() {
   if (!this.sinonSandbox) {
     this.sinonSandbox = sinon.createSandbox();

package/lib/test/fixtures/getChainAssetLockProofFixture.js

@@ -1 +1,20 @@
-module.exports = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
+const { ChainAssetLockProof } = require('../../..');
+
+function getChainAssetLockProofFixture() {
+  const outPoint = {
+    outpointHash: '6e200d059fb567ba19e92f5c2dcd3dde522fd4e0a50af223752db16158dabb1d',
+    outpointIndex: 0,
+  };
+
+  const binaryTransactionHash = Buffer.from(outPoint.outpointHash, 'hex');
+  const indexBuffer = Buffer.alloc(4);
+
+  indexBuffer.writeUInt32LE(outPoint.outpointIndex, 0);
+
+  return new ChainAssetLockProof({
+    coreChainLockedHeight: 42,
+    outPoint: Buffer.concat([binaryTransactionHash, indexBuffer]),
+  });
+}
+
+module.exports = getChainAssetLockProofFixture;

package/lib/test/fixtures/getDataContractFixture.js

@@ -1,9 +1,7 @@
 const crypto = require('crypto');
-const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-const JsIdentifier = require('@dashevo/dpp/lib/identifier/Identifier');
 const generateRandomIdentifierAsync = require('../utils/generateRandomIdentifierAsync');
 const { default: loadWasmDpp } = require('../../..');
-let { DataContractFactory, DataContractValidator } = require('../../..');
+const { DataContractFactory, getLatestProtocolVersion, Identifier } = require('../../..');
 
 let randomOwnerId = null;
 
@@ -13,7 +11,7 @@ let randomOwnerId = null;
  * @return {Promise<DataContract>}
  */
 module.exports = async function getDataContractFixture(ownerId = randomOwnerId) {
-  ({ DataContractFactory, DataContractValidator } = await loadWasmDpp());
+  await loadWasmDpp();
 
   if (!randomOwnerId) {
     randomOwnerId = await generateRandomIdentifierAsync();
@@ -191,7 +189,7 @@ module.exports = async function getDataContractFixture(ownerId = randomOwnerId)
         identifierField: {
           type: 'array',
           byteArray: true,
-          contentMediaType: JsIdentifier.MEDIA_TYPE,
+          contentMediaType: Identifier.MEDIA_TYPE,
           minItems: 32,
           maxItems: 32,
         },
@@ -250,17 +248,23 @@ module.exports = async function getDataContractFixture(ownerId = randomOwnerId)
     },
   };
 
-  const dataContractValidator = new DataContractValidator();
   const entropyGenerator = {
     generate() {
       return crypto.randomBytes(32);
     },
   };
   const factory = new DataContractFactory(
-    protocolVersion.latestVersion,
-    dataContractValidator,
+    getLatestProtocolVersion(),
     entropyGenerator,
   );
 
-  return factory.create(ownerId, documents);
+  const config = {
+    canBeDeleted: false,
+    readonly: false,
+    keepsHistory: true,
+    documentsKeepHistoryContractDefault: false,
+    documentsMutableContractDefault: true,
+  };
+
+  return factory.create(ownerId, documents, config);
 };

package/lib/test/fixtures/getDocumentTransitionsFixture.js

@@ -1 +1,31 @@
-module.exports = require('@dashevo/dpp/lib/test/fixtures/getDocumentTransitionsFixture');
+const crypto = require('crypto');
+const { DocumentFactory } = require('../../..');
+
+const getDocumentsFixture = require('./getDocumentsFixture');
+
+async function getDocumentTransitionsFixture(documents = {}) {
+  const {
+    create: createDocuments,
+    replace: replaceDocuments,
+    delete: deleteDocuments,
+  } = documents;
+
+  const fixtureDocuments = await getDocumentsFixture();
+
+  const entropyGenerator = {
+    generate() {
+      return crypto.randomBytes(32);
+    },
+  };
+  const factory = new DocumentFactory(1, entropyGenerator);
+
+  const stateTransition = factory.createStateTransition({
+    create: (createDocuments || fixtureDocuments),
+    replace: (replaceDocuments || []),
+    delete: (deleteDocuments || []),
+  });
+
+  return stateTransition.getTransitions();
+}
+
+module.exports = getDocumentTransitionsFixture;

package/lib/test/fixtures/getDocumentsFixture.js

@@ -3,9 +3,11 @@ const crypto = require('crypto');
 const getDataContractFixture = require('./getDataContractFixture');
 
 const { default: loadWasmDpp } = require('../../..');
-let { DocumentFactory, DocumentValidator, ProtocolVersionValidator } = require('../../..');
+let { DocumentFactory } = require('../../..');
 const generateRandomIdentifierAsync = require('../utils/generateRandomIdentifierAsync');
 
+let ownerId;
+
 /**
  * @param {DataContract} [dataContract]
  * @return {Promise<Document[]>}
@@ -18,17 +20,19 @@ module.exports = async function getDocumentsFixture(
     dataContract = await getDataContractFixture();
   }
 
-  ({ DocumentFactory, DocumentValidator, ProtocolVersionValidator } = await loadWasmDpp());
+  ({ DocumentFactory } = await loadWasmDpp());
 
-  const documentValidator = new DocumentValidator(new ProtocolVersionValidator());
+  // const documentValidator = new DocumentValidator(new ProtocolVersionValidator());
   const entropyGenerator = {
     generate() {
       return crypto.randomBytes(32);
     },
   };
-  const factory = new DocumentFactory(1, documentValidator, {}, entropyGenerator);
+  const factory = new DocumentFactory(1, entropyGenerator);
 
-  const ownerId = await generateRandomIdentifierAsync();
+  if (!ownerId) {
+    ownerId = await generateRandomIdentifierAsync();
+  }
 
   return [
     factory.create(dataContract, ownerId, 'niceDocument', { name: 'Cutie' }),

package/lib/test/fixtures/getIdentityCreateTransitionFixture.js

@@ -3,7 +3,7 @@ const PrivateKey = require('@dashevo/dashcore-lib/lib/privatekey');
 const getInstantAssetLockProofFixture = require('./getInstantAssetLockProofFixture');
 
 const { default: loadWasmDpp } = require('../../..');
-let { IdentityCreateTransition, IdentityPublicKey } = require('../../..');
+const { IdentityCreateTransition, IdentityPublicKeyWithWitness } = require('../../..');
 
 /**
  * @param {PrivateKey} oneTimePrivateKey
@@ -13,23 +13,17 @@ let { IdentityCreateTransition, IdentityPublicKey } = require('../../..');
 module.exports = async function getIdentityCreateTransitionFixture(
   oneTimePrivateKey = new PrivateKey(),
 ) {
-  ({ IdentityCreateTransition, IdentityPublicKey } = await loadWasmDpp());
-  const rawStateTransition = {
-    protocolVersion: 1,
-    type: 2,
-    assetLockProof: (await getInstantAssetLockProofFixture(oneTimePrivateKey)).toObject(),
-    publicKeys: [
-      {
-        id: 0,
-        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
-        data: Buffer.from('AuryIuMtRrl/VviQuyLD1l4nmxi9ogPzC9LT7tdpo0di', 'base64'),
-        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
-        readOnly: false,
-        signature: Buffer.alloc(0),
-      },
-    ],
-  };
-
-  return new IdentityCreateTransition(rawStateTransition);
+  await loadWasmDpp();
+
+  const assetLockProof = await getInstantAssetLockProofFixture(oneTimePrivateKey);
+
+  const stateTransition = new IdentityCreateTransition(1);
+  stateTransition.setAssetLockProof(assetLockProof);
+
+  const publicKey = new IdentityPublicKeyWithWitness(1);
+  publicKey.setData(Buffer.from('AuryIuMtRrl/VviQuyLD1l4nmxi9ogPzC9LT7tdpo0di', 'base64'));
+
+  stateTransition.setPublicKeys([publicKey]);
+
+  return stateTransition;
 };

package/lib/test/fixtures/getIdentityCreditTransferTransitionFixture.js

@@ -0,0 +1,14 @@
+const { default: loadWasmDpp } = require('../../..');
+const { IdentityCreditTransferTransition } = require('../../..');
+const generateRandomIdentifier = require('../utils/generateRandomIdentifierAsync');
+
+module.exports = async function getIdentityUpdateTransitionFixture() {
+  await loadWasmDpp();
+
+  const stateTransition = new IdentityCreditTransferTransition(1);
+  stateTransition.setAmount(1000);
+  stateTransition.setIdentityId(await generateRandomIdentifier());
+  stateTransition.setRecipientId(await generateRandomIdentifier());
+
+  return stateTransition;
+};

package/lib/test/fixtures/getIdentityFixture.js

@@ -1,5 +1,6 @@
-const { default: loadWasmDpp } = require('../../..');
-let { Identity, IdentityPublicKey } = require('../../..');
+const {
+  default: loadWasmDpp, Identity, IdentityPublicKey,
+} = require('../../..');
 const generateRandomIdentifierAsync = require('../utils/generateRandomIdentifierAsync');
 
 let staticId = null;
@@ -8,7 +9,7 @@ let staticId = null;
  * @return {Identity}
  */
 module.exports = async function getIdentityFixture(id = staticId, publicKeys = undefined) {
-  ({ Identity, IdentityPublicKey } = await loadWasmDpp());
+  await loadWasmDpp();
 
   if (!staticId) {
     staticId = await generateRandomIdentifierAsync();
@@ -19,33 +20,21 @@ module.exports = async function getIdentityFixture(id = staticId, publicKeys = u
     id = staticId;
   }
 
-  const preCreatedPublicKeys = [
-    {
-      id: 0,
-      type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
-      data: Buffer.from('AuryIuMtRrl/VviQuyLD1l4nmxi9ogPzC9LT7tdpo0di', 'base64'),
-      purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-      securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
-      readOnly: false,
-    },
-    {
-      id: 1,
-      type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
-      data: Buffer.from('A8AK95PYMVX5VQKzOhcVQRCUbc9pyg3RiL7jttEMDU+L', 'base64'),
-      purpose: IdentityPublicKey.PURPOSES.ENCRYPTION,
-      securityLevel: IdentityPublicKey.SECURITY_LEVELS.MEDIUM,
-      readOnly: false,
-    },
-  ];
-
-  const rawIdentity = {
-    // TODO: obtain latest version from some wasm binding?
-    protocolVersion: 1,
-    id, // TODO: should be probably id.toBuffer(), but it causes panic in IdentityWasm
-    balance: 10000,
-    revision: 0,
-    publicKeys: publicKeys === undefined ? preCreatedPublicKeys : publicKeys,
-  };
-
-  return new Identity(rawIdentity);
+  const key1 = new IdentityPublicKey(1);
+  key1.setData(Buffer.from('AuryIuMtRrl/VviQuyLD1l4nmxi9ogPzC9LT7tdpo0di', 'base64'));
+
+  const key2 = new IdentityPublicKey(1);
+  key2.setData(Buffer.from('A8AK95PYMVX5VQKzOhcVQRCUbc9pyg3RiL7jttEMDU+L', 'base64'));
+  key2.setId(1);
+  key2.setPurpose(IdentityPublicKey.PURPOSES.ENCRYPTION);
+  key2.setSecurityLevel(IdentityPublicKey.SECURITY_LEVELS.MEDIUM);
+
+  const newPublicKeys = publicKeys || [key1, key2];
+
+  const identity = new Identity(1);
+  identity.setId(id);
+  identity.setPublicKeys(newPublicKeys);
+  identity.setBalance(10000);
+
+  return identity;
 };

package/lib/test/fixtures/getIdentityTopUpTransitionFixture.js

@@ -3,8 +3,7 @@ const PrivateKey = require('@dashevo/dashcore-lib/lib/privatekey');
 const getInstantAssetLockProofFixture = require('./getInstantAssetLockProofFixture');
 const generateRandomIdentifier = require('../utils/generateRandomIdentifierAsync');
 
-const { default: loadWasmDpp } = require('../../..');
-let { IdentityTopUpTransition } = require('../../..');
+const { IdentityTopUpTransition, default: loadWasmDpp } = require('../../..');
 
 /**
  * @param {PrivateKey} oneTimePrivateKey
@@ -14,13 +13,11 @@ let { IdentityTopUpTransition } = require('../../..');
 module.exports = async function getIdentityCreateTransitionFixture(
   oneTimePrivateKey = new PrivateKey(),
 ) {
-  ({ IdentityTopUpTransition } = await loadWasmDpp());
-  const rawStateTransition = {
-    protocolVersion: 1,
-    type: 3,
-    assetLockProof: (await getInstantAssetLockProofFixture(oneTimePrivateKey)).toObject(),
-    identityId: await generateRandomIdentifier(),
-  };
+  await loadWasmDpp();
 
-  return new IdentityTopUpTransition(rawStateTransition);
+  const stateTransition = new IdentityTopUpTransition(1);
+  stateTransition.setIdentityId(await generateRandomIdentifier());
+  stateTransition.setAssetLockProof(await getInstantAssetLockProofFixture(oneTimePrivateKey));
+
+  return stateTransition;
 };

package/lib/test/fixtures/getIdentityUpdateTransitionFixture.js

@@ -1,35 +1,20 @@
 const generateRandomIdentifierAsync = require('../utils/generateRandomIdentifierAsync');
 
-const getInstantAssetLockProofFixture = require('./getInstantAssetLockProofFixture');
-
-const { default: loadWasmDpp } = require('../../..');
-let { IdentityUpdateTransition, IdentityPublicKey } = require('../../..');
+const { IdentityUpdateTransition, IdentityPublicKeyWithWitness, default: loadWasmDpp } = require('../../..');
 
 module.exports = async function getIdentityUpdateTransitionFixture() {
-  ({ IdentityUpdateTransition, IdentityPublicKey } = await loadWasmDpp());
+  await loadWasmDpp();
+
+  const stateTransition = new IdentityUpdateTransition(1);
+  stateTransition.setIdentityId(await generateRandomIdentifierAsync());
+
+  const key = new IdentityPublicKeyWithWitness(1);
+  key.setId(3);
+  key.setData(Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'));
 
-  const rawStateTransition = {
-    signature: Buffer.alloc(0),
-    signaturePublicKeyId: 0,
-    protocolVersion: 1,
-    type: 5,
-    assetLockProof: (await getInstantAssetLockProofFixture()).toObject(),
-    identityId: (await generateRandomIdentifierAsync()).toBuffer(),
-    revision: 0,
-    addPublicKeys: [
-      {
-        id: 3,
-        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
-        data: Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'),
-        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
-        signature: Buffer.alloc(0),
-        readOnly: false,
-      },
-    ],
-    disablePublicKeys: [0],
-    publicKeysDisabledAt: 1234567,
-  };
+  stateTransition.setPublicKeysToAdd([key]);
+  stateTransition.setPublicKeyIdsToDisable([0]);
+  stateTransition.setPublicKeysDisabledAt(new Date());
 
-  return new IdentityUpdateTransition(rawStateTransition);
+  return stateTransition;
 };