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

package/test/unit/document/stateTransition/DocumetsBatchTransition/DocumentsBatchTransition.spec.js

@@ -3,36 +3,68 @@ const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocuments
 const stateTransitionTypes = require('@dashevo/dpp/lib/stateTransition/stateTransitionTypes');
 const createDPPMock = require('@dashevo/dpp/lib/test/mocks/createDPPMock');
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-const DocumentFactory = require('@dashevo/dpp/lib/document/DocumentFactory');
-const serializer = require('@dashevo/dpp/lib/util/serializer');
-const hash = require('@dashevo/dpp/lib/util/hash');
+const DocumentFactoryJs = require('@dashevo/dpp/lib/document/DocumentFactory');
+const lodash = require('lodash');
+const { default: loadWasmDpp } = require('../../../../../dist');
+const newDocumentsContainer = require('../../../../../lib/test/utils/newDocumentsContainer');
+
+let Identifier;
+let DocumentFactory;
+let DataContract;
+let Document;
+let DocumentValidator;
+let ProtocolVersionValidator;
 
 describe('DocumentsBatchTransition', () => {
+  let stateTransitionJs;
   let stateTransition;
+  let documentsJs;
   let documents;
-  let hashMock;
-  let encodeMock;
+  let dataContractJs;
   let dataContract;
+  let factoryJs;
 
-  beforeEach(function beforeEach() {
-    dataContract = getDataContractFixture();
-    documents = getDocumentsFixture(dataContract);
+  beforeEach(async () => {
+    ({
+      Identifier, ProtocolVersionValidator, DocumentValidator, DocumentFactory, DataContract,
+      Document,
+    } = await loadWasmDpp());
+  });
 
-    encodeMock = this.sinonSandbox.stub(serializer, 'encode');
-    hashMock = this.sinonSandbox.stub(hash, 'hash');
+  beforeEach(async () => {
+    dataContractJs = getDataContractFixture();
+    dataContract = DataContract.fromBuffer(dataContractJs.toBuffer());
 
-    const factory = new DocumentFactory(createDPPMock(), undefined, undefined);
-    stateTransition = factory.createStateTransition({
-      create: documents,
+    documentsJs = getDocumentsFixture(dataContractJs);
+    documents = documentsJs.map((d) => {
+      const doc = new Document(d.toObject(), dataContract);
+      doc.setEntropy(d.entropy);
+      return doc;
     });
-  });
 
-  afterEach(() => {
-    encodeMock.restore();
-    hashMock.restore();
+    const protocolVersionValidatorRs = new ProtocolVersionValidator();
+    const documentValidatorRs = new DocumentValidator(protocolVersionValidatorRs);
+    const factory = new DocumentFactory(1, documentValidatorRs, {});
+    factoryJs = new DocumentFactoryJs(createDPPMock(), undefined, undefined);
+
+    stateTransitionJs = factoryJs.createStateTransition({
+      create: documentsJs,
+    });
+
+    stateTransition = factory.createStateTransition(await newDocumentsContainer({
+      create: documents,
+    }));
   });
 
   describe('#getProtocolVersion', () => {
+    it('should return the current protocol version', () => {
+      const result = stateTransitionJs.getProtocolVersion();
+
+      expect(result).to.equal(protocolVersion.latestVersion);
+    });
+  });
+
+  describe('#getProtocolVersion - Rust', () => {
     it('should return the current protocol version', () => {
       const result = stateTransition.getProtocolVersion();
 
@@ -41,6 +73,14 @@ describe('DocumentsBatchTransition', () => {
   });
 
   describe('#getType', () => {
+    it('should return State Transition type', () => {
+      const result = stateTransitionJs.getType();
+
+      expect(result).to.equal(stateTransitionTypes.DOCUMENTS_BATCH);
+    });
+  });
+
+  describe('#getType - Rust', () => {
     it('should return State Transition type', () => {
       const result = stateTransition.getType();
 
@@ -50,19 +90,38 @@ describe('DocumentsBatchTransition', () => {
 
   describe('#getTransitions', () => {
     it('should return document transitions', () => {
-      const result = stateTransition.getTransitions();
+      const result = stateTransitionJs.getTransitions();
 
-      expect(result).to.equal(stateTransition.transitions);
+      expect(result).to.equal(stateTransitionJs.transitions);
+    });
+  });
+
+  describe('#getTransitions - Rust', () => {
+    it('should return document transitions', () => {
+      const transitionsJs = stateTransitionJs.getTransitions().map((t) => t.toJSON());
+      const transitions = stateTransition.getTransitions().map((t) => t.toJSON());
+      expect(transitionsJs).to.deep.equal(transitions);
     });
   });
 
   describe('#toJSON', () => {
     it('should return State Transition as JSON', () => {
+      expect(stateTransitionJs.toJSON()).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.DOCUMENTS_BATCH,
+        ownerId: documentsJs[0].getOwnerId().toString(),
+        transitions: stateTransitionJs.getTransitions().map((d) => d.toJSON()),
+        signaturePublicKeyId: undefined,
+        signature: undefined,
+      });
+    });
+
+    it('should return State Transition as JSON - Rust', () => {
       expect(stateTransition.toJSON()).to.deep.equal({
         protocolVersion: protocolVersion.latestVersion,
         type: stateTransitionTypes.DOCUMENTS_BATCH,
-        ownerId: documents[0].getOwnerId().toString(),
-        transitions: stateTransition.getTransitions().map((d) => d.toJSON()),
+        ownerId: documentsJs[0].getOwnerId().toString(),
+        transitions: stateTransitionJs.getTransitions().map((d) => d.toJSON()),
         signaturePublicKeyId: undefined,
         signature: undefined,
       });
@@ -71,77 +130,78 @@ describe('DocumentsBatchTransition', () => {
 
   describe('#toObject', () => {
     it('should return State Transition as plain object', () => {
-      expect(stateTransition.toObject()).to.deep.equal({
+      expect(stateTransitionJs.toObject()).to.deep.equal({
         protocolVersion: protocolVersion.latestVersion,
         type: stateTransitionTypes.DOCUMENTS_BATCH,
-        ownerId: documents[0].getOwnerId(),
-        transitions: stateTransition.getTransitions().map((d) => d.toObject()),
+        ownerId: documentsJs[0].getOwnerId(),
+        transitions: stateTransitionJs.getTransitions().map((d) => d.toObject()),
         signaturePublicKeyId: undefined,
         signature: undefined,
       });
     });
-  });
-
-  describe('#toBuffer', () => {
-    it('should return serialized Documents State Transition', () => {
-      const serializedStateTransition = Buffer.from('123');
-
-      encodeMock.returns(serializedStateTransition);
-
-      const result = stateTransition.toBuffer();
 
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
+    it('should return State Transition as plain object -  Rust', () => {
+      const rawObject = stateTransition.toObject();
+      const rawObjectJs = stateTransitionJs.toObject();
+      /* eslint-disable */
+      const rawObjectWithBuffers = lodash.cloneDeepWith(rawObject, (value) => {
+        if (value instanceof Identifier) {
+          return value.toBuffer();
+        }
+      });
 
-      expect(result).to.deep.equal(
-        Buffer.concat([protocolVersionUInt32, serializedStateTransition]),
-      );
+      expect(rawObjectWithBuffers).to.deep.equal(rawObjectJs);
+    });
+  });
 
-      const dataToEncode = stateTransition.toObject();
-      delete dataToEncode.protocolVersion;
+  describe('#toBuffer', () => {
+    it('should return the same bytes as JS version', () => {
+      const bufferJs = stateTransitionJs.toBuffer();
+      const buffer = stateTransition.toBuffer();
 
-      expect(encodeMock).to.have.been.calledOnceWith(dataToEncode);
+      expect(bufferJs).to.deep.equal(buffer);
     });
   });
 
   describe('#hash', () => {
-    it('should return Documents State Transition hash as hex', () => {
-      const serializedDocument = Buffer.from('123');
-      const hashedDocument = '456';
-
-      encodeMock.returns(serializedDocument);
-      hashMock.returns(hashedDocument);
+    it('should return the same hash as the JS version', () => {
+      const hashJs = stateTransitionJs.hash();
+      const hash = stateTransitionJs.hash();
 
-      const result = stateTransition.hash();
-
-      expect(result).to.equal(hashedDocument);
-
-      const dataToEncode = stateTransition.toObject();
-      delete dataToEncode.protocolVersion;
-
-      expect(encodeMock).to.have.been.calledOnceWith(dataToEncode);
+      expect(hash).to.deep.equal(hashJs);
+    });
+  });
 
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
+  describe('#getOwnerId', () => {
+    it('should return owner id', async () => {
+      const result = stateTransitionJs.getOwnerId();
 
-      expect(hashMock).to.have.been.calledOnceWith(
-        Buffer.concat([protocolVersionUInt32, serializedDocument]),
-      );
+      expect(result).to.deep.equal(getDocumentsFixture.ownerId);
     });
   });
 
-  describe('#getOwnerId', () => {
+  describe('#getOwnerId - Rust', () => {
     it('should return owner id', async () => {
       const result = stateTransition.getOwnerId();
 
-      expect(result).to.deep.equal(getDocumentsFixture.ownerId);
+      expect(result.toBuffer()).to.deep.equal(getDocumentsFixture.ownerId.toBuffer());
     });
   });
 
   describe('#getModifiedDataIds', () => {
     it('should return ids of affected documents', () => {
-      const expectedIds = documents.map((doc) => doc.getId());
-      const result = stateTransition.getModifiedDataIds();
+      const expectedIds = documentsJs.map((doc) => doc.getId());
+      const result = stateTransitionJs.getModifiedDataIds();
+
+      expect(result.length).to.be.equal(10);
+      expect(result).to.be.deep.equal(expectedIds);
+    });
+  });
+
+  describe('#getModifiedDataIds - Rust', () => {
+    it('should return ids of affected documents', () => {
+      const expectedIds = documentsJs.map((doc) => doc.getId().toBuffer());
+      const result = stateTransition.getModifiedDataIds().map((id) => id.toBuffer());
 
       expect(result.length).to.be.equal(10);
       expect(result).to.be.deep.equal(expectedIds);
@@ -149,18 +209,36 @@ describe('DocumentsBatchTransition', () => {
   });
 
   describe('#isDataContractStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransitionJs.isDataContractStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isDataContractStateTransition - Rust', () => {
     it('should return false', () => {
       expect(stateTransition.isDataContractStateTransition()).to.be.false();
     });
   });
 
   describe('#isDocumentStateTransition', () => {
+    it('should return true', () => {
+      expect(stateTransitionJs.isDocumentStateTransition()).to.be.true();
+    });
+  });
+
+  describe('#isDocumentStateTransition - Rust', () => {
     it('should return true', () => {
       expect(stateTransition.isDocumentStateTransition()).to.be.true();
     });
   });
 
   describe('#isIdentityStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransitionJs.isIdentityStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isIdentityStateTransition - Rust', () => {
     it('should return false', () => {
       expect(stateTransition.isIdentityStateTransition()).to.be.false();
     });

package/test/unit/identity/Identity.spec.js

@@ -1,3 +1,4 @@
+const varint = require('varint');
 const JSIdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
 const JSIdentity = require('@dashevo/dpp/lib/identity/Identity');
@@ -145,8 +146,7 @@ describe('Identity', () => {
       const identityDataToEncode = identity.toObject();
       delete identityDataToEncode.protocolVersion;
 
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(identity.getProtocolVersion(), 0);
+      varint.encode(identity.getProtocolVersion());
 
       expect(result).to.deep.equal(expectedHash);
     });

package/test/unit/identity/stateTransition/IdentityCreateTransition/IdentityCreateTransition.spec.js

@@ -1,35 +1,65 @@
-const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
-
-const stateTransitionTypes = require(
-  '@dashevo/dpp/lib/stateTransition/stateTransitionTypes',
-);
+const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
+const getChainAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
 
+const stateTransitionTypes = require('@dashevo/dpp/lib/stateTransition/stateTransitionTypes');
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-const IdentityCreateTransition = require('@dashevo/dpp/lib/identity/stateTransition/IdentityCreateTransition/IdentityCreateTransition');
-const Identifier = require('@dashevo/dpp/lib/identifier/Identifier');
-
-const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
-const InstantAssetLockProof = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/instant/InstantAssetLockProof');
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('IdentityCreateTransition', () => {
   let rawStateTransition;
   let stateTransition;
 
+  let IdentityCreateTransition;
+  let InstantAssetLockProof;
+  let KeyType;
+  let KeyPurpose;
+  let KeySecurityLevel;
+  let IdentityPublicKey;
+  let Identifier;
+
+  const mockRawPublicKey = (params = {}) => ({
+    id: 0,
+    type: KeyType.ECDSA_SECP256K1,
+    data: Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'),
+    purpose: KeyPurpose.AUTHENTICATION,
+    securityLevel: KeySecurityLevel.MASTER,
+    signature: Buffer.alloc(32).fill(1),
+    readOnly: false,
+    ...params,
+  });
+
+  before(async () => {
+    ({
+      IdentityCreateTransition, IdentityPublicKey, KeyType, KeyPurpose, KeySecurityLevel,
+      InstantAssetLockProof, Identifier,
+    } = await loadWasmDpp());
+  });
+
   beforeEach(() => {
-    stateTransition = getIdentityCreateTransitionFixture();
-    rawStateTransition = stateTransition.toObject();
+    rawStateTransition = getIdentityCreateTransitionFixture().toObject();
+    stateTransition = new IdentityCreateTransition(
+      rawStateTransition,
+    );
   });
 
   describe('#constructor', () => {
-    it('should create an instance with specified data', () => {
+    it('should create instance with specified data', () => {
       expect(stateTransition.getAssetLockProof().toObject()).to.deep.equal(
         rawStateTransition.assetLockProof,
       );
 
-      expect(stateTransition.publicKeys).to.deep.equal([
-        new IdentityPublicKey(rawStateTransition.publicKeys[0]),
+      expect(stateTransition.publicKeys.map((key) => key.toObject())).to.deep.equal([
+        new IdentityPublicKey(rawStateTransition.publicKeys[0]).toObject(),
       ]);
     });
+
+    it('should create instance with chain asset lock proof', () => {
+      const stObject = stateTransition.toObject();
+      stObject.assetLockProof = getChainAssetLockProofFixture().toObject();
+      stateTransition = new IdentityCreateTransition(stObject);
+      expect(stateTransition.getAssetLockProof().toObject())
+        .to.deep.equal(stObject.assetLockProof);
+    });
   });
 
   describe('#getType', () => {
@@ -53,8 +83,8 @@ describe('IdentityCreateTransition', () => {
         new InstantAssetLockProof(rawStateTransition.assetLockProof),
       );
 
-      expect(stateTransition.identityId).to.deep.equal(
-        stateTransition.getAssetLockProof().createIdentifier(),
+      expect(stateTransition.identityId.toBuffer()).to.deep.equal(
+        stateTransition.getAssetLockProof().createIdentifier().toBuffer(),
       );
     });
   });
@@ -69,44 +99,53 @@ describe('IdentityCreateTransition', () => {
 
   describe('#setPublicKeys', () => {
     it('should set public keys', () => {
-      const publicKeys = [new IdentityPublicKey(), new IdentityPublicKey()];
+      const publicKeys = [
+        new IdentityPublicKey(mockRawPublicKey({ id: 0 })),
+        new IdentityPublicKey(mockRawPublicKey({ id: 1 })),
+      ];
 
       stateTransition.setPublicKeys(publicKeys);
 
-      expect(stateTransition.publicKeys).to.have.deep.members(publicKeys);
+      expect(stateTransition.publicKeys.map((key) => key.toObject()))
+        .to.have.deep.members(publicKeys.map((key) => key.toObject()));
     });
   });
 
   describe('#getPublicKeys', () => {
     it('should return set public keys', () => {
-      expect(stateTransition.getPublicKeys()).to.deep.equal(
-        rawStateTransition.publicKeys.map((rawPublicKey) => new IdentityPublicKey(rawPublicKey)),
+      expect(stateTransition.getPublicKeys().map((key) => key.toObject())).to.deep.equal(
+        rawStateTransition.publicKeys
+          .map((rawPublicKey) => new IdentityPublicKey(rawPublicKey).toObject()),
       );
     });
   });
 
   describe('#addPublicKeys', () => {
     it('should add more public keys', () => {
-      const publicKeys = [new IdentityPublicKey(), new IdentityPublicKey()];
+      const publicKeys = [
+        new IdentityPublicKey(mockRawPublicKey({ id: 0 })),
+        new IdentityPublicKey(mockRawPublicKey({ id: 1 })),
+      ];
 
-      stateTransition.publicKeys = [];
+      stateTransition.setPublicKeys([]);
       stateTransition.addPublicKeys(publicKeys);
-      expect(stateTransition.getPublicKeys()).to.have.deep.members(publicKeys);
+      expect(stateTransition.getPublicKeys().map((key) => key.toObject()))
+        .to.have.deep.members(publicKeys.map((key) => key.toObject()));
     });
   });
 
   describe('#getIdentityId', () => {
     it('should return identity id', () => {
-      expect(stateTransition.getIdentityId()).to.deep.equal(
-        stateTransition.getAssetLockProof().createIdentifier(),
+      expect(stateTransition.getIdentityId().toBuffer()).to.deep.equal(
+        stateTransition.getAssetLockProof().createIdentifier().toBuffer(),
       );
     });
   });
 
   describe('#getOwnerId', () => {
     it('should return owner id', () => {
-      expect(stateTransition.getOwnerId()).to.equal(
-        stateTransition.getIdentityId(),
+      expect(stateTransition.getOwnerId().toBuffer()).to.deep.equal(
+        stateTransition.getIdentityId().toBuffer(),
       );
     });
   });
@@ -158,8 +197,8 @@ describe('IdentityCreateTransition', () => {
       const identityId = result[0];
 
       expect(identityId).to.be.an.instanceOf(Identifier);
-      expect(identityId).to.be.deep.equal(
-        new IdentityCreateTransition(rawStateTransition).getIdentityId(),
+      expect(identityId.toBuffer()).to.be.deep.equal(
+        new IdentityCreateTransition(rawStateTransition).getIdentityId().toBuffer(),
       );
     });
   });

package/test/unit/identity/stateTransition/IdentityCreateTransition/applyIdentityCreateTransitionFactory.spec.js

@@ -1,9 +1,3 @@
-const Identity = require('@dashevo/dpp/lib/identity/Identity');
-
-const applyIdentityCreateTransitionFactory = require(
-  '@dashevo/dpp/lib/identity/stateTransition/IdentityCreateTransition/applyIdentityCreateTransitionFactory',
-);
-
 const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
 
 const { convertSatoshiToCredits } = require('@dashevo/dpp/lib/identity/creditsConverter');
@@ -11,21 +5,37 @@ const { convertSatoshiToCredits } = require('@dashevo/dpp/lib/identity/creditsCo
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
-const ReadOperation = require('@dashevo/dpp/lib/stateTransition/fee/operations/ReadOperation');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('applyIdentityCreateTransitionFactory', () => {
   let stateTransition;
   let applyIdentityCreateTransition;
   let stateRepositoryMock;
-  let fetchAssetLockTransactionOutputMock;
   let output;
   let executionContext;
 
+  let StateTransitionExecutionContext;
+  let IdentityCreateTransition;
+  let Identity;
+
+  let applyIdentityCreateTransitionDPP;
+
+  before(async () => {
+    ({
+      StateTransitionExecutionContext,
+      IdentityCreateTransition,
+      applyIdentityCreateTransition: applyIdentityCreateTransitionDPP,
+      Identity,
+    } = await loadWasmDpp());
+  });
+
   beforeEach(function beforeEach() {
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
 
-    stateTransition = getIdentityCreateTransitionFixture();
+    stateTransition = new IdentityCreateTransition(
+      getIdentityCreateTransitionFixture().toObject(),
+    );
 
     executionContext = new StateTransitionExecutionContext();
 
@@ -33,19 +43,13 @@ describe('applyIdentityCreateTransitionFactory', () => {
 
     output = stateTransition.getAssetLockProof().getOutput();
 
-    fetchAssetLockTransactionOutputMock = this.sinonSandbox.stub().resolves(output);
-
-    applyIdentityCreateTransition = applyIdentityCreateTransitionFactory(
+    applyIdentityCreateTransition = (st) => applyIdentityCreateTransitionDPP(
       stateRepositoryMock,
-      fetchAssetLockTransactionOutputMock,
+      st,
     );
   });
 
-  it('should store identity created from state transition', async () => {
-    executionContext.addOperation(
-      new ReadOperation(1),
-    );
-
+  it('should store identity created from state transition', async function () {
     await applyIdentityCreateTransition(stateTransition);
 
     const balance = convertSatoshiToCredits(
@@ -60,9 +64,11 @@ describe('applyIdentityCreateTransitionFactory', () => {
       revision: 0,
     });
 
+    const { match } = this.sinonSandbox;
+
     expect(stateRepositoryMock.createIdentity).to.have.been.calledOnceWithExactly(
-      identity,
-      executionContext,
+      match((arg) => expect(arg.toObject()).to.deep.equal(identity.toObject())),
+      match.instanceOf(StateTransitionExecutionContext),
     );
 
     const publicKeyHashes = identity
@@ -70,21 +76,15 @@ describe('applyIdentityCreateTransitionFactory', () => {
       .map((publicKey) => publicKey.hash());
 
     expect(stateRepositoryMock.storeIdentityPublicKeyHashes).to.have.been.calledOnceWithExactly(
-      identity.getId(),
-      publicKeyHashes,
-      executionContext,
+      match((arg) => expect(arg.toBuffer()).to.deep.equal(identity.getId().toBuffer())),
+      match((arg) => expect(arg).to.deep.equal(publicKeyHashes)),
+      match.instanceOf(StateTransitionExecutionContext),
     );
 
+    const outPoint = stateTransition.getAssetLockProof().getOutPoint();
     expect(stateRepositoryMock.markAssetLockTransactionOutPointAsUsed).to.have.been
       .calledOnceWithExactly(
-        stateTransition.getAssetLockProof().getOutPoint(),
-        executionContext,
-      );
-
-    expect(fetchAssetLockTransactionOutputMock)
-      .to.be.calledOnceWithExactly(
-        stateTransition.getAssetLockProof(),
-        executionContext,
+        match((arg) => Buffer.from(arg).equals(outPoint)),
       );
   });
 });