@dashevo/wasm-dpp 0.25.0-dev.9 → 0.25.0

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/getDataContractFixture.js

@@ -3,7 +3,7 @@ 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('../../..');
+let { DataContractFactory } = require('../../..');
 
 let randomOwnerId = null;
 
@@ -13,7 +13,7 @@ let randomOwnerId = null;
  * @return {Promise<DataContract>}
  */
 module.exports = async function getDataContractFixture(ownerId = randomOwnerId) {
-  ({ DataContractFactory, DataContractValidator } = await loadWasmDpp());
+  ({ DataContractFactory } = await loadWasmDpp());
 
   if (!randomOwnerId) {
     randomOwnerId = await generateRandomIdentifierAsync();
@@ -250,7 +250,6 @@ module.exports = async function getDataContractFixture(ownerId = randomOwnerId)
     },
   };
 
-  const dataContractValidator = new DataContractValidator();
   const entropyGenerator = {
     generate() {
       return crypto.randomBytes(32);
@@ -258,9 +257,16 @@ module.exports = async function getDataContractFixture(ownerId = randomOwnerId)
   };
   const factory = new DataContractFactory(
     protocolVersion.latestVersion,
-    dataContractValidator,
     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/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;
 };

package/lib/test/fixtures/getPrivateAndPublicKeyForSigningFixture.js

@@ -8,16 +8,14 @@ module.exports = async function getPrivateAndPublicKeyForSigningFixture(privateK
   const privateKey = new PrivateKey(privateKeyHex);
   const publicKey = privateKey.toPublicKey();
 
-  const rawPublicKey = {
-    id: 2,
-    type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
-    data: publicKey.toBuffer(),
-    purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-    securityLevel: IdentityPublicKey.SECURITY_LEVELS.HIGH,
-    readOnly: false,
-  };
+  const identityPublicKey = new IdentityPublicKey(1);
 
-  const identityPublicKey = new IdentityPublicKey(rawPublicKey);
+  identityPublicKey.setId(2);
+  identityPublicKey.setType(IdentityPublicKey.TYPES.ECDSA_SECP256K1);
+  identityPublicKey.setData(publicKey.toBuffer());
+  identityPublicKey.setPurpose(IdentityPublicKey.PURPOSES.AUTHENTICATION);
+  identityPublicKey.setSecurityLevel(IdentityPublicKey.SECURITY_LEVELS.CRITICAL);
+  identityPublicKey.setReadOnly(false);
 
   return { privateKey: Buffer.from(privateKeyHex, 'hex'), identityPublicKey };
 };

package/lib/test/fixtures/js/generateRandomIdentifier.js

@@ -0,0 +1 @@
+module.exports = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');

package/lib/test/fixtures/js/getChainAssetLockProofFixture.js

@@ -0,0 +1 @@
+module.exports = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');

package/lib/test/fixtures/js/getDataContractFixture.js

@@ -0,0 +1 @@
+module.exports = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');

package/lib/test/fixtures/js/getDocumentTransitionsFixture.js

@@ -0,0 +1 @@
+module.exports = require('@dashevo/dpp/lib/test/fixtures/getDocumentTransitionsFixture');

package/lib/test/fixtures/js/getDocumentsFixture.js

@@ -0,0 +1 @@
+module.exports = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');

package/lib/test/fixtures/js/getInstantAssetLockProofFixture.js

@@ -0,0 +1 @@
+module.exports = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');

package/lib/test/mocks/createStateRepositoryMock.js

@@ -37,6 +37,7 @@ module.exports = function createStateRepositoryMock(sinonSandbox) {
     createDataContract: sinonSandbox.stub(),
     updateDataContract: sinonSandbox.stub(),
     fetchDocuments: sinonSandbox.stub(),
+    fetchExtendedDocuments: sinonSandbox.stub(),
     createDocument: sinonSandbox.stub(),
     updateDocument: sinonSandbox.stub(),
     removeDocument: sinonSandbox.stub(),