@enbox/dwn-sdk-js 0.0.1 → 0.0.3

package/dist/esm/tests/handlers/records-write.spec.js

@@ -7,22 +7,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import anyoneCollaborateProtocolDefinition from '../vectors/protocol-definitions/anyone-collaborate.json' assert { type: 'json' };
-import authorCanProtocolDefinition from '../vectors/protocol-definitions/author-can.json' assert { type: 'json' };
-import chaiAsPromised from 'chai-as-promised';
-import credentialIssuanceProtocolDefinition from '../vectors/protocol-definitions/credential-issuance.json' assert { type: 'json' };
-import dexProtocolDefinition from '../vectors/protocol-definitions/dex.json' assert { type: 'json' };
-import emailProtocolDefinition from '../vectors/protocol-definitions/email.json' assert { type: 'json' };
-import friendRoleProtocolDefinition from '../vectors/protocol-definitions/friend-role.json' assert { type: 'json' };
-import messageProtocolDefinition from '../vectors/protocol-definitions/message.json' assert { type: 'json' };
-import minimalProtocolDefinition from '../vectors/protocol-definitions/minimal.json' assert { type: 'json' };
-import nestedProtocol from '../vectors/protocol-definitions/nested.json' assert { type: 'json' };
-import privateProtocol from '../vectors/protocol-definitions/private-protocol.json' assert { type: 'json' };
-import recipientCanProtocol from '../vectors/protocol-definitions/recipient-can.json' assert { type: 'json' };
+import anyoneCollaborateProtocolDefinition from '../vectors/protocol-definitions/anyone-collaborate.json' with { type: 'json' };
+import authorCanProtocolDefinition from '../vectors/protocol-definitions/author-can.json' with { type: 'json' };
+import credentialIssuanceProtocolDefinition from '../vectors/protocol-definitions/credential-issuance.json' with { type: 'json' };
+import dexProtocolDefinition from '../vectors/protocol-definitions/dex.json' with { type: 'json' };
+import emailProtocolDefinition from '../vectors/protocol-definitions/email.json' with { type: 'json' };
+import friendRoleProtocolDefinition from '../vectors/protocol-definitions/friend-role.json' with { type: 'json' };
+import messageProtocolDefinition from '../vectors/protocol-definitions/message.json' with { type: 'json' };
+import minimalProtocolDefinition from '../vectors/protocol-definitions/minimal.json' with { type: 'json' };
+import nestedProtocol from '../vectors/protocol-definitions/nested.json' with { type: 'json' };
+import privateProtocol from '../vectors/protocol-definitions/private-protocol.json' with { type: 'json' };
+import recipientCanProtocol from '../vectors/protocol-definitions/recipient-can.json' with { type: 'json' };
 import sinon from 'sinon';
-import socialMediaProtocolDefinition from '../vectors/protocol-definitions/social-media.json' assert { type: 'json' };
-import threadRoleProtocolDefinition from '../vectors/protocol-definitions/thread-role.json' assert { type: 'json' };
-import chai, { expect } from 'chai';
+import socialMediaProtocolDefinition from '../vectors/protocol-definitions/social-media.json' with { type: 'json' };
+import threadRoleProtocolDefinition from '../vectors/protocol-definitions/thread-role.json' with { type: 'json' };
 import { ArrayUtility } from '../../src/utils/array.js';
 import { base64url } from 'multiformats/bases/base64';
 import { Cid } from '../../src/utils/cid.js';
@@ -41,18 +39,18 @@ import { TestEventStream } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
 import { TestStubGenerator } from '../utils/test-stub-generator.js';
 import { Time } from '../../src/utils/time.js';
-import { DwnError, DwnErrorCode } from '../../src/core/dwn-error.js';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import { DataStoreLevel, DwnConstant, DwnInterfaceName, DwnMethodName, KeyDerivationScheme, MessageStoreLevel, PermissionsProtocol, RecordsDelete, RecordsQuery } from '../../src/index.js';
 import { DidKey, UniversalResolver } from '@enbox/dids';
+import { DwnError, DwnErrorCode } from '../../src/core/dwn-error.js';
 import { Encryption, EncryptionAlgorithm } from '../../src/utils/encryption.js';
-chai.use(chaiAsPromised);
 export function testRecordsWriteHandler() {
-    describe('RecordsWriteHandler.handle()', () => __awaiter(this, void 0, void 0, function* () {
+    describe('RecordsWriteHandler.handle()', () => {
         let didResolver;
         let messageStore;
         let dataStore;
         let resumableTaskStore;
-        let eventLog;
+        let stateIndex;
         let eventStream;
         let dwn;
         beforeEach(() => {
@@ -61,24 +59,24 @@ export function testRecordsWriteHandler() {
         describe('functional tests', () => {
             // important to follow the `before` and `after` pattern to initialize and clean the stores in tests
             // so that different test suites can reuse the same backend store for testing
-            before(() => __awaiter(this, void 0, void 0, function* () {
+            beforeAll(() => __awaiter(this, void 0, void 0, function* () {
                 didResolver = new UniversalResolver({ didResolvers: [DidKey] });
                 const stores = TestStores.get();
                 messageStore = stores.messageStore;
                 dataStore = stores.dataStore;
                 resumableTaskStore = stores.resumableTaskStore;
-                eventLog = stores.eventLog;
+                stateIndex = stores.stateIndex;
                 eventStream = TestEventStream.get();
-                dwn = yield Dwn.create({ didResolver, messageStore, dataStore, eventLog, eventStream, resumableTaskStore });
+                dwn = yield Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
             }));
             beforeEach(() => __awaiter(this, void 0, void 0, function* () {
                 // clean up before each test rather than after so that a test does not depend on other tests to do the clean up
                 yield messageStore.clear();
                 yield dataStore.clear();
                 yield resumableTaskStore.clear();
-                yield eventLog.clear();
+                yield stateIndex.clear();
             }));
-            after(() => __awaiter(this, void 0, void 0, function* () {
+            afterAll(() => __awaiter(this, void 0, void 0, function* () {
                 yield dwn.close();
             }));
             it('should call preProcessingForCoreRecordsWrite after authorization and before storage', () => __awaiter(this, void 0, void 0, function* () {
@@ -91,12 +89,12 @@ export function testRecordsWriteHandler() {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const reply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(reply.status.code).to.equal(400);
+                expect(reply.status.code).toBe(400);
                 // expect that authorization and preProcessingForCoreRecordsWrite are both called once
-                expect(authorizationSpy.calledOnce).to.be.true;
-                expect(preProcessingForCoreRecordsWriteSpy.calledOnce).to.be.true;
+                expect(authorizationSpy.calledOnce).toBe(true);
+                expect(preProcessingForCoreRecordsWriteSpy.calledOnce).toBe(true);
                 // expect that processMessageWithDataStream is NOT called since preProcessingForCoreRecordsWrite failed before reaching it
-                expect(processDataStreamSpy.called).to.be.false;
+                expect(processDataStreamSpy.called).toBe(false);
             }));
             it('should only be able to overwrite existing record if new record has a later `messageTimestamp` value', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c;
@@ -106,7 +104,7 @@ export function testRecordsWriteHandler() {
                 const recordsWriteMessageData = yield TestDataGenerator.generateRecordsWrite({ author, data: data1 });
                 const tenant = author.did;
                 const recordsWriteReply = yield dwn.processMessage(tenant, recordsWriteMessageData.message, { dataStream: recordsWriteMessageData.dataStream });
-                expect(recordsWriteReply.status.code).to.equal(202);
+                expect(recordsWriteReply.status.code).toBe(202);
                 const recordId = recordsWriteMessageData.message.recordId;
                 const recordsQueryMessageData = yield TestDataGenerator.generateRecordsQuery({
                     author,
@@ -114,9 +112,9 @@ export function testRecordsWriteHandler() {
                 });
                 // verify the message written can be queried
                 const recordsQueryReply = yield dwn.processMessage(tenant, recordsQueryMessageData.message);
-                expect(recordsQueryReply.status.code).to.equal(200);
-                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(recordsQueryReply.entries[0].encodedData).to.equal(base64url.baseEncode(data1));
+                expect(recordsQueryReply.status.code).toBe(200);
+                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(recordsQueryReply.entries[0].encodedData).toBe(base64url.baseEncode(data1));
                 // generate and write a new RecordsWrite to overwrite the existing record
                 // a new RecordsWrite by default will have a later `messageTimestamp`
                 const newDataBytes = Encoder.stringToBytes('new data');
@@ -127,22 +125,22 @@ export function testRecordsWriteHandler() {
                     data: newDataBytes
                 });
                 // sanity check that old data and new data are different
-                expect(newDataEncoded).to.not.equal(Encoder.bytesToBase64Url(recordsWriteMessageData.dataBytes));
+                expect(newDataEncoded).not.toBe(Encoder.bytesToBase64Url(recordsWriteMessageData.dataBytes));
                 const newRecordsWriteReply = yield dwn.processMessage(tenant, newRecordsWrite.message, { dataStream: newRecordsWrite.dataStream });
-                expect(newRecordsWriteReply.status.code).to.equal(202);
+                expect(newRecordsWriteReply.status.code).toBe(202);
                 // verify new record has overwritten the existing record
                 const newRecordsQueryReply = yield dwn.processMessage(tenant, recordsQueryMessageData.message);
-                expect(newRecordsQueryReply.status.code).to.equal(200);
-                expect((_b = newRecordsQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-                expect(newRecordsQueryReply.entries[0].encodedData).to.equal(newDataEncoded);
+                expect(newRecordsQueryReply.status.code).toBe(200);
+                expect((_b = newRecordsQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(newRecordsQueryReply.entries[0].encodedData).toBe(newDataEncoded);
                 // try to write the older message to store again and verify that it is not accepted
                 const thirdRecordsWriteReply = yield dwn.processMessage(tenant, recordsWriteMessageData.message, { dataStream: recordsWriteMessageData.dataStream });
-                expect(thirdRecordsWriteReply.status.code).to.equal(409); // expecting to fail
+                expect(thirdRecordsWriteReply.status.code).toBe(409); // expecting to fail
                 // expecting unchanged
                 const thirdRecordsQueryReply = yield dwn.processMessage(tenant, recordsQueryMessageData.message);
-                expect(thirdRecordsQueryReply.status.code).to.equal(200);
-                expect((_c = thirdRecordsQueryReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(1);
-                expect(thirdRecordsQueryReply.entries[0].encodedData).to.equal(newDataEncoded);
+                expect(thirdRecordsQueryReply.status.code).toBe(200);
+                expect((_c = thirdRecordsQueryReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
+                expect(thirdRecordsQueryReply.entries[0].encodedData).toBe(newDataEncoded);
             }));
             it('should only be able to overwrite existing record if new message CID is larger when `messageTimestamp` value is the same', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c;
@@ -156,7 +154,7 @@ export function testRecordsWriteHandler() {
                 // setting up a stub DID resolver
                 TestStubGenerator.stubDidResolver(didResolver, [author]);
                 const originatingMessageWriteReply = yield dwn.processMessage(tenant, originatingMessageData.message, { dataStream: originatingMessageData.dataStream });
-                expect(originatingMessageWriteReply.status.code).to.equal(202);
+                expect(originatingMessageWriteReply.status.code).toBe(202);
                 // generate two new RecordsWrite messages with the same `messageTimestamp` value
                 const dateModified = Time.getCurrentTimestamp();
                 const recordsWrite1 = yield TestDataGenerator.generateFromRecordsWrite({
@@ -184,7 +182,7 @@ export function testRecordsWriteHandler() {
                 }
                 // write the message with the smaller lexicographical message CID first
                 const recordsWriteReply = yield dwn.processMessage(tenant, olderWrite.message, { dataStream: olderWrite.dataStream });
-                expect(recordsWriteReply.status.code).to.equal(202);
+                expect(recordsWriteReply.status.code).toBe(202);
                 // query to fetch the record
                 const recordsQueryMessageData = yield TestDataGenerator.generateRecordsQuery({
                     author,
@@ -192,29 +190,29 @@ export function testRecordsWriteHandler() {
                 });
                 // verify the data is written
                 const recordsQueryReply = yield dwn.processMessage(tenant, recordsQueryMessageData.message);
-                expect(recordsQueryReply.status.code).to.equal(200);
-                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+                expect(recordsQueryReply.status.code).toBe(200);
+                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
                 expect(recordsQueryReply.entries[0].descriptor.dataCid)
-                    .to.equal(olderWrite.message.descriptor.dataCid);
+                    .toBe(olderWrite.message.descriptor.dataCid);
                 // attempt to write the message with larger lexicographical message CID
                 const newRecordsWriteReply = yield dwn.processMessage(tenant, newerWrite.message, { dataStream: newerWrite.dataStream });
-                expect(newRecordsWriteReply.status.code).to.equal(202);
+                expect(newRecordsWriteReply.status.code).toBe(202);
                 // verify new record has overwritten the existing record
                 const newRecordsQueryReply = yield dwn.processMessage(tenant, recordsQueryMessageData.message);
-                expect(newRecordsQueryReply.status.code).to.equal(200);
-                expect((_b = newRecordsQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
+                expect(newRecordsQueryReply.status.code).toBe(200);
+                expect((_b = newRecordsQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
                 expect(newRecordsQueryReply.entries[0].descriptor.dataCid)
-                    .to.equal(newerWrite.message.descriptor.dataCid);
+                    .toBe(newerWrite.message.descriptor.dataCid);
                 // try to write the message with smaller lexicographical message CID again
                 const thirdRecordsWriteReply = yield dwn.processMessage(tenant, olderWrite.message, { dataStream: DataStream.fromBytes(olderWrite.dataBytes) } // need to create data stream again since it's already used above
                 );
-                expect(thirdRecordsWriteReply.status.code).to.equal(409); // expecting to fail
+                expect(thirdRecordsWriteReply.status.code).toBe(409); // expecting to fail
                 // verify the message in store is still the one with larger lexicographical message CID
                 const thirdRecordsQueryReply = yield dwn.processMessage(tenant, recordsQueryMessageData.message);
-                expect(thirdRecordsQueryReply.status.code).to.equal(200);
-                expect((_c = thirdRecordsQueryReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(1);
+                expect(thirdRecordsQueryReply.status.code).toBe(200);
+                expect((_c = thirdRecordsQueryReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
                 expect(thirdRecordsQueryReply.entries[0].descriptor.dataCid)
-                    .to.equal(newerWrite.message.descriptor.dataCid); // expecting unchanged
+                    .toBe(newerWrite.message.descriptor.dataCid); // expecting unchanged
             }));
             it('#690 - should allow data format of a flat-space record to be updated to any value', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -222,7 +220,7 @@ export function testRecordsWriteHandler() {
                 const tenant = initialWriteData.author.did;
                 TestStubGenerator.stubDidResolver(didResolver, [initialWriteData.author]);
                 const initialWriteReply = yield dwn.processMessage(tenant, initialWriteData.message, { dataStream: initialWriteData.dataStream });
-                expect(initialWriteReply.status.code).to.equal(202);
+                expect(initialWriteReply.status.code).toBe(202);
                 const newDataFormat = 'any-new-data-format';
                 const newDataBytes = TestDataGenerator.randomBytes(100);
                 const updateWrite = yield RecordsWrite.createFrom({
@@ -233,22 +231,22 @@ export function testRecordsWriteHandler() {
                 });
                 const newDataStream = DataStream.fromBytes(newDataBytes);
                 const updateReply = yield dwn.processMessage(tenant, updateWrite.message, { dataStream: newDataStream });
-                expect(updateReply.status.code).to.equal(202);
+                expect(updateReply.status.code).toBe(202);
                 // verify the data format of the record is updated
                 const recordsRead = yield RecordsRead.create({
                     filter: { recordId: initialWriteData.message.recordId },
                     signer: Jws.createSigner(initialWriteData.author),
                 });
                 const recordsReadReply = yield dwn.processMessage(tenant, recordsRead.message);
-                expect(recordsReadReply.status.code).to.equal(200);
-                expect((_a = recordsReadReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.descriptor.dataFormat).to.equal(newDataFormat);
+                expect(recordsReadReply.status.code).toBe(200);
+                expect((_a = recordsReadReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.descriptor.dataFormat).toBe(newDataFormat);
             }));
             it('should not allow changes to immutable properties', () => __awaiter(this, void 0, void 0, function* () {
                 const initialWriteData = yield TestDataGenerator.generateRecordsWrite();
                 const tenant = initialWriteData.author.did;
                 TestStubGenerator.stubDidResolver(didResolver, [initialWriteData.author]);
                 const initialWriteReply = yield dwn.processMessage(tenant, initialWriteData.message, { dataStream: initialWriteData.dataStream });
-                expect(initialWriteReply.status.code).to.equal(202);
+                expect(initialWriteReply.status.code).toBe(202);
                 const recordId = initialWriteData.message.recordId;
                 const dateCreated = initialWriteData.message.descriptor.dateCreated;
                 const schema = initialWriteData.message.descriptor.schema;
@@ -261,8 +259,8 @@ export function testRecordsWriteHandler() {
                     dataFormat: initialWriteData.message.descriptor.dataFormat
                 });
                 let reply = yield dwn.processMessage(tenant, childMessageData.message, { dataStream: childMessageData.dataStream });
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain('dateCreated is an immutable property');
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain('dateCreated is an immutable property');
                 // schema test
                 childMessageData = yield TestDataGenerator.generateRecordsWrite({
                     author: initialWriteData.author,
@@ -272,8 +270,8 @@ export function testRecordsWriteHandler() {
                     dataFormat: initialWriteData.message.descriptor.dataFormat
                 });
                 reply = yield dwn.processMessage(tenant, childMessageData.message, { dataStream: childMessageData.dataStream });
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain('schema is an immutable property');
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain('schema is an immutable property');
             }));
             it('should inherit data from previous RecordsWrite given a matching dataCid and dataSize and no dataStream', () => __awaiter(this, void 0, void 0, function* () {
                 const { message, author, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({
@@ -282,24 +280,24 @@ export function testRecordsWriteHandler() {
                 const tenant = author.did;
                 TestStubGenerator.stubDidResolver(didResolver, [author]);
                 const initialWriteReply = yield dwn.processMessage(tenant, message, { dataStream });
-                expect(initialWriteReply.status.code).to.equal(202);
+                expect(initialWriteReply.status.code).toBe(202);
                 const write2 = yield RecordsWrite.createFrom({
                     recordsWriteMessage: message,
                     published: true,
                     signer: Jws.createSigner(author),
                 });
                 const writeUpdateReply = yield dwn.processMessage(tenant, write2.message);
-                expect(writeUpdateReply.status.code).to.equal(202);
+                expect(writeUpdateReply.status.code).toBe(202);
                 const readMessage = yield RecordsRead.create({
                     filter: {
                         recordId: message.recordId,
                     }
                 });
                 const readMessageReply = yield dwn.processMessage(tenant, readMessage.message);
-                expect(readMessageReply.status.code).to.equal(200);
-                expect(readMessageReply.entry.recordsWrite).to.exist;
+                expect(readMessageReply.status.code).toBe(200);
+                expect(readMessageReply.entry.recordsWrite).toBeDefined();
                 const data = yield DataStream.toBytes(readMessageReply.entry.data);
-                expect(data).to.eql(dataBytes);
+                expect(data).toEqual(dataBytes);
             }));
             it('should allow an initial `RecordsWrite` to be written without supplying data', () => __awaiter(this, void 0, void 0, function* () {
                 //scenario:  you have an initial write without the data and a subsequent write with data to be able to write.
@@ -309,15 +307,15 @@ export function testRecordsWriteHandler() {
                 const { recordsWrite } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 // simulate synchronize of pruned initial `RecordsWrite`
                 const reply = yield dwn.processMessage(alice.did, recordsWrite.message);
-                expect(reply.status.code).to.equal(204);
+                expect(reply.status.code).toBe(204);
                 // verify `RecordsWrite` inserted is not returned with a query
                 const recordsQueryMessageData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: recordsWrite.message.recordId }
                 });
                 const recordsQueryReply = yield dwn.processMessage(alice.did, recordsQueryMessageData.message);
-                expect(recordsQueryReply.status.code).to.equal(200);
-                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(0);
+                expect(recordsQueryReply.status.code).toBe(200);
+                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
                 // generate and write a new `RecordsWrite` to overwrite the existing record
                 const newDataBytes = Encoder.stringToBytes('new data');
                 const newDataEncoded = Encoder.bytesToBase64Url(newDataBytes);
@@ -327,12 +325,12 @@ export function testRecordsWriteHandler() {
                     data: newDataBytes
                 });
                 const newRecordsWriteReply = yield dwn.processMessage(alice.did, newRecordsWrite.message, { dataStream: newRecordsWrite.dataStream });
-                expect(newRecordsWriteReply.status.code).to.equal(202);
+                expect(newRecordsWriteReply.status.code).toBe(202);
                 // verify new `RecordsWrite` has overwritten the existing record with new data
                 const newRecordsQueryReply = yield dwn.processMessage(alice.did, recordsQueryMessageData.message);
-                expect(newRecordsQueryReply.status.code).to.equal(200);
-                expect((_b = newRecordsQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-                expect(newRecordsQueryReply.entries[0].encodedData).to.equal(newDataEncoded);
+                expect(newRecordsQueryReply.status.code).toBe(200);
+                expect((_b = newRecordsQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(newRecordsQueryReply.entries[0].encodedData).toBe(newDataEncoded);
             }));
             it('should not allow non-initial writes to be written without supplying data', () => __awaiter(this, void 0, void 0, function* () {
                 //scenario:  you have an initial write without the data and a subsequent write with data to be able to write.
@@ -342,15 +340,15 @@ export function testRecordsWriteHandler() {
                 // write a record into the dwn
                 const { recordsWrite, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const reply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                expect(reply.status.code).to.equal(202);
+                expect(reply.status.code).toBe(202);
                 // verify `RecordsWrite` inserted can be queried
                 const recordsQueryMessageData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: recordsWrite.message.recordId }
                 });
                 const recordsQueryReply = yield dwn.processMessage(alice.did, recordsQueryMessageData.message);
-                expect(recordsQueryReply.status.code).to.equal(200);
-                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+                expect(recordsQueryReply.status.code).toBe(200);
+                expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
                 // generate and write a new `RecordsWrite` to overwrite the existing record
                 const newDataBytes = Encoder.stringToBytes('new data');
                 const newRecordsWrite = yield TestDataGenerator.generateFromRecordsWrite({
@@ -360,14 +358,14 @@ export function testRecordsWriteHandler() {
                 });
                 // records write should be rejected.
                 const newRecordsWriteReply = yield dwn.processMessage(alice.did, newRecordsWrite.message);
-                expect(newRecordsWriteReply.status.code).to.equal(400);
-                expect(newRecordsWriteReply.status.detail).to.contain(DwnErrorCode.RecordsWriteDataCidMismatch);
+                expect(newRecordsWriteReply.status.code).toBe(400);
+                expect(newRecordsWriteReply.status.detail).toContain(DwnErrorCode.RecordsWriteDataCidMismatch);
                 // verify the original `RecordsWrite` and data are still available
                 const newRecordsQueryReply = yield dwn.processMessage(alice.did, recordsQueryMessageData.message);
-                expect(newRecordsQueryReply.status.code).to.equal(200);
-                expect((_b = newRecordsQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
+                expect(newRecordsQueryReply.status.code).toBe(200);
+                expect((_b = newRecordsQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
                 const originalEncodedData = Encoder.bytesToBase64Url(dataBytes);
-                expect(newRecordsQueryReply.entries[0].encodedData).to.equal(originalEncodedData);
+                expect(newRecordsQueryReply.entries[0].encodedData).toBe(originalEncodedData);
             }));
             describe('should inherit data from previous RecordsWrite given a matching dataCid and dataSize and no dataStream', () => {
                 it('with data above the threshold for encodedData', () => __awaiter(this, void 0, void 0, function* () {
@@ -378,24 +376,24 @@ export function testRecordsWriteHandler() {
                     const tenant = author.did;
                     TestStubGenerator.stubDidResolver(didResolver, [author]);
                     const initialWriteReply = yield dwn.processMessage(tenant, message, { dataStream });
-                    expect(initialWriteReply.status.code).to.equal(202);
+                    expect(initialWriteReply.status.code).toBe(202);
                     const write2 = yield RecordsWrite.createFrom({
                         recordsWriteMessage: message,
                         published: true,
                         signer: Jws.createSigner(author),
                     });
                     const writeUpdateReply = yield dwn.processMessage(tenant, write2.message);
-                    expect(writeUpdateReply.status.code).to.equal(202);
+                    expect(writeUpdateReply.status.code).toBe(202);
                     const readMessage = yield RecordsRead.create({
                         filter: {
                             recordId: message.recordId,
                         }
                     });
                     const readMessageReply = yield dwn.processMessage(tenant, readMessage.message);
-                    expect(readMessageReply.status.code).to.equal(200);
-                    expect(readMessageReply.entry.recordsWrite).to.exist;
+                    expect(readMessageReply.status.code).toBe(200);
+                    expect(readMessageReply.entry.recordsWrite).toBeDefined();
                     const data = yield DataStream.toBytes(readMessageReply.entry.data);
-                    expect(data).to.eql(dataBytes);
+                    expect(data).toEqual(dataBytes);
                 }));
                 it('with data equal to or below the threshold for encodedData', () => __awaiter(this, void 0, void 0, function* () {
                     const { message, author, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({
@@ -405,24 +403,24 @@ export function testRecordsWriteHandler() {
                     const tenant = author.did;
                     TestStubGenerator.stubDidResolver(didResolver, [author]);
                     const initialWriteReply = yield dwn.processMessage(tenant, message, { dataStream });
-                    expect(initialWriteReply.status.code).to.equal(202);
+                    expect(initialWriteReply.status.code).toBe(202);
                     const write2 = yield RecordsWrite.createFrom({
                         recordsWriteMessage: message,
                         published: true,
                         signer: Jws.createSigner(author),
                     });
                     const writeUpdateReply = yield dwn.processMessage(tenant, write2.message);
-                    expect(writeUpdateReply.status.code).to.equal(202);
+                    expect(writeUpdateReply.status.code).toBe(202);
                     const readMessage = yield RecordsRead.create({
                         filter: {
                             recordId: message.recordId,
                         }
                     });
                     const readMessageReply = yield dwn.processMessage(tenant, readMessage.message);
-                    expect(readMessageReply.status.code).to.equal(200);
-                    expect(readMessageReply.entry.recordsWrite).to.exist;
+                    expect(readMessageReply.status.code).toBe(200);
+                    expect(readMessageReply.entry.recordsWrite).toBeDefined();
                     const data = yield DataStream.toBytes(readMessageReply.entry.data);
-                    expect(data).to.eql(dataBytes);
+                    expect(data).toEqual(dataBytes);
                 }));
             });
             describe('should return 400 if actual data size mismatches with `dataSize` in descriptor', () => {
@@ -448,8 +446,8 @@ export function testRecordsWriteHandler() {
                     message.recordId = recordId;
                     message.authorization = { signature };
                     const reply = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain(DwnErrorCode.RecordsWriteDataSizeMismatch);
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain(DwnErrorCode.RecordsWriteDataSizeMismatch);
                 }));
                 it('with only `dataSize` larger than encodedData threshold', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -473,8 +471,8 @@ export function testRecordsWriteHandler() {
                     message.recordId = recordId;
                     message.authorization = { signature };
                     const reply = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain(DwnErrorCode.RecordsWriteDataSizeMismatch);
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain(DwnErrorCode.RecordsWriteDataSizeMismatch);
                 }));
                 it('with only dataStream larger than encodedData threshold', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -498,8 +496,8 @@ export function testRecordsWriteHandler() {
                     message.recordId = recordId;
                     message.authorization = { signature };
                     const reply = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain(DwnErrorCode.RecordsWriteDataSizeMismatch);
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain(DwnErrorCode.RecordsWriteDataSizeMismatch);
                 }));
                 it('with both `dataSize` and dataStream below than encodedData threshold', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -522,8 +520,8 @@ export function testRecordsWriteHandler() {
                     message.recordId = recordId;
                     message.authorization = { signature };
                     const reply = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain(DwnErrorCode.RecordsWriteDataSizeMismatch);
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain(DwnErrorCode.RecordsWriteDataSizeMismatch);
                 }));
             });
             it('should return 400 for data CID mismatch with both dataStream and `dataSize` larger than encodedData threshold', () => __awaiter(this, void 0, void 0, function* () {
@@ -534,8 +532,8 @@ export function testRecordsWriteHandler() {
                 });
                 const dataStream = DataStream.fromBytes(TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1)); // mismatch data stream
                 const reply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain(DwnErrorCode.RecordsWriteDataCidMismatch);
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain(DwnErrorCode.RecordsWriteDataCidMismatch);
             }));
             it('should return 400 for data CID mismatch with `dataSize` larger than encodedData threshold', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -545,8 +543,8 @@ export function testRecordsWriteHandler() {
                 });
                 const dataStream = DataStream.fromBytes(TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded)); // mismatch data stream
                 const reply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain(DwnErrorCode.RecordsWriteDataCidMismatch);
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain(DwnErrorCode.RecordsWriteDataCidMismatch);
             }));
             it('should return 400 for data CID mismatch with dataStream larger than encodedData threshold', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -556,8 +554,8 @@ export function testRecordsWriteHandler() {
                 });
                 const dataStream = DataStream.fromBytes(TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1)); // mismatch data stream
                 const reply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain(DwnErrorCode.RecordsWriteDataCidMismatch);
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain(DwnErrorCode.RecordsWriteDataCidMismatch);
             }));
             it('should return 400 for data CID mismatch with both dataStream and `dataSize` below than encodedData threshold', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -567,8 +565,8 @@ export function testRecordsWriteHandler() {
                 });
                 const dataStream = DataStream.fromBytes(TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded)); // mismatch data stream
                 const reply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain(DwnErrorCode.RecordsWriteDataCidMismatch);
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain(DwnErrorCode.RecordsWriteDataCidMismatch);
             }));
             it('#359 - should not allow access of data by referencing a different`dataCid` in "modify" `RecordsWrite` with large data', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -582,11 +580,11 @@ export function testRecordsWriteHandler() {
                     data,
                 });
                 const write1Reply = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
-                expect(write1Reply.status.code).to.equal(202);
+                expect(write1Reply.status.code).toBe(202);
                 // alice writes another record (which will be modified later)
                 const write2 = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const write2Reply = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
-                expect(write2Reply.status.code).to.equal(202);
+                expect(write2Reply.status.code).toBe(202);
                 // modify write2 by referencing the `dataCid` in write1 (which should not be allowed)
                 const write2Change = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -601,8 +599,8 @@ export function testRecordsWriteHandler() {
                     dataSize
                 });
                 const write2ChangeReply = yield dwn.processMessage(alice.did, write2Change.message);
-                expect(write2ChangeReply.status.code).to.equal(400); // should be disallowed
-                expect(write2ChangeReply.status.detail).to.contain(DwnErrorCode.RecordsWriteDataCidMismatch);
+                expect(write2ChangeReply.status.code).toBe(400); // should be disallowed
+                expect(write2ChangeReply.status.detail).toContain(DwnErrorCode.RecordsWriteDataCidMismatch);
                 // further sanity test to make sure the change is not written, ie. write2 still has the original data
                 const read = yield RecordsRead.create({
                     filter: {
@@ -611,9 +609,9 @@ export function testRecordsWriteHandler() {
                     signer: Jws.createSigner(alice)
                 });
                 const readReply = yield dwn.processMessage(alice.did, read.message);
-                expect(readReply.status.code).to.equal(200);
+                expect(readReply.status.code).toBe(200);
                 const readDataBytes = yield DataStream.toBytes(readReply.entry.data);
-                expect(ArrayUtility.byteArraysEqual(readDataBytes, write2.dataBytes)).to.be.true;
+                expect(ArrayUtility.byteArraysEqual(readDataBytes, write2.dataBytes)).toBe(true);
             }));
             it('#359 - should not allow access of data by referencing a different`dataCid` in "modify" `RecordsWrite`', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -627,11 +625,11 @@ export function testRecordsWriteHandler() {
                     data,
                 });
                 const write1Reply = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
-                expect(write1Reply.status.code).to.equal(202);
+                expect(write1Reply.status.code).toBe(202);
                 // alice writes another record (which will be modified later)
                 const write2 = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const write2Reply = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
-                expect(write2Reply.status.code).to.equal(202);
+                expect(write2Reply.status.code).toBe(202);
                 // modify write2 by referencing the `dataCid` in write1 (which should not be allowed)
                 const write2Change = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -646,8 +644,8 @@ export function testRecordsWriteHandler() {
                     dataSize
                 });
                 const write2ChangeReply = yield dwn.processMessage(alice.did, write2Change.message);
-                expect(write2ChangeReply.status.code).to.equal(400); // should be disallowed
-                expect(write2ChangeReply.status.detail).to.contain(DwnErrorCode.RecordsWriteDataCidMismatch);
+                expect(write2ChangeReply.status.code).toBe(400); // should be disallowed
+                expect(write2ChangeReply.status.detail).toContain(DwnErrorCode.RecordsWriteDataCidMismatch);
                 // further sanity test to make sure the change is not written, ie. write2 still has the original data
                 const read = yield RecordsRead.create({
                     filter: {
@@ -656,9 +654,9 @@ export function testRecordsWriteHandler() {
                     signer: Jws.createSigner(alice)
                 });
                 const readReply = yield dwn.processMessage(alice.did, read.message);
-                expect(readReply.status.code).to.equal(200);
+                expect(readReply.status.code).toBe(200);
                 const readDataBytes = yield DataStream.toBytes(readReply.entry.data);
-                expect(ArrayUtility.byteArraysEqual(readDataBytes, write2.dataBytes)).to.be.true;
+                expect(ArrayUtility.byteArraysEqual(readDataBytes, write2.dataBytes)).toBe(true);
             }));
             describe('initial write & subsequent write tests', () => {
                 describe('createFrom()', () => {
@@ -675,7 +673,7 @@ export function testRecordsWriteHandler() {
                         // setting up a stub DID resolver
                         TestStubGenerator.stubDidResolver(didResolver, [author]);
                         const reply = yield dwn.processMessage(tenant, message, { dataStream });
-                        expect(reply.status.code).to.equal(202);
+                        expect(reply.status.code).toBe(202);
                         // changing the `published` property
                         const newWrite = yield RecordsWrite.createFrom({
                             recordsWriteMessage: recordsWrite.message,
@@ -683,18 +681,18 @@ export function testRecordsWriteHandler() {
                             signer: Jws.createSigner(author)
                         });
                         const newWriteReply = yield dwn.processMessage(tenant, newWrite.message);
-                        expect(newWriteReply.status.code).to.equal(202);
+                        expect(newWriteReply.status.code).toBe(202);
                         // verify the new record state can be queried
                         const recordsQueryMessageData = yield TestDataGenerator.generateRecordsQuery({
                             author,
                             filter: { recordId: message.recordId }
                         });
                         const recordsQueryReply = yield dwn.processMessage(tenant, recordsQueryMessageData.message);
-                        expect(recordsQueryReply.status.code).to.equal(200);
-                        expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                        expect(recordsQueryReply.entries[0].descriptor.published).to.equal(true);
+                        expect(recordsQueryReply.status.code).toBe(200);
+                        expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                        expect(recordsQueryReply.entries[0].descriptor.published).toBe(true);
                         // very importantly verify the original data is still returned
-                        expect(recordsQueryReply.entries[0].encodedData).to.equal(encodedData);
+                        expect(recordsQueryReply.entries[0].encodedData).toBe(encodedData);
                     }));
                     it('should inherit parent published state when using createFrom() to create RecordsWrite', () => __awaiter(this, void 0, void 0, function* () {
                         var _a;
@@ -705,7 +703,7 @@ export function testRecordsWriteHandler() {
                         // setting up a stub DID resolver
                         TestStubGenerator.stubDidResolver(didResolver, [author]);
                         const reply = yield dwn.processMessage(tenant, message, { dataStream });
-                        expect(reply.status.code).to.equal(202);
+                        expect(reply.status.code).toBe(202);
                         const newData = Encoder.stringToBytes('new data');
                         const newWrite = yield RecordsWrite.createFrom({
                             recordsWriteMessage: recordsWrite.message,
@@ -713,19 +711,19 @@ export function testRecordsWriteHandler() {
                             signer: Jws.createSigner(author)
                         });
                         const newWriteReply = yield dwn.processMessage(tenant, newWrite.message, { dataStream: DataStream.fromBytes(newData) });
-                        expect(newWriteReply.status.code).to.equal(202);
+                        expect(newWriteReply.status.code).toBe(202);
                         // verify the new record state can be queried
                         const recordsQueryMessageData = yield TestDataGenerator.generateRecordsQuery({
                             author,
                             filter: { recordId: message.recordId }
                         });
                         const recordsQueryReply = yield dwn.processMessage(tenant, recordsQueryMessageData.message);
-                        expect(recordsQueryReply.status.code).to.equal(200);
-                        expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+                        expect(recordsQueryReply.status.code).toBe(200);
+                        expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
                         const recordsWriteReturned = recordsQueryReply.entries[0];
-                        expect(recordsWriteReturned.encodedData).to.equal(Encoder.bytesToBase64Url(newData));
-                        expect(recordsWriteReturned.descriptor.published).to.equal(true);
-                        expect(recordsWriteReturned.descriptor.datePublished).to.equal(message.descriptor.datePublished);
+                        expect(recordsWriteReturned.encodedData).toBe(Encoder.bytesToBase64Url(newData));
+                        expect(recordsWriteReturned.descriptor.published).toBe(true);
+                        expect(recordsWriteReturned.descriptor.datePublished).toBe(message.descriptor.datePublished);
                     }));
                 });
                 it('should fail with 400 if modifying a record but its initial write cannot be found in DB', () => __awaiter(this, void 0, void 0, function* () {
@@ -737,8 +735,8 @@ export function testRecordsWriteHandler() {
                     const tenant = author.did;
                     TestStubGenerator.stubDidResolver(didResolver, [author]);
                     const reply = yield dwn.processMessage(tenant, message, { dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain(DwnErrorCode.RecordsWriteGetInitialWriteNotFound);
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain(DwnErrorCode.RecordsWriteGetInitialWriteNotFound);
                 }));
                 it('should return 400 if `dateCreated` and `messageTimestamp` are not the same in an initial write', () => __awaiter(this, void 0, void 0, function* () {
                     const { author, message, dataStream } = yield TestDataGenerator.generateRecordsWrite({
@@ -748,8 +746,8 @@ export function testRecordsWriteHandler() {
                     const tenant = author.did;
                     TestStubGenerator.stubDidResolver(didResolver, [author]);
                     const reply = yield dwn.processMessage(tenant, message, { dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain('must match dateCreated');
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain('must match dateCreated');
                 }));
                 it('should return 400 if `contextId` in an initial protocol-base write mismatches with the expected deterministic `contextId`', () => __awaiter(this, void 0, void 0, function* () {
                     // generate a message with protocol so that computed contextId is also computed and included in message
@@ -757,45 +755,45 @@ export function testRecordsWriteHandler() {
                     message.contextId = yield TestDataGenerator.randomCborSha256Cid(); // make contextId mismatch from computed value
                     TestStubGenerator.stubDidResolver(didResolver, [author]);
                     const reply = yield dwn.processMessage('unused-tenant-DID', message, { dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain('does not match deterministic contextId');
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain('does not match deterministic contextId');
                 }));
-                describe('event log', () => {
-                    it('should add an event to the event log on initial write', () => __awaiter(this, void 0, void 0, function* () {
+                describe('state index', () => {
+                    it('should add an entry to the state index on initial write', () => __awaiter(this, void 0, void 0, function* () {
                         const { message, author, dataStream } = yield TestDataGenerator.generateRecordsWrite();
                         TestStubGenerator.stubDidResolver(didResolver, [author]);
                         const reply = yield dwn.processMessage(author.did, message, { dataStream });
-                        expect(reply.status.code).to.equal(202);
-                        const { events } = yield eventLog.getEvents(author.did);
-                        expect(events.length).to.equal(1);
+                        expect(reply.status.code).toBe(202);
+                        const events = yield stateIndex.getLeaves(author.did, []);
+                        expect(events.length).toBe(1);
                         const messageCid = yield Message.getCid(message);
-                        expect(events[0]).to.equal(messageCid);
+                        expect(events[0]).toBe(messageCid);
                     }));
                     it('should only keep first write and latest write when subsequent writes happen', () => __awaiter(this, void 0, void 0, function* () {
                         const { message, author, dataStream, recordsWrite } = yield TestDataGenerator.generateRecordsWrite();
                         TestStubGenerator.stubDidResolver(didResolver, [author]);
                         const reply = yield dwn.processMessage(author.did, message, { dataStream });
-                        expect(reply.status.code).to.equal(202);
+                        expect(reply.status.code).toBe(202);
                         const newWrite = yield RecordsWrite.createFrom({
                             recordsWriteMessage: recordsWrite.message,
                             published: true,
                             signer: Jws.createSigner(author)
                         });
                         const newWriteReply = yield dwn.processMessage(author.did, newWrite.message);
-                        expect(newWriteReply.status.code).to.equal(202);
+                        expect(newWriteReply.status.code).toBe(202);
                         const newestWrite = yield RecordsWrite.createFrom({
                             recordsWriteMessage: recordsWrite.message,
                             published: true,
                             signer: Jws.createSigner(author)
                         });
                         const newestWriteReply = yield dwn.processMessage(author.did, newestWrite.message);
-                        expect(newestWriteReply.status.code).to.equal(202);
-                        const { events } = yield eventLog.getEvents(author.did);
-                        expect(events.length).to.equal(2);
+                        expect(newestWriteReply.status.code).toBe(202);
+                        const events = yield stateIndex.getLeaves(author.did, []);
+                        expect(events.length).toBe(2);
                         const deletedMessageCid = yield Message.getCid(newWrite.message);
                         for (const messageCid of events) {
                             if (messageCid === deletedMessageCid) {
-                                expect.fail(`${messageCid} should not exist`);
+                                throw new Error(`${messageCid} should not exist`);
                             }
                         }
                     }));
@@ -816,7 +814,7 @@ export function testRecordsWriteHandler() {
                     // setting up a stub DID resolver
                     TestStubGenerator.stubDidResolver(didResolver, [alice, bob]);
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // generate a `RecordsWrite` message from bob
                     const bobData = Encoder.stringToBytes('data from bob');
                     const emailFromBob = yield TestDataGenerator.generateRecordsWrite({
@@ -828,16 +826,16 @@ export function testRecordsWriteHandler() {
                         data: bobData
                     });
                     const bobWriteReply = yield dwn.processMessage(alice.did, emailFromBob.message, { dataStream: emailFromBob.dataStream });
-                    expect(bobWriteReply.status.code).to.equal(202);
+                    expect(bobWriteReply.status.code).toBe(202);
                     // verify bob's message got written to the DB
                     const messageDataForQueryingBobsWrite = yield TestDataGenerator.generateRecordsQuery({
                         author: alice,
                         filter: { recordId: emailFromBob.message.recordId }
                     });
                     const bobRecordsQueryReply = yield dwn.processMessage(alice.did, messageDataForQueryingBobsWrite.message);
-                    expect(bobRecordsQueryReply.status.code).to.equal(200);
-                    expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                    expect(bobRecordsQueryReply.entries[0].encodedData).to.equal(Encoder.bytesToBase64Url(bobData));
+                    expect(bobRecordsQueryReply.status.code).toBe(200);
+                    expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                    expect(bobRecordsQueryReply.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(bobData));
                 }));
                 it('should allow co-update with allow-anyone rule', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Alice creates a record on her DWN, and Bob (anyone) is able to update it. Bob is not able to
@@ -850,7 +848,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // Alice creates a doc
                     const docRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -859,7 +857,7 @@ export function testRecordsWriteHandler() {
                         protocolPath: 'doc'
                     });
                     const docRecordsReply = yield dwn.processMessage(alice.did, docRecord.message, { dataStream: docRecord.dataStream });
-                    expect(docRecordsReply.status.code).to.equal(202);
+                    expect(docRecordsReply.status.code).toBe(202);
                     // Bob updates Alice's doc
                     const bobsData = yield TestDataGenerator.randomBytes(10);
                     const docUpdateRecord = yield TestDataGenerator.generateFromRecordsWrite({
@@ -868,7 +866,7 @@ export function testRecordsWriteHandler() {
                         data: bobsData
                     });
                     const docUpdateRecordsReply = yield dwn.processMessage(alice.did, docUpdateRecord.message, { dataStream: docUpdateRecord.dataStream });
-                    expect(docUpdateRecordsReply.status.code).to.equal(202);
+                    expect(docUpdateRecordsReply.status.code).toBe(202);
                     // Bob tries and fails to create a new record
                     const bobDocRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: bob,
@@ -877,8 +875,8 @@ export function testRecordsWriteHandler() {
                         protocolPath: 'doc'
                     });
                     const bobDocRecordsReply = yield dwn.processMessage(alice.did, bobDocRecord.message, { dataStream: bobDocRecord.dataStream });
-                    expect(bobDocRecordsReply.status.code).to.equal(401);
-                    expect(bobDocRecordsReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                    expect(bobDocRecordsReply.status.code).toBe(401);
+                    expect(bobDocRecordsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                 }));
                 describe('recipient rules', () => {
                     it('should allow write with ancestor recipient rule', () => __awaiter(this, void 0, void 0, function* () {
@@ -898,7 +896,7 @@ export function testRecordsWriteHandler() {
                         // setting up a stub DID resolver
                         TestStubGenerator.stubDidResolver(didResolver, [alice, vcIssuer, carol]);
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // write a credential application to Alice's DWN to simulate that she has sent a credential application to a VC issuer
                         const encodedCredentialApplication = new TextEncoder().encode('credential application data');
                         const credentialApplication = yield TestDataGenerator.generateRecordsWrite({
@@ -911,7 +909,7 @@ export function testRecordsWriteHandler() {
                             data: encodedCredentialApplication
                         });
                         const credentialApplicationReply = yield dwn.processMessage(alice.did, credentialApplication.message, { dataStream: credentialApplication.dataStream });
-                        expect(credentialApplicationReply.status.code).to.equal(202);
+                        expect(credentialApplicationReply.status.code).toBe(202);
                         // generate a credential application response message from VC issuer
                         const encodedCredentialResponse = new TextEncoder().encode('credential response data');
                         const credentialResponse = yield TestDataGenerator.generateRecordsWrite({
@@ -925,17 +923,17 @@ export function testRecordsWriteHandler() {
                             data: encodedCredentialResponse
                         });
                         const credentialResponseReply = yield dwn.processMessage(alice.did, credentialResponse.message, { dataStream: credentialResponse.dataStream });
-                        expect(credentialResponseReply.status.code).to.equal(202);
+                        expect(credentialResponseReply.status.code).toBe(202);
                         // verify VC issuer's message got written to the DB
                         const messageDataForQueryingCredentialResponse = yield TestDataGenerator.generateRecordsQuery({
                             author: alice,
                             filter: { recordId: credentialResponse.message.recordId }
                         });
                         const applicationResponseQueryReply = yield dwn.processMessage(alice.did, messageDataForQueryingCredentialResponse.message);
-                        expect(applicationResponseQueryReply.status.code).to.equal(200);
-                        expect((_a = applicationResponseQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+                        expect(applicationResponseQueryReply.status.code).toBe(200);
+                        expect((_a = applicationResponseQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
                         expect(applicationResponseQueryReply.entries[0].encodedData)
-                            .to.equal(base64url.baseEncode(encodedCredentialResponse));
+                            .toBe(base64url.baseEncode(encodedCredentialResponse));
                     }));
                     it('should allow co-update with ancestor recipient rule', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice creates a post with Bob as recipient. Alice adds a `post/tag` to the post. Bob is able to update
@@ -948,7 +946,7 @@ export function testRecordsWriteHandler() {
                             protocolDefinition
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates a post with Bob as recipient
                         const docRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -957,7 +955,7 @@ export function testRecordsWriteHandler() {
                             protocolPath: 'post'
                         });
                         const docRecordsReply = yield dwn.processMessage(alice.did, docRecord.message, { dataStream: docRecord.dataStream });
-                        expect(docRecordsReply.status.code).to.equal(202);
+                        expect(docRecordsReply.status.code).toBe(202);
                         // Alice creates a post/tag
                         const tagRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -967,7 +965,7 @@ export function testRecordsWriteHandler() {
                             parentContextId: docRecord.message.contextId,
                         });
                         const tagRecordsReply = yield dwn.processMessage(alice.did, tagRecord.message, { dataStream: tagRecord.dataStream });
-                        expect(tagRecordsReply.status.code).to.equal(202);
+                        expect(tagRecordsReply.status.code).toBe(202);
                         // Bob updates Alice's post
                         const bobsData = yield TestDataGenerator.randomBytes(10);
                         const tagUpdateRecord = yield TestDataGenerator.generateFromRecordsWrite({
@@ -976,7 +974,7 @@ export function testRecordsWriteHandler() {
                             data: bobsData
                         });
                         const tagUpdateRecordsReply = yield dwn.processMessage(alice.did, tagUpdateRecord.message, { dataStream: tagUpdateRecord.dataStream });
-                        expect(tagUpdateRecordsReply.status.code).to.equal(202);
+                        expect(tagUpdateRecordsReply.status.code).toBe(202);
                         // Bob tries and fails to create a new record
                         const bobTagRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: bob,
@@ -986,8 +984,8 @@ export function testRecordsWriteHandler() {
                             parentContextId: docRecord.message.contextId,
                         });
                         const bobTagRecordsReply = yield dwn.processMessage(alice.did, bobTagRecord.message, { dataStream: bobTagRecord.dataStream });
-                        expect(bobTagRecordsReply.status.code).to.equal(401);
-                        expect(bobTagRecordsReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                        expect(bobTagRecordsReply.status.code).toBe(401);
+                        expect(bobTagRecordsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                     }));
                     it('should allow co-update with direct recipient rule', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario:
@@ -1005,7 +1003,7 @@ export function testRecordsWriteHandler() {
                         // setting up a stub DID resolver
                         TestStubGenerator.stubDidResolver(didResolver, [alice, bob, carol]);
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates a 'post' with Bob as recipient
                         const recordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1014,22 +1012,22 @@ export function testRecordsWriteHandler() {
                             protocolPath: 'post',
                         });
                         const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
-                        expect(recordsWriteReply.status.code).to.eq(202);
+                        expect(recordsWriteReply.status.code).toBe(202);
                         // Carol is unable to update the 'post'
                         const carolRecordsWrite = yield TestDataGenerator.generateFromRecordsWrite({
                             author: carol,
                             existingWrite: recordsWrite.recordsWrite
                         });
                         const carolRecordsWriteReply = yield dwn.processMessage(alice.did, carolRecordsWrite.message);
-                        expect(carolRecordsWriteReply.status.code).to.eq(401);
-                        expect(carolRecordsWriteReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                        expect(carolRecordsWriteReply.status.code).toBe(401);
+                        expect(carolRecordsWriteReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                         // Bob is able to update the post
                         const bobRecordsWrite = yield TestDataGenerator.generateFromRecordsWrite({
                             author: bob,
                             existingWrite: recordsWrite.recordsWrite,
                         });
                         const bobRecordsWriteReply = yield dwn.processMessage(alice.did, bobRecordsWrite.message, { dataStream: bobRecordsWrite.dataStream });
-                        expect(bobRecordsWriteReply.status.code).to.eq(202);
+                        expect(bobRecordsWriteReply.status.code).toBe(202);
                     }));
                 });
                 describe('author action rules', () => {
@@ -1049,7 +1047,7 @@ export function testRecordsWriteHandler() {
                             protocolDefinition
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice writes image to bob's DWN
                         const encodedImage = new TextEncoder().encode('cafe-aesthetic.jpg');
                         const imageRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
@@ -1061,7 +1059,7 @@ export function testRecordsWriteHandler() {
                             data: encodedImage
                         });
                         const imageReply = yield dwn.processMessage(bob.did, imageRecordsWrite.message, { dataStream: imageRecordsWrite.dataStream });
-                        expect(imageReply.status.code).to.equal(202);
+                        expect(imageReply.status.code).toBe(202);
                         // AliceImposter attempts and fails to caption Alice's image
                         const encodedCaptionImposter = new TextEncoder().encode('bad vibes! >:(');
                         const captionImposter = yield TestDataGenerator.generateRecordsWrite({
@@ -1074,8 +1072,8 @@ export function testRecordsWriteHandler() {
                             data: encodedCaptionImposter
                         });
                         const captionReply = yield dwn.processMessage(bob.did, captionImposter.message, { dataStream: captionImposter.dataStream });
-                        expect(captionReply.status.code).to.equal(401);
-                        expect(captionReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                        expect(captionReply.status.code).toBe(401);
+                        expect(captionReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                         // Alice is able to add a caption to her image
                         const encodedCaption = new TextEncoder().encode('coffee and work vibes!');
                         const captionRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
@@ -1088,17 +1086,17 @@ export function testRecordsWriteHandler() {
                             data: encodedCaption
                         });
                         const captionResponse = yield dwn.processMessage(bob.did, captionRecordsWrite.message, { dataStream: captionRecordsWrite.dataStream });
-                        expect(captionResponse.status.code).to.equal(202);
+                        expect(captionResponse.status.code).toBe(202);
                         // Verify Alice's caption got written to the DB
                         const messageDataForQueryingCaptionResponse = yield TestDataGenerator.generateRecordsQuery({
                             author: alice,
                             filter: { recordId: captionRecordsWrite.message.recordId }
                         });
                         const applicationResponseQueryReply = yield dwn.processMessage(bob.did, messageDataForQueryingCaptionResponse.message);
-                        expect(applicationResponseQueryReply.status.code).to.equal(200);
-                        expect((_a = applicationResponseQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+                        expect(applicationResponseQueryReply.status.code).toBe(200);
+                        expect((_a = applicationResponseQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
                         expect(applicationResponseQueryReply.entries[0].encodedData)
-                            .to.equal(base64url.baseEncode(encodedCaption));
+                            .toBe(base64url.baseEncode(encodedCaption));
                     }));
                     it('should allow co-update with ancestor author rule', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Bob authors a post on Alice's DWN. Alice adds a comment to the post. Bob is able to update the comment,
@@ -1111,7 +1109,7 @@ export function testRecordsWriteHandler() {
                             protocolDefinition
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Bob creates a post
                         const postRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: bob,
@@ -1120,7 +1118,7 @@ export function testRecordsWriteHandler() {
                             protocolPath: 'post'
                         });
                         const postRecordsReply = yield dwn.processMessage(alice.did, postRecord.message, { dataStream: postRecord.dataStream });
-                        expect(postRecordsReply.status.code).to.equal(202);
+                        expect(postRecordsReply.status.code).toBe(202);
                         // Alice creates a post/comment
                         const commentRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1130,7 +1128,7 @@ export function testRecordsWriteHandler() {
                             parentContextId: postRecord.message.contextId,
                         });
                         const commentRecordsReply = yield dwn.processMessage(alice.did, commentRecord.message, { dataStream: commentRecord.dataStream });
-                        expect(commentRecordsReply.status.code).to.equal(202);
+                        expect(commentRecordsReply.status.code).toBe(202);
                         // Bob updates Alice's comment
                         const bobsData = yield TestDataGenerator.randomBytes(10);
                         const postUpdateRecord = yield TestDataGenerator.generateFromRecordsWrite({
@@ -1139,7 +1137,7 @@ export function testRecordsWriteHandler() {
                             data: bobsData
                         });
                         const commentUpdateRecordsReply = yield dwn.processMessage(alice.did, postUpdateRecord.message, { dataStream: postUpdateRecord.dataStream });
-                        expect(commentUpdateRecordsReply.status.code).to.equal(202);
+                        expect(commentUpdateRecordsReply.status.code).toBe(202);
                         // Bob tries and fails to create a new comment
                         const bobPostRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: bob,
@@ -1149,8 +1147,8 @@ export function testRecordsWriteHandler() {
                             parentContextId: postRecord.message.contextId,
                         });
                         const bobPostRecordsReply = yield dwn.processMessage(alice.did, bobPostRecord.message, { dataStream: bobPostRecord.dataStream });
-                        expect(bobPostRecordsReply.status.code).to.equal(401);
-                        expect(bobPostRecordsReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                        expect(bobPostRecordsReply.status.code).toBe(401);
+                        expect(bobPostRecordsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                     }));
                 });
                 describe('role rules', () => {
@@ -1165,7 +1163,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Alice writes a 'friend' root-level role record with Bob as recipient
                             const friendRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1175,14 +1173,14 @@ export function testRecordsWriteHandler() {
                                 data: new TextEncoder().encode('Bob is my friend'),
                             });
                             const friendRoleReply = yield dwn.processMessage(alice.did, friendRoleRecord.message, { dataStream: friendRoleRecord.dataStream });
-                            expect(friendRoleReply.status.code).to.equal(202);
+                            expect(friendRoleReply.status.code).toBe(202);
                             // Alice updates Bob's 'friend' record
                             const updateFriendRecord = yield TestDataGenerator.generateFromRecordsWrite({
                                 author: alice,
                                 existingWrite: friendRoleRecord.recordsWrite,
                             });
                             const updateFriendReply = yield dwn.processMessage(alice.did, updateFriendRecord.message, { dataStream: updateFriendRecord.dataStream });
-                            expect(updateFriendReply.status.code).to.equal(202);
+                            expect(updateFriendReply.status.code).toBe(202);
                         }));
                         it('should reject role RecordsWrite if recipient is undefined', () => __awaiter(this, void 0, void 0, function* () {
                             // scenario: Alice writes a root-level role record with no recipient and it is rejected
@@ -1193,7 +1191,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Alice writes a 'friend' root-level role record with no recipient
                             const friendRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1202,8 +1200,8 @@ export function testRecordsWriteHandler() {
                                 data: new TextEncoder().encode('Bob is my friend'),
                             });
                             const friendRoleReply = yield dwn.processMessage(alice.did, friendRoleRecord.message, { dataStream: friendRoleRecord.dataStream });
-                            expect(friendRoleReply.status.code).to.equal(400);
-                            expect(friendRoleReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationRoleMissingRecipient);
+                            expect(friendRoleReply.status.code).toBe(400);
+                            expect(friendRoleReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationRoleMissingRecipient);
                         }));
                         it('should allow a new root-level role record to be created for the same recipient if their old one was deleted', () => __awaiter(this, void 0, void 0, function* () {
                             // scenario: Alice adds Bob to the 'friend' role, then deletes the role. Alice writes a new record adding Bob as a 'friend' again.
@@ -1215,7 +1213,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Alice writes a 'friend' root-level role record with Bob as recipient
                             const friendRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1225,14 +1223,14 @@ export function testRecordsWriteHandler() {
                                 data: new TextEncoder().encode('Bob is my friend'),
                             });
                             const friendRoleReply = yield dwn.processMessage(alice.did, friendRoleRecord.message, { dataStream: friendRoleRecord.dataStream });
-                            expect(friendRoleReply.status.code).to.equal(202);
+                            expect(friendRoleReply.status.code).toBe(202);
                             // Alice deletes Bob's 'friend' role record
                             const deleteFriend = yield TestDataGenerator.generateRecordsDelete({
                                 author: alice,
                                 recordId: friendRoleRecord.message.recordId,
                             });
                             const deleteFriendReply = yield dwn.processMessage(alice.did, deleteFriend.message);
-                            expect(deleteFriendReply.status.code).to.equal(202);
+                            expect(deleteFriendReply.status.code).toBe(202);
                             // Alice writes a new record adding Bob as a 'friend' again
                             const duplicateFriendRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1242,7 +1240,7 @@ export function testRecordsWriteHandler() {
                                 data: new TextEncoder().encode('Bob is still my friend'),
                             });
                             const duplicateFriendReply = yield dwn.processMessage(alice.did, duplicateFriendRecord.message, { dataStream: duplicateFriendRecord.dataStream });
-                            expect(duplicateFriendReply.status.code).to.equal(202);
+                            expect(duplicateFriendReply.status.code).toBe(202);
                         }));
                     });
                     describe('write context role records', () => {
@@ -1256,7 +1254,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Alice creates a thread
                             const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1265,7 +1263,7 @@ export function testRecordsWriteHandler() {
                                 protocolPath: 'thread'
                             });
                             const threadRecordReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                            expect(threadRecordReply.status.code).to.equal(202);
+                            expect(threadRecordReply.status.code).toBe(202);
                             // Alice adds Bob as a 'thread/participant' in that thread
                             const participantRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1275,14 +1273,14 @@ export function testRecordsWriteHandler() {
                                 parentContextId: threadRecord.message.contextId,
                             });
                             const participantRecordReply = yield dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
-                            expect(participantRecordReply.status.code).to.equal(202);
+                            expect(participantRecordReply.status.code).toBe(202);
                             // Alice updates Bob's role record
                             const participantUpdateRecord = yield TestDataGenerator.generateFromRecordsWrite({
                                 author: alice,
                                 existingWrite: participantRecord.recordsWrite,
                             });
                             const participantUpdateRecordReply = yield dwn.processMessage(alice.did, participantUpdateRecord.message, { dataStream: participantUpdateRecord.dataStream });
-                            expect(participantUpdateRecordReply.status.code).to.equal(202);
+                            expect(participantUpdateRecordReply.status.code).toBe(202);
                         }));
                         it('can create the same role under different contexts', () => __awaiter(this, void 0, void 0, function* () {
                             // scenario: Alice creates a thread and adds Bob to the 'thread/participant' role. Alice repeats the steps with a new thread.
@@ -1294,7 +1292,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Alice creates the first thread
                             const threadRecord1 = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1303,7 +1301,7 @@ export function testRecordsWriteHandler() {
                                 protocolPath: 'thread'
                             });
                             const threadRecordReply1 = yield dwn.processMessage(alice.did, threadRecord1.message, { dataStream: threadRecord1.dataStream });
-                            expect(threadRecordReply1.status.code).to.equal(202);
+                            expect(threadRecordReply1.status.code).toBe(202);
                             // Alice adds Bob as a 'thread/participant' to the first thread
                             const participantRecord1 = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1313,7 +1311,7 @@ export function testRecordsWriteHandler() {
                                 parentContextId: threadRecord1.message.contextId,
                             });
                             const participantRecordReply1 = yield dwn.processMessage(alice.did, participantRecord1.message, { dataStream: participantRecord1.dataStream });
-                            expect(participantRecordReply1.status.code).to.equal(202);
+                            expect(participantRecordReply1.status.code).toBe(202);
                             // Alice creates a second thread
                             const threadRecord2 = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1322,7 +1320,7 @@ export function testRecordsWriteHandler() {
                                 protocolPath: 'thread'
                             });
                             const threadRecordReply2 = yield dwn.processMessage(alice.did, threadRecord2.message, { dataStream: threadRecord2.dataStream });
-                            expect(threadRecordReply2.status.code).to.equal(202);
+                            expect(threadRecordReply2.status.code).toBe(202);
                             // Alice adds Bob as a 'thread/participant' to the second thread
                             const participantRecord2 = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1332,7 +1330,7 @@ export function testRecordsWriteHandler() {
                                 parentContextId: threadRecord2.message.contextId,
                             });
                             const participantRecordReply2 = yield dwn.processMessage(alice.did, participantRecord2.message, { dataStream: participantRecord2.dataStream });
-                            expect(participantRecordReply2.status.code).to.equal(202);
+                            expect(participantRecordReply2.status.code).toBe(202);
                         }));
                         it('rejects writes to a $role record if there already exists one in the same context', () => __awaiter(this, void 0, void 0, function* () {
                             // scenario: Alice creates a thread and adds Bob to the 'thread/participant' role. She adds Bob to the role second time and fails
@@ -1344,7 +1342,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Alice creates the first thread
                             const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1353,7 +1351,7 @@ export function testRecordsWriteHandler() {
                                 protocolPath: 'thread'
                             });
                             const threadRecordReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                            expect(threadRecordReply.status.code).to.equal(202);
+                            expect(threadRecordReply.status.code).toBe(202);
                             // Alice adds Bob as a 'thread/participant' to the thread
                             const participantRecord1 = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1363,7 +1361,7 @@ export function testRecordsWriteHandler() {
                                 parentContextId: threadRecord.message.contextId,
                             });
                             const participantRecordReply1 = yield dwn.processMessage(alice.did, participantRecord1.message, { dataStream: participantRecord1.dataStream });
-                            expect(participantRecordReply1.status.code).to.equal(202);
+                            expect(participantRecordReply1.status.code).toBe(202);
                             // Alice adds Bob as a 'thread/participant' again to the same thread
                             const participantRecord2 = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1373,8 +1371,8 @@ export function testRecordsWriteHandler() {
                                 parentContextId: threadRecord.message.contextId,
                             });
                             const participantRecordReply2 = yield dwn.processMessage(alice.did, participantRecord2.message, { dataStream: participantRecord2.dataStream });
-                            expect(participantRecordReply2.status.code).to.equal(400);
-                            expect(participantRecordReply2.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationDuplicateRoleRecipient);
+                            expect(participantRecordReply2.status.code).toBe(400);
+                            expect(participantRecordReply2.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationDuplicateRoleRecipient);
                         }));
                         it('allows a new context role record to be created for the same recipient in the same context if their old one was deleted', () => __awaiter(this, void 0, void 0, function* () {
                             // scenario: Alice creates a thread and adds Bob to the 'thread/participant' role. She deletes the role and then adds a new one.
@@ -1386,7 +1384,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Alice creates the first thread
                             const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1395,7 +1393,7 @@ export function testRecordsWriteHandler() {
                                 protocolPath: 'thread'
                             });
                             const threadRecordReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                            expect(threadRecordReply.status.code).to.equal(202);
+                            expect(threadRecordReply.status.code).toBe(202);
                             // Alice adds Bob as a 'thread/participant' to the thread
                             const participantRecord1 = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1405,14 +1403,14 @@ export function testRecordsWriteHandler() {
                                 parentContextId: threadRecord.message.contextId,
                             });
                             const participantRecordReply1 = yield dwn.processMessage(alice.did, participantRecord1.message, { dataStream: participantRecord1.dataStream });
-                            expect(participantRecordReply1.status.code).to.equal(202);
+                            expect(participantRecordReply1.status.code).toBe(202);
                             // Alice deletes the participant record
                             const participantDelete = yield TestDataGenerator.generateRecordsDelete({
                                 author: alice,
                                 recordId: participantRecord1.message.recordId,
                             });
                             const participantDeleteReply = yield dwn.processMessage(alice.did, participantDelete.message);
-                            expect(participantDeleteReply.status.code).to.equal(202);
+                            expect(participantDeleteReply.status.code).toBe(202);
                             // Alice creates a new 'thread/participant' record
                             const participantRecord2 = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1422,7 +1420,7 @@ export function testRecordsWriteHandler() {
                                 parentContextId: threadRecord.message.contextId,
                             });
                             const participantRecordReply2 = yield dwn.processMessage(alice.did, participantRecord2.message, { dataStream: participantRecord2.dataStream });
-                            expect(participantRecordReply2.status.code).to.equal(202);
+                            expect(participantRecordReply2.status.code).toBe(202);
                         }));
                     });
                     describe('role based writes', () => {
@@ -1437,7 +1435,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Alice writes a 'friend' $root-level role record with Bob as recipient
                             const friendRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1447,7 +1445,7 @@ export function testRecordsWriteHandler() {
                                 data: new TextEncoder().encode('Bob is my friend'),
                             });
                             const friendRoleReply = yield dwn.processMessage(alice.did, friendRoleRecord.message, { dataStream: friendRoleRecord.dataStream });
-                            expect(friendRoleReply.status.code).to.equal(202);
+                            expect(friendRoleReply.status.code).toBe(202);
                             // Bob writes a 'chat' record
                             const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: bob,
@@ -1458,7 +1456,7 @@ export function testRecordsWriteHandler() {
                                 protocolRole: 'friend'
                             });
                             const chatReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-                            expect(chatReply.status.code).to.equal(202);
+                            expect(chatReply.status.code).toBe(202);
                         }));
                         it('uses a root-level role to authorize a co-update', () => __awaiter(this, void 0, void 0, function* () {
                             // scenario: Alice gives Bob a admin role. Bob invokes his
@@ -1471,7 +1469,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Alice writes a 'admin' root-level role record with Bob as recipient
                             const friendRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1481,7 +1479,7 @@ export function testRecordsWriteHandler() {
                                 data: new TextEncoder().encode('Bob is my friend'),
                             });
                             const friendRoleReply = yield dwn.processMessage(alice.did, friendRoleRecord.message, { dataStream: friendRoleRecord.dataStream });
-                            expect(friendRoleReply.status.code).to.equal(202);
+                            expect(friendRoleReply.status.code).toBe(202);
                             // Alice creates a 'chat' record
                             const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1491,7 +1489,7 @@ export function testRecordsWriteHandler() {
                                 data: new TextEncoder().encode('Bob can write this cuz he is Alices friend'),
                             });
                             const chatReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-                            expect(chatReply.status.code).to.equal(202);
+                            expect(chatReply.status.code).toBe(202);
                             // Bob invokes his admin role to update the 'chat' record
                             const chatUpdateRecord = yield TestDataGenerator.generateFromRecordsWrite({
                                 author: bob,
@@ -1499,7 +1497,7 @@ export function testRecordsWriteHandler() {
                                 protocolRole: 'admin',
                             });
                             const chatUpdateReply = yield dwn.processMessage(alice.did, chatUpdateRecord.message, { dataStream: chatUpdateRecord.dataStream });
-                            expect(chatUpdateReply.status.code).to.equal(202);
+                            expect(chatUpdateReply.status.code).toBe(202);
                         }));
                         it('rejects root-level role authorized writes if the protocolRole is not a valid protocol path to an active role record', () => __awaiter(this, void 0, void 0, function* () {
                             // scenario: Bob tries to invoke the 'chat' role to write to Alice's DWN, but 'chat' is not a role.
@@ -1511,7 +1509,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Alice writes a 'chat' record with Bob as recipient
                             const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1521,7 +1519,7 @@ export function testRecordsWriteHandler() {
                                 data: new TextEncoder().encode('Blah blah blah'),
                             });
                             const chatReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-                            expect(chatReply.status.code).to.equal(202);
+                            expect(chatReply.status.code).toBe(202);
                             // Bob tries to invoke a 'chat' role but 'chat' is not a role
                             const writeChatRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: bob,
@@ -1532,8 +1530,8 @@ export function testRecordsWriteHandler() {
                                 protocolRole: 'chat',
                             });
                             const chatReadReply = yield dwn.processMessage(alice.did, writeChatRecord.message, { dataStream: writeChatRecord.dataStream });
-                            expect(chatReadReply.status.code).to.equal(401);
-                            expect(chatReadReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationNotARole);
+                            expect(chatReadReply.status.code).toBe(401);
+                            expect(chatReadReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationNotARole);
                         }));
                         it('rejects root-level role authorized writes if there is no active role for the recipient', () => __awaiter(this, void 0, void 0, function* () {
                             // scenario: Bob tries to invoke a role to write, but he has not been given one.
@@ -1545,7 +1543,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Bob writes a 'chat' record invoking a friend role that he does not have
                             const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: bob,
@@ -1556,8 +1554,8 @@ export function testRecordsWriteHandler() {
                                 protocolRole: 'friend'
                             });
                             const chatReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-                            expect(chatReply.status.code).to.equal(401);
-                            expect(chatReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
+                            expect(chatReply.status.code).toBe(401);
+                            expect(chatReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
                         }));
                         it('uses a context role to authorize a write', () => __awaiter(this, void 0, void 0, function* () {
                             // scenario: Alice creates a thread and adds Bob to the 'thread/participant' role. Bob invokes the record to write in the thread
@@ -1569,7 +1567,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Alice creates a thread
                             const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1578,7 +1576,7 @@ export function testRecordsWriteHandler() {
                                 protocolPath: 'thread'
                             });
                             const threadRecordReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                            expect(threadRecordReply.status.code).to.equal(202);
+                            expect(threadRecordReply.status.code).toBe(202);
                             // Alice adds Bob as a 'thread/participant' in that thread
                             const participantRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1588,7 +1586,7 @@ export function testRecordsWriteHandler() {
                                 parentContextId: threadRecord.message.contextId,
                             });
                             const participantRecordReply = yield dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
-                            expect(participantRecordReply.status.code).to.equal(202);
+                            expect(participantRecordReply.status.code).toBe(202);
                             // Bob invokes the role to write to the thread
                             const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: bob,
@@ -1598,7 +1596,7 @@ export function testRecordsWriteHandler() {
                                 protocolRole: 'thread/participant'
                             });
                             const chatRecordReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-                            expect(chatRecordReply.status.code).to.equal(202);
+                            expect(chatRecordReply.status.code).toBe(202);
                         }));
                         it('uses a context role to authorize a co-update', () => __awaiter(this, void 0, void 0, function* () {
                             // scenario: Alice creates a thread and adds Bob to the 'thread/admin' role.
@@ -1611,7 +1609,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Alice creates a thread
                             const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1620,7 +1618,7 @@ export function testRecordsWriteHandler() {
                                 protocolPath: 'thread'
                             });
                             const threadRecordReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                            expect(threadRecordReply.status.code).to.equal(202);
+                            expect(threadRecordReply.status.code).toBe(202);
                             // Alice adds Bob as a 'thread/participant' in that thread
                             const participantRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1630,7 +1628,7 @@ export function testRecordsWriteHandler() {
                                 parentContextId: threadRecord.message.contextId,
                             });
                             const participantRecordReply = yield dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
-                            expect(participantRecordReply.status.code).to.equal(202);
+                            expect(participantRecordReply.status.code).toBe(202);
                             // Alice writes a chat message in the thread
                             const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1639,7 +1637,7 @@ export function testRecordsWriteHandler() {
                                 parentContextId: threadRecord.message.contextId,
                             });
                             const chatRecordReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-                            expect(chatRecordReply.status.code).to.equal(202);
+                            expect(chatRecordReply.status.code).toBe(202);
                             // Bob invokes his admin role to co-update the chat message
                             const chatCoUpdateRecord = yield TestDataGenerator.generateFromRecordsWrite({
                                 author: bob,
@@ -1647,7 +1645,7 @@ export function testRecordsWriteHandler() {
                                 protocolRole: 'thread/admin',
                             });
                             const chatUpdateRecordReply = yield dwn.processMessage(alice.did, chatCoUpdateRecord.message, { dataStream: chatCoUpdateRecord.dataStream });
-                            expect(chatUpdateRecordReply.status.code).to.equal(202);
+                            expect(chatUpdateRecordReply.status.code).toBe(202);
                         }));
                         it('rejects context role authorized writes if the protocolRole is not a valid protocol path to an active role record', () => __awaiter(this, void 0, void 0, function* () {
                             // scenario: Alice creates a thread and adds Bob as a participant. ALice creates another thread. Bob tries and fails to invoke his
@@ -1660,7 +1658,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Alice creates a thread
                             const threadRecord1 = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1669,7 +1667,7 @@ export function testRecordsWriteHandler() {
                                 protocolPath: 'thread'
                             });
                             const threadRecordReply1 = yield dwn.processMessage(alice.did, threadRecord1.message, { dataStream: threadRecord1.dataStream });
-                            expect(threadRecordReply1.status.code).to.equal(202);
+                            expect(threadRecordReply1.status.code).toBe(202);
                             // Alice adds Bob as a 'thread/participant' in that thread
                             const participantRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1679,7 +1677,7 @@ export function testRecordsWriteHandler() {
                                 parentContextId: threadRecord1.message.contextId,
                             });
                             const participantRecordReply = yield dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
-                            expect(participantRecordReply.status.code).to.equal(202);
+                            expect(participantRecordReply.status.code).toBe(202);
                             // Alice creates a second thread
                             const threadRecord2 = yield TestDataGenerator.generateRecordsWrite({
                                 author: alice,
@@ -1688,7 +1686,7 @@ export function testRecordsWriteHandler() {
                                 protocolPath: 'thread'
                             });
                             const threadRecordReply2 = yield dwn.processMessage(alice.did, threadRecord2.message, { dataStream: threadRecord2.dataStream });
-                            expect(threadRecordReply2.status.code).to.equal(202);
+                            expect(threadRecordReply2.status.code).toBe(202);
                             // Bob invokes his role to try to write to the second thread
                             const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                                 author: bob,
@@ -1698,8 +1696,8 @@ export function testRecordsWriteHandler() {
                                 protocolRole: 'thread/participant'
                             });
                             const chatRecordReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
-                            expect(chatRecordReply.status.code).to.equal(401);
-                            expect(chatRecordReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
+                            expect(chatRecordReply.status.code).toBe(401);
+                            expect(chatRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
                         }));
                         it('rejects attempts to invoke an invalid path as a protocolRole', () => __awaiter(this, void 0, void 0, function* () {
                             // scenario: Bob tries to invoke 'notARealPath' as a protocolRole and fails
@@ -1711,7 +1709,7 @@ export function testRecordsWriteHandler() {
                                 protocolDefinition
                             });
                             const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                            expect(protocolsConfigureReply.status.code).to.equal(202);
+                            expect(protocolsConfigureReply.status.code).toBe(202);
                             // Bob invokes a fake protocolRole to write
                             const fakeRoleInvocation = yield TestDataGenerator.generateRecordsWrite({
                                 author: bob,
@@ -1721,8 +1719,8 @@ export function testRecordsWriteHandler() {
                                 protocolRole: 'notARealPath',
                             });
                             const fakeRoleInvocationReply = yield dwn.processMessage(alice.did, fakeRoleInvocation.message, { dataStream: fakeRoleInvocation.dataStream });
-                            expect(fakeRoleInvocationReply.status.code).to.equal(401);
-                            expect(fakeRoleInvocationReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationNotARole);
+                            expect(fakeRoleInvocationReply.status.code).toBe(401);
+                            expect(fakeRoleInvocationReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationNotARole);
                         }));
                     });
                 });
@@ -1741,7 +1739,7 @@ export function testRecordsWriteHandler() {
                     // setting up a stub DID resolver
                     TestStubGenerator.stubDidResolver(didResolver, [alice, bob]);
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // generate a `RecordsWrite` message from bob
                     const bobData = new TextEncoder().encode('message from bob');
                     const messageFromBob = yield TestDataGenerator.generateRecordsWrite({
@@ -1753,16 +1751,16 @@ export function testRecordsWriteHandler() {
                         data: bobData
                     });
                     const bobWriteReply = yield dwn.processMessage(alice.did, messageFromBob.message, { dataStream: messageFromBob.dataStream });
-                    expect(bobWriteReply.status.code).to.equal(202);
+                    expect(bobWriteReply.status.code).toBe(202);
                     // verify bob's message got written to the DB
                     const messageDataForQueryingBobsWrite = yield TestDataGenerator.generateRecordsQuery({
                         author: alice,
                         filter: { recordId: messageFromBob.message.recordId }
                     });
                     const bobRecordsQueryReply = yield dwn.processMessage(alice.did, messageDataForQueryingBobsWrite.message);
-                    expect(bobRecordsQueryReply.status.code).to.equal(200);
-                    expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                    expect(bobRecordsQueryReply.entries[0].encodedData).to.equal(base64url.baseEncode(bobData));
+                    expect(bobRecordsQueryReply.status.code).toBe(200);
+                    expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                    expect(bobRecordsQueryReply.entries[0].encodedData).toBe(base64url.baseEncode(bobData));
                     // generate a new message from bob updating the existing message
                     const updatedMessageBytes = Encoder.stringToBytes('updated message from bob');
                     const updatedMessageFromBob = yield TestDataGenerator.generateFromRecordsWrite({
@@ -1771,12 +1769,12 @@ export function testRecordsWriteHandler() {
                         data: updatedMessageBytes
                     });
                     const newWriteReply = yield dwn.processMessage(alice.did, updatedMessageFromBob.message, { dataStream: updatedMessageFromBob.dataStream });
-                    expect(newWriteReply.status.code).to.equal(202);
+                    expect(newWriteReply.status.code).toBe(202);
                     // verify bob's message got written to the DB
                     const newRecordQueryReply = yield dwn.processMessage(alice.did, messageDataForQueryingBobsWrite.message);
-                    expect(newRecordQueryReply.status.code).to.equal(200);
-                    expect((_b = newRecordQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-                    expect(newRecordQueryReply.entries[0].encodedData).to.equal(Encoder.bytesToBase64Url(updatedMessageBytes));
+                    expect(newRecordQueryReply.status.code).toBe(200);
+                    expect((_b = newRecordQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                    expect(newRecordQueryReply.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(updatedMessageBytes));
                 }));
                 it('should disallow overwriting existing records by a different author if author is not authorized to `co-update`', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Bob writes into Alice's DWN given Alice's "message" protocol, Carol then attempts to modify the existing message
@@ -1794,7 +1792,7 @@ export function testRecordsWriteHandler() {
                     // setting up a stub DID resolver
                     TestStubGenerator.stubDidResolver(didResolver, [alice, bob, carol]);
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // generate a `RecordsWrite` message from bob
                     const bobData = new TextEncoder().encode('data from bob');
                     const messageFromBob = yield TestDataGenerator.generateRecordsWrite({
@@ -1806,16 +1804,16 @@ export function testRecordsWriteHandler() {
                         data: bobData
                     });
                     const bobWriteReply = yield dwn.processMessage(alice.did, messageFromBob.message, { dataStream: messageFromBob.dataStream });
-                    expect(bobWriteReply.status.code).to.equal(202);
+                    expect(bobWriteReply.status.code).toBe(202);
                     // verify bob's message got written to the DB
                     const messageDataForQueryingBobsWrite = yield TestDataGenerator.generateRecordsQuery({
                         author: alice,
                         filter: { recordId: messageFromBob.message.recordId }
                     });
                     const bobRecordsQueryReply = yield dwn.processMessage(alice.did, messageDataForQueryingBobsWrite.message);
-                    expect(bobRecordsQueryReply.status.code).to.equal(200);
-                    expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                    expect(bobRecordsQueryReply.entries[0].encodedData).to.equal(base64url.baseEncode(bobData));
+                    expect(bobRecordsQueryReply.status.code).toBe(200);
+                    expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                    expect(bobRecordsQueryReply.entries[0].encodedData).toBe(base64url.baseEncode(bobData));
                     // generate a new message from carol updating the existing message, which should not be allowed/accepted
                     const modifiedMessageData = new TextEncoder().encode('modified message by carol');
                     const modifiedMessageFromCarol = yield TestDataGenerator.generateRecordsWrite({
@@ -1828,8 +1826,8 @@ export function testRecordsWriteHandler() {
                         recordId: messageFromBob.message.recordId,
                     });
                     const carolWriteReply = yield dwn.processMessage(alice.did, modifiedMessageFromCarol.message, { dataStream: modifiedMessageFromCarol.dataStream });
-                    expect(carolWriteReply.status.code).to.equal(401);
-                    expect(carolWriteReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                    expect(carolWriteReply.status.code).toBe(401);
+                    expect(carolWriteReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                 }));
                 it('should not allow to change immutable recipient', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Bob writes into Alice's DWN given Alice's "message" protocol allow-anyone rule, then tries to modify immutable recipient
@@ -1848,7 +1846,7 @@ export function testRecordsWriteHandler() {
                     // setting up a stub DID resolver
                     TestStubGenerator.stubDidResolver(didResolver, [alice, bob]);
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // generate a `RecordsWrite` message from bob
                     const bobData = new TextEncoder().encode('message from bob');
                     const messageFromBob = yield TestDataGenerator.generateRecordsWrite({
@@ -1860,16 +1858,16 @@ export function testRecordsWriteHandler() {
                         data: bobData
                     });
                     const bobWriteReply = yield dwn.processMessage(alice.did, messageFromBob.message, { dataStream: messageFromBob.dataStream });
-                    expect(bobWriteReply.status.code).to.equal(202);
+                    expect(bobWriteReply.status.code).toBe(202);
                     // verify bob's message got written to the DB
                     const messageDataForQueryingBobsWrite = yield TestDataGenerator.generateRecordsQuery({
                         author: alice,
                         filter: { recordId: messageFromBob.message.recordId }
                     });
                     const bobRecordsQueryReply = yield dwn.processMessage(alice.did, messageDataForQueryingBobsWrite.message);
-                    expect(bobRecordsQueryReply.status.code).to.equal(200);
-                    expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                    expect(bobRecordsQueryReply.entries[0].encodedData).to.equal(base64url.baseEncode(bobData));
+                    expect(bobRecordsQueryReply.status.code).toBe(200);
+                    expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                    expect(bobRecordsQueryReply.entries[0].encodedData).toBe(base64url.baseEncode(bobData));
                     // generate a new message from bob changing immutable recipient
                     const updatedMessageFromBob = yield TestDataGenerator.generateRecordsWrite({
                         author: bob,
@@ -1883,8 +1881,8 @@ export function testRecordsWriteHandler() {
                         recipient: bob.did // this immutable property was Alice's DID initially
                     });
                     const newWriteReply = yield dwn.processMessage(alice.did, updatedMessageFromBob.message, { dataStream: updatedMessageFromBob.dataStream });
-                    expect(newWriteReply.status.code).to.equal(400);
-                    expect(newWriteReply.status.detail).to.contain('recipient is an immutable property');
+                    expect(newWriteReply.status.code).toBe(400);
+                    expect(newWriteReply.status.detail).toContain('recipient is an immutable property');
                 }));
                 it('should block unauthorized write with recipient rule', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: fake VC issuer attempts write into Alice's DWN a credential response
@@ -1902,7 +1900,7 @@ export function testRecordsWriteHandler() {
                     // setting up a stub DID resolver
                     TestStubGenerator.stubDidResolver(didResolver, [alice, fakeVcIssuer]);
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // write a credential application to Alice's DWN to simulate that she has sent a credential application to a VC issuer
                     const vcIssuer = yield TestDataGenerator.generatePersona();
                     const encodedCredentialApplication = new TextEncoder().encode('credential application data');
@@ -1917,7 +1915,7 @@ export function testRecordsWriteHandler() {
                     });
                     const credentialApplicationContextId = yield credentialApplication.recordsWrite.getEntryId();
                     const credentialApplicationReply = yield dwn.processMessage(alice.did, credentialApplication.message, { dataStream: credentialApplication.dataStream });
-                    expect(credentialApplicationReply.status.code).to.equal(202);
+                    expect(credentialApplicationReply.status.code).toBe(202);
                     // generate a credential application response message from a fake VC issuer
                     const encodedCredentialResponse = new TextEncoder().encode('credential response data');
                     const credentialResponse = yield TestDataGenerator.generateRecordsWrite({
@@ -1931,8 +1929,8 @@ export function testRecordsWriteHandler() {
                         data: encodedCredentialResponse
                     });
                     const credentialResponseReply = yield dwn.processMessage(alice.did, credentialResponse.message, { dataStream: credentialResponse.dataStream });
-                    expect(credentialResponseReply.status.code).to.equal(401);
-                    expect(credentialResponseReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                    expect(credentialResponseReply.status.code).toBe(401);
+                    expect(credentialResponseReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                 }));
                 it('should fail authorization if protocol definition cannot be found for a protocol-based RecordsWrite', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1946,8 +1944,8 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const reply = yield dwn.processMessage(alice.did, credentialApplication.message, { dataStream: credentialApplication.dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain('unable to find protocol definition');
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain('unable to find protocol definition');
                 }));
                 it('should fail authorization if record schema is incorrect for a protocol-based RecordsWrite', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1958,7 +1956,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition
                     });
                     const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfig.message);
-                    expect(protocolConfigureReply.status.code).to.equal(202);
+                    expect(protocolConfigureReply.status.code).toBe(202);
                     const data = Encoder.stringToBytes('any data');
                     const credentialApplication = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -1969,8 +1967,8 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const reply = yield dwn.processMessage(alice.did, credentialApplication.message, { dataStream: credentialApplication.dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationInvalidSchema);
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationInvalidSchema);
                 }));
                 it('should fail authorization if given `protocolPath` contains an invalid record type', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1981,7 +1979,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition
                     });
                     const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfig.message);
-                    expect(protocolConfigureReply.status.code).to.equal(202);
+                    expect(protocolConfigureReply.status.code).toBe(202);
                     const data = Encoder.stringToBytes('any data');
                     const credentialApplication = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -1991,8 +1989,8 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const reply = yield dwn.processMessage(alice.did, credentialApplication.message, { dataStream: credentialApplication.dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationInvalidType);
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationInvalidType);
                 }));
                 it('should fail authorization if given `protocolPath` is mismatching with actual path', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -2003,7 +2001,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition,
                     });
                     const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfig.message);
-                    expect(protocolConfigureReply.status.code).to.equal(202);
+                    expect(protocolConfigureReply.status.code).toBe(202);
                     const data = Encoder.stringToBytes('any data');
                     const credentialApplication = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2014,9 +2012,9 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const reply = yield dwn.processMessage(alice.did, credentialApplication.message, { dataStream: credentialApplication.dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationParentlessIncorrectProtocolPath);
-                    expect(reply.status.detail).to.contain('is not valid for records with no parent');
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationParentlessIncorrectProtocolPath);
+                    expect(reply.status.detail).toContain('is not valid for records with no parent');
                 }));
                 it('#690 - should only allow data format of a protocol-space record to be updated to any value allowed by the protocol configuration', () => __awaiter(this, void 0, void 0, function* () {
                     var _a;
@@ -2028,7 +2026,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition: protocolDefinition,
                     });
                     const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfig.message);
-                    expect(protocolConfigureReply.status.code).to.equal(202);
+                    expect(protocolConfigureReply.status.code).toBe(202);
                     // write image record
                     const data = TestDataGenerator.randomBytes(100);
                     const imageRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
@@ -2041,7 +2039,7 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const writeReply = yield dwn.processMessage(alice.did, imageRecordsWrite.message, { dataStream: imageRecordsWrite.dataStream });
-                    expect(writeReply.status.code).to.equal(202);
+                    expect(writeReply.status.code).toBe(202);
                     // update the image to a not-allowed data format
                     const newDataBytes = TestDataGenerator.randomBytes(100);
                     const notAllowedUpdateWrite = yield RecordsWrite.createFrom({
@@ -2052,8 +2050,8 @@ export function testRecordsWriteHandler() {
                     });
                     const newDataStream = DataStream.fromBytes(newDataBytes);
                     const notAllowedUpdateWriteReply = yield dwn.processMessage(alice.did, notAllowedUpdateWrite.message, { dataStream: newDataStream });
-                    expect(notAllowedUpdateWriteReply.status.code).to.equal(400);
-                    expect(notAllowedUpdateWriteReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationIncorrectDataFormat);
+                    expect(notAllowedUpdateWriteReply.status.code).toBe(400);
+                    expect(notAllowedUpdateWriteReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationIncorrectDataFormat);
                     // update the image to a different allowed dataFormat
                     const updateWrite = yield RecordsWrite.createFrom({
                         recordsWriteMessage: imageRecordsWrite.message,
@@ -2062,15 +2060,15 @@ export function testRecordsWriteHandler() {
                         data: newDataBytes
                     });
                     const updateReply = yield dwn.processMessage(alice.did, updateWrite.message, { dataStream: newDataStream });
-                    expect(updateReply.status.code).to.equal(202);
+                    expect(updateReply.status.code).toBe(202);
                     // verify the data format of the record is updated
                     const recordsRead = yield RecordsRead.create({
                         filter: { recordId: imageRecordsWrite.message.recordId },
                         signer: Jws.createSigner(alice),
                     });
                     const recordsReadReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                    expect(recordsReadReply.status.code).to.equal(200);
-                    expect((_a = recordsReadReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.descriptor.dataFormat).to.equal(protocolDefinition.types.image.dataFormats[1]);
+                    expect(recordsReadReply.status.code).toBe(200);
+                    expect((_a = recordsReadReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.descriptor.dataFormat).toBe(protocolDefinition.types.image.dataFormats[1]);
                 }));
                 it('#690 - should allow any data format for a record if protocol definition does not explicitly specify the list of allowed data formats', () => __awaiter(this, void 0, void 0, function* () {
                     var _a;
@@ -2082,7 +2080,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition: protocolDefinition,
                     });
                     const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfig.message);
-                    expect(protocolConfigureReply.status.code).to.equal(202);
+                    expect(protocolConfigureReply.status.code).toBe(202);
                     // write image record
                     const data = TestDataGenerator.randomBytes(100);
                     const imageRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
@@ -2095,7 +2093,7 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const writeReply = yield dwn.processMessage(alice.did, imageRecordsWrite.message, { dataStream: imageRecordsWrite.dataStream });
-                    expect(writeReply.status.code).to.equal(202);
+                    expect(writeReply.status.code).toBe(202);
                     // update the image to a different data format
                     const newDataFormat = 'any-new-data-format';
                     const newDataBytes = TestDataGenerator.randomBytes(100);
@@ -2107,15 +2105,15 @@ export function testRecordsWriteHandler() {
                     });
                     const newDataStream = DataStream.fromBytes(newDataBytes);
                     const updateReply = yield dwn.processMessage(alice.did, updateWrite.message, { dataStream: newDataStream });
-                    expect(updateReply.status.code).to.equal(202);
+                    expect(updateReply.status.code).toBe(202);
                     // verify the data format of the record is updated
                     const recordsRead = yield RecordsRead.create({
                         filter: { recordId: imageRecordsWrite.message.recordId },
                         signer: Jws.createSigner(alice),
                     });
                     const recordsReadReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                    expect(recordsReadReply.status.code).to.equal(200);
-                    expect((_a = recordsReadReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.descriptor.dataFormat).to.equal(newDataFormat);
+                    expect(recordsReadReply.status.code).toBe(200);
+                    expect((_a = recordsReadReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.descriptor.dataFormat).toBe(newDataFormat);
                 }));
                 it('should fail authorization if record schema is not allowed at the hierarchical level attempted for the RecordsWrite', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Attempt writing of records at 3 levels in the hierarchy to cover all possible cases of missing rule sets
@@ -2129,7 +2127,7 @@ export function testRecordsWriteHandler() {
                     const credentialApplicationSchema = protocolDefinition.types.credentialApplication.schema;
                     const credentialResponseSchema = protocolDefinition.types.credentialResponse.schema;
                     const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfig.message);
-                    expect(protocolConfigureReply.status.code).to.equal(202);
+                    expect(protocolConfigureReply.status.code).toBe(202);
                     // Try and fail to write a 'credentialResponse', which is not allowed at the top level of the record hierarchy
                     const data = Encoder.stringToBytes('any data');
                     const failedCredentialResponse = yield TestDataGenerator.generateRecordsWrite({
@@ -2141,8 +2139,8 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const failedCredentialResponseReply = yield dwn.processMessage(alice.did, failedCredentialResponse.message, { dataStream: failedCredentialResponse.dataStream });
-                    expect(failedCredentialResponseReply.status.code).to.equal(400);
-                    expect(failedCredentialResponseReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMissingRuleSet);
+                    expect(failedCredentialResponseReply.status.code).toBe(400);
+                    expect(failedCredentialResponseReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMissingRuleSet);
                     // Successfully write a 'credentialApplication' at the top level of the of the record hierarchy
                     const credentialApplication = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2153,7 +2151,7 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const credentialApplicationReply = yield dwn.processMessage(alice.did, credentialApplication.message, { dataStream: credentialApplication.dataStream });
-                    expect(credentialApplicationReply.status.code).to.equal(202);
+                    expect(credentialApplicationReply.status.code).toBe(202);
                     // Try and fail to write another 'credentialApplication' below the first 'credentialApplication'
                     const failedCredentialApplication = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2165,8 +2163,8 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const failedCredentialApplicationReply2 = yield dwn.processMessage(alice.did, failedCredentialApplication.message, { dataStream: failedCredentialApplication.dataStream });
-                    expect(failedCredentialApplicationReply2.status.code).to.equal(400);
-                    expect(failedCredentialApplicationReply2.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMissingRuleSet);
+                    expect(failedCredentialApplicationReply2.status.code).toBe(400);
+                    expect(failedCredentialApplicationReply2.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMissingRuleSet);
                     // Successfully write a 'credentialResponse' below the 'credentialApplication'
                     const credentialResponse = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2178,7 +2176,7 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const credentialResponseReply = yield dwn.processMessage(alice.did, credentialResponse.message, { dataStream: credentialResponse.dataStream });
-                    expect(credentialResponseReply.status.code).to.equal(202);
+                    expect(credentialResponseReply.status.code).toBe(202);
                     // Try and fail to write a 'credentialApplication' below 'credentialApplication/credentialResponse'
                     // Testing case where there is no rule set for any record type at the given level in the hierarchy
                     const nestedCredentialApplication = yield TestDataGenerator.generateRecordsWrite({
@@ -2191,8 +2189,8 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const nestedCredentialApplicationReply = yield dwn.processMessage(alice.did, nestedCredentialApplication.message, { dataStream: nestedCredentialApplication.dataStream });
-                    expect(nestedCredentialApplicationReply.status.code).to.equal(400);
-                    expect(nestedCredentialApplicationReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMissingRuleSet);
+                    expect(nestedCredentialApplicationReply.status.code).toBe(400);
+                    expect(nestedCredentialApplicationReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMissingRuleSet);
                 }));
                 it('should only allow DWN owner to write if record does not have an action rule defined', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -2204,7 +2202,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition
                     });
                     const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfig.message);
-                    expect(protocolConfigureReply.status.code).to.equal(202);
+                    expect(protocolConfigureReply.status.code).toBe(202);
                     // test that Alice is allowed to write to her own DWN
                     const data = Encoder.stringToBytes('any data');
                     const aliceWriteMessageData = yield TestDataGenerator.generateRecordsWrite({
@@ -2217,7 +2215,7 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     let reply = yield dwn.processMessage(alice.did, aliceWriteMessageData.message, { dataStream: aliceWriteMessageData.dataStream });
-                    expect(reply.status.code).to.equal(202);
+                    expect(reply.status.code).toBe(202);
                     // test that Bob is not allowed to write to Alice's DWN
                     const bob = yield TestDataGenerator.generateDidKeyPersona();
                     const bobWriteMessageData = yield TestDataGenerator.generateRecordsWrite({
@@ -2230,8 +2228,8 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     reply = yield dwn.processMessage(alice.did, bobWriteMessageData.message, { dataStream: bobWriteMessageData.dataStream });
-                    expect(reply.status.code).to.equal(401);
-                    expect(reply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionRulesNotFound);
+                    expect(reply.status.code).toBe(401);
+                    expect(reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionRulesNotFound);
                 }));
                 it('should look up recipient path with ancestor depth of 2+ (excluding self) in action rule correctly', () => __awaiter(this, void 0, void 0, function* () {
                     // simulate a DEX protocol with at least 3 layers of message exchange: ask -> offer -> fulfillment
@@ -2248,7 +2246,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition: protocolDefinition
                     });
                     const protocolConfigureReply = yield dwn.processMessage(pfi.did, protocolConfig.message);
-                    expect(protocolConfigureReply.status.code).to.equal(202);
+                    expect(protocolConfigureReply.status.code).toBe(202);
                     // simulate Alice's ask and PFI's offer already occurred
                     const data = Encoder.stringToBytes('irrelevant');
                     const askMessageData = yield TestDataGenerator.generateRecordsWrite({
@@ -2260,7 +2258,7 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     let reply = yield dwn.processMessage(pfi.did, askMessageData.message, { dataStream: askMessageData.dataStream });
-                    expect(reply.status.code).to.equal(202);
+                    expect(reply.status.code).toBe(202);
                     const offerMessageData = yield TestDataGenerator.generateRecordsWrite({
                         author: pfi,
                         recipient: alice.did,
@@ -2271,7 +2269,7 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     reply = yield dwn.processMessage(pfi.did, offerMessageData.message, { dataStream: offerMessageData.dataStream });
-                    expect(reply.status.code).to.equal(202);
+                    expect(reply.status.code).toBe(202);
                     // the actual test: making sure fulfillment message is accepted
                     const fulfillmentMessageData = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2283,7 +2281,7 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     reply = yield dwn.processMessage(pfi.did, fulfillmentMessageData.message, { dataStream: fulfillmentMessageData.dataStream });
-                    expect(reply.status.code).to.equal(202);
+                    expect(reply.status.code).toBe(202);
                     // verify the fulfillment message is stored
                     const recordsQueryMessageData = yield TestDataGenerator.generateRecordsQuery({
                         author: pfi,
@@ -2291,9 +2289,9 @@ export function testRecordsWriteHandler() {
                     });
                     // verify the data is written
                     const recordsQueryReply = yield dwn.processMessage(pfi.did, recordsQueryMessageData.message);
-                    expect(recordsQueryReply.status.code).to.equal(200);
-                    expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                    expect(recordsQueryReply.entries[0].descriptor.dataCid).to.equal(fulfillmentMessageData.message.descriptor.dataCid);
+                    expect(recordsQueryReply.status.code).toBe(200);
+                    expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                    expect(recordsQueryReply.entries[0].descriptor.dataCid).toBe(fulfillmentMessageData.message.descriptor.dataCid);
                 }));
                 it('should fail authorization if incoming message contains `parentId` that leads to no record', () => __awaiter(this, void 0, void 0, function* () {
                     // 1. DEX protocol with at least 3 layers of message exchange: ask -> offer -> fulfillment
@@ -2310,7 +2308,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition: protocolDefinition
                     });
                     const protocolConfigureReply = yield dwn.processMessage(pfi.did, protocolConfig.message);
-                    expect(protocolConfigureReply.status.code).to.equal(202);
+                    expect(protocolConfigureReply.status.code).toBe(202);
                     // simulate Alice's ask
                     const data = Encoder.stringToBytes('irrelevant');
                     const askMessageData = yield TestDataGenerator.generateRecordsWrite({
@@ -2322,7 +2320,7 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     let reply = yield dwn.processMessage(pfi.did, askMessageData.message, { dataStream: askMessageData.dataStream });
-                    expect(reply.status.code).to.equal(202);
+                    expect(reply.status.code).toBe(202);
                     // the actual test: making sure fulfillment message fails
                     const fulfillmentMessageData = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2334,8 +2332,8 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     reply = yield dwn.processMessage(pfi.did, fulfillmentMessageData.message, { dataStream: fulfillmentMessageData.dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationIncorrectProtocolPath);
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationIncorrectProtocolPath);
                 }));
                 it('should 400 if expected CID of `encryption` mismatches the `encryptionCid` in `authorization`', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generatePersona();
@@ -2348,7 +2346,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     const bobMessageBytes = Encoder.stringToBytes('message from bob');
                     const bobMessageStream = DataStream.fromBytes(bobMessageBytes);
                     const dataEncryptionInitializationVector = TestDataGenerator.randomBytes(16);
@@ -2376,10 +2374,10 @@ export function testRecordsWriteHandler() {
                     });
                     // replace valid `encryption` property with a mismatching one
                     message.encryption.initializationVector = Encoder.stringToBase64Url('any value which will result in a different CID');
-                    const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, eventLog, eventStream);
+                    const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, stateIndex, eventStream);
                     const writeReply = yield recordsWriteHandler.handle({ tenant: alice.did, message, dataStream: dataStream });
-                    expect(writeReply.status.code).to.equal(400);
-                    expect(writeReply.status.detail).to.contain(DwnErrorCode.RecordsWriteValidateIntegrityEncryptionCidMismatch);
+                    expect(writeReply.status.code).toBe(400);
+                    expect(writeReply.status.detail).toContain(DwnErrorCode.RecordsWriteValidateIntegrityEncryptionCidMismatch);
                 }));
                 it('should return 400 if protocol is not normalized', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -2408,8 +2406,8 @@ export function testRecordsWriteHandler() {
                     recordsWrite.message = Object.assign(Object.assign({}, recordsWrite.message), { attestation, authorization: { signature } });
                     // Send records write message
                     const reply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain(DwnErrorCode.UrlProtocolNotNormalized);
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain(DwnErrorCode.UrlProtocolNotNormalized);
                 }));
                 it('#359 - should not allow access of data by referencing `dataCid` in protocol authorized `RecordsWrite`', () => __awaiter(this, void 0, void 0, function* () {
                     var _a, _b, _c;
@@ -2425,7 +2423,7 @@ export function testRecordsWriteHandler() {
                         data,
                     });
                     const reply = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(reply.status.code).to.equal(202);
+                    expect(reply.status.code).toBe(202);
                     const protocolDefinition = socialMediaProtocolDefinition;
                     const protocol = protocolDefinition.protocol;
                     // alice has a social media protocol that allows anyone to write and read images
@@ -2434,7 +2432,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // bob learns of metadata (ie. dataCid) of alice's secret data,
                     // attempts to gain unauthorized access by writing to alice's DWN through open protocol referencing the dataCid without supplying the data
                     // which he is allowed to do, the DWN will treat the operation as an initial-write or a record that has a later and different state.
@@ -2449,7 +2447,7 @@ export function testRecordsWriteHandler() {
                         recipient: alice.did
                     });
                     const imageReply = yield dwn.processMessage(alice.did, imageRecordsWrite.message);
-                    expect(imageReply.status.code).to.equal(204); // allows write but is not readable or queryable
+                    expect(imageReply.status.code).toBe(204); // allows write but is not readable or queryable
                     // verify the record is not able to be read
                     const bobRecordsReadData = yield RecordsRead.create({
                         filter: {
@@ -2458,7 +2456,7 @@ export function testRecordsWriteHandler() {
                         signer: Jws.createSigner(bob)
                     });
                     const bobRecordsReadReply = yield dwn.processMessage(alice.did, bobRecordsReadData.message);
-                    expect(bobRecordsReadReply.status.code).to.equal(404);
+                    expect(bobRecordsReadReply.status.code).toBe(404);
                     // verify the record is not part of a query
                     const bobRecordsQuery = yield RecordsQuery.create({
                         filter: {
@@ -2467,8 +2465,8 @@ export function testRecordsWriteHandler() {
                         signer: Jws.createSigner(bob)
                     });
                     const bobRecordsQueryReply = yield dwn.processMessage(alice.did, bobRecordsQuery.message);
-                    expect(bobRecordsQueryReply.status.code).to.equal(200);
-                    expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(0);
+                    expect(bobRecordsQueryReply.status.code).toBe(200);
+                    expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
                     //further sanity query for specific recordId
                     const bobRecordsQueryRecordId = yield RecordsQuery.create({
                         filter: {
@@ -2477,8 +2475,8 @@ export function testRecordsWriteHandler() {
                         signer: Jws.createSigner(bob)
                     });
                     const bobRecordsQueryRecordIdReply = yield dwn.processMessage(alice.did, bobRecordsQueryRecordId.message);
-                    expect(bobRecordsQueryRecordIdReply.status.code).to.equal(200);
-                    expect((_b = bobRecordsQueryRecordIdReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(0);
+                    expect(bobRecordsQueryRecordIdReply.status.code).toBe(200);
+                    expect((_b = bobRecordsQueryRecordIdReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
                     // attempt update recordsWrite without data, this will reject
                     const updateRecord = yield RecordsWrite.createFrom({
                         recordsWriteMessage: imageRecordsWrite.message,
@@ -2486,12 +2484,12 @@ export function testRecordsWriteHandler() {
                         published: true,
                     });
                     const updateRecordReply = yield dwn.processMessage(alice.did, updateRecord.message);
-                    expect(updateRecordReply.status.code).to.equal(400);
-                    expect(updateRecordReply.status.detail).to.include(DwnErrorCode.RecordsWriteMissingEncodedDataInPrevious);
+                    expect(updateRecordReply.status.code).toBe(400);
+                    expect(updateRecordReply.status.detail).toContain(DwnErrorCode.RecordsWriteMissingEncodedDataInPrevious);
                     // sanity still can't query
                     const bobRecordsQueryReply2 = yield dwn.processMessage(alice.did, bobRecordsQuery.message);
-                    expect(bobRecordsQueryReply2.status.code).to.equal(200);
-                    expect((_c = bobRecordsQueryReply2.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(0);
+                    expect(bobRecordsQueryReply2.status.code).toBe(200);
+                    expect((_c = bobRecordsQueryReply2.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(0);
                 }));
                 it('#359 - should not allow access of data by referencing `dataCid` in protocol authorized `RecordsWrite` with large data', () => __awaiter(this, void 0, void 0, function* () {
                     var _a, _b, _c;
@@ -2507,7 +2505,7 @@ export function testRecordsWriteHandler() {
                         data,
                     });
                     const reply = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(reply.status.code).to.equal(202);
+                    expect(reply.status.code).toBe(202);
                     const protocolDefinition = socialMediaProtocolDefinition;
                     const protocol = protocolDefinition.protocol;
                     // alice has a social media protocol that allows anyone to write and read images
@@ -2516,7 +2514,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // bob learns of metadata (ie. dataCid) of alice's secret data,
                     // attempts to gain unauthorized access by writing to alice's DWN through open protocol referencing the dataCid without supplying the data
                     // which he is allowed to do, the DWN will treat the operation as an initial-write or a record that has a later and different state.
@@ -2531,7 +2529,7 @@ export function testRecordsWriteHandler() {
                         recipient: alice.did
                     });
                     const imageReply = yield dwn.processMessage(alice.did, imageRecordsWrite.message);
-                    expect(imageReply.status.code).to.equal(204); // allows write but is not readable or queryable
+                    expect(imageReply.status.code).toBe(204); // allows write but is not readable or queryable
                     // verify the record is not able to be read
                     const bobRecordsReadData = yield RecordsRead.create({
                         filter: {
@@ -2540,7 +2538,7 @@ export function testRecordsWriteHandler() {
                         signer: Jws.createSigner(bob)
                     });
                     const bobRecordsReadReply = yield dwn.processMessage(alice.did, bobRecordsReadData.message);
-                    expect(bobRecordsReadReply.status.code).to.equal(404);
+                    expect(bobRecordsReadReply.status.code).toBe(404);
                     // verify the record is not part of a query
                     const bobRecordsQuery = yield RecordsQuery.create({
                         filter: {
@@ -2549,8 +2547,8 @@ export function testRecordsWriteHandler() {
                         signer: Jws.createSigner(bob)
                     });
                     const bobRecordsQueryReply = yield dwn.processMessage(alice.did, bobRecordsQuery.message);
-                    expect(bobRecordsQueryReply.status.code).to.equal(200);
-                    expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(0);
+                    expect(bobRecordsQueryReply.status.code).toBe(200);
+                    expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
                     //further sanity query for specific recordId
                     const bobRecordsQueryRecordId = yield RecordsQuery.create({
                         filter: {
@@ -2559,8 +2557,8 @@ export function testRecordsWriteHandler() {
                         signer: Jws.createSigner(bob)
                     });
                     const bobRecordsQueryRecordIdReply = yield dwn.processMessage(alice.did, bobRecordsQueryRecordId.message);
-                    expect(bobRecordsQueryRecordIdReply.status.code).to.equal(200);
-                    expect((_b = bobRecordsQueryRecordIdReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(0);
+                    expect(bobRecordsQueryRecordIdReply.status.code).toBe(200);
+                    expect((_b = bobRecordsQueryRecordIdReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
                     // attempt update recordsWrite without data, this will reject
                     const updateRecord = yield RecordsWrite.createFrom({
                         recordsWriteMessage: imageRecordsWrite.message,
@@ -2568,12 +2566,12 @@ export function testRecordsWriteHandler() {
                         published: true,
                     });
                     const updateRecordReply = yield dwn.processMessage(alice.did, updateRecord.message);
-                    expect(updateRecordReply.status.code).to.equal(400);
-                    expect(updateRecordReply.status.detail).to.include(DwnErrorCode.RecordsWriteMissingDataInPrevious);
+                    expect(updateRecordReply.status.code).toBe(400);
+                    expect(updateRecordReply.status.detail).toContain(DwnErrorCode.RecordsWriteMissingDataInPrevious);
                     // sanity still can't query
                     const bobRecordsQueryReply2 = yield dwn.processMessage(alice.did, bobRecordsQuery.message);
-                    expect(bobRecordsQueryReply2.status.code).to.equal(200);
-                    expect((_c = bobRecordsQueryReply2.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(0);
+                    expect(bobRecordsQueryReply2.status.code).toBe(200);
+                    expect((_c = bobRecordsQueryReply2.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(0);
                 }));
                 it('should allow record with or without schema if protocol does not require schema for a record type', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Alice's DWN has a protocol that allows anyone to write a record without schema
@@ -2586,7 +2584,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // write a `RecordsWrite` message without schema
                     const data = TestDataGenerator.randomBytes(100);
                     const dataStream = DataStream.fromBytes(data);
@@ -2598,7 +2596,7 @@ export function testRecordsWriteHandler() {
                         signer: Jws.createSigner(alice)
                     });
                     const writeReply = yield dwn.processMessage(alice.did, docWrite.message, { dataStream });
-                    expect(writeReply.status.code).to.equal(202);
+                    expect(writeReply.status.code).toBe(202);
                     // write a `RecordsWrite` message with schema
                     const data2 = TestDataGenerator.randomBytes(100);
                     const data2Stream = DataStream.fromBytes(data2);
@@ -2611,15 +2609,15 @@ export function testRecordsWriteHandler() {
                         signer: Jws.createSigner(alice)
                     });
                     const write2Reply = yield dwn.processMessage(alice.did, doc2Write.message, { dataStream: data2Stream });
-                    expect(write2Reply.status.code).to.equal(202);
+                    expect(write2Reply.status.code).toBe(202);
                     // verify messages got written to the DB
                     const recordsQuery = yield RecordsQuery.create({
                         filter: { protocolPath: 'doc' },
                         signer: Jws.createSigner(alice)
                     });
                     const recordsReadReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                    expect(recordsReadReply.status.code).to.equal(200);
-                    expect((_a = recordsReadReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(2);
+                    expect(recordsReadReply.status.code).toBe(200);
+                    expect((_a = recordsReadReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
                 }));
                 it('should allow authorization if protocol message size is within min and max size', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generatePersona();
@@ -2645,7 +2643,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition,
                     });
                     const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfig.message);
-                    expect(protocolConfigureReply.status.code).to.equal(202);
+                    expect(protocolConfigureReply.status.code).toBe(202);
                     // test min record size
                     const data = TestDataGenerator.randomBytes(1);
                     const testRecord = yield TestDataGenerator.generateRecordsWrite({
@@ -2656,7 +2654,7 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const reply = yield dwn.processMessage(alice.did, testRecord.message, { dataStream: testRecord.dataStream });
-                    expect(reply.status.code).to.equal(202);
+                    expect(reply.status.code).toBe(202);
                     // test max record size
                     const data2 = TestDataGenerator.randomBytes(1000);
                     const testRecord2 = yield TestDataGenerator.generateRecordsWrite({
@@ -2667,7 +2665,7 @@ export function testRecordsWriteHandler() {
                         data: data2
                     });
                     const reply2 = yield dwn.processMessage(alice.did, testRecord2.message, { dataStream: testRecord2.dataStream });
-                    expect(reply2.status.code).to.equal(202);
+                    expect(reply2.status.code).toBe(202);
                     // test beyond max size
                     const data3 = TestDataGenerator.randomBytes(1001);
                     const testRecord3 = yield TestDataGenerator.generateRecordsWrite({
@@ -2678,8 +2676,8 @@ export function testRecordsWriteHandler() {
                         data: data3
                     });
                     const reply3 = yield dwn.processMessage(alice.did, testRecord3.message, { dataStream: testRecord3.dataStream });
-                    expect(reply3.status.code).to.equal(400);
-                    expect(reply3.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMaxSizeInvalid);
+                    expect(reply3.status.code).toBe(400);
+                    expect(reply3.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMaxSizeInvalid);
                 }));
                 it('should fail authorization if protocol message size is less than specified minimum size', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generatePersona();
@@ -2704,7 +2702,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition,
                     });
                     const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfig.message);
-                    expect(protocolConfigureReply.status.code).to.equal(202);
+                    expect(protocolConfigureReply.status.code).toBe(202);
                     const data = TestDataGenerator.randomBytes(999);
                     const testRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2714,8 +2712,8 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const reply = yield dwn.processMessage(alice.did, testRecord.message, { dataStream: testRecord.dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMinSizeInvalid);
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMinSizeInvalid);
                     // test valid min record size
                     const data2 = TestDataGenerator.randomBytes(1000);
                     const testRecord2 = yield TestDataGenerator.generateRecordsWrite({
@@ -2726,7 +2724,7 @@ export function testRecordsWriteHandler() {
                         data: data2
                     });
                     const reply2 = yield dwn.processMessage(alice.did, testRecord2.message, { dataStream: testRecord2.dataStream });
-                    expect(reply2.status.code).to.equal(202);
+                    expect(reply2.status.code).toBe(202);
                 }));
                 it('should fail authorization if protocol message size is more than specified maximum size', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generatePersona();
@@ -2751,7 +2749,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition,
                     });
                     const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfig.message);
-                    expect(protocolConfigureReply.status.code).to.equal(202);
+                    expect(protocolConfigureReply.status.code).toBe(202);
                     const data = TestDataGenerator.randomBytes(1001);
                     const testRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2761,8 +2759,8 @@ export function testRecordsWriteHandler() {
                         data
                     });
                     const reply = yield dwn.processMessage(alice.did, testRecord.message, { dataStream: testRecord.dataStream });
-                    expect(reply.status.code).to.equal(400);
-                    expect(reply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMaxSizeInvalid);
+                    expect(reply.status.code).toBe(400);
+                    expect(reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMaxSizeInvalid);
                     // test valid max record size
                     const data2 = TestDataGenerator.randomBytes(1000);
                     const testRecord2 = yield TestDataGenerator.generateRecordsWrite({
@@ -2773,7 +2771,7 @@ export function testRecordsWriteHandler() {
                         data: data2
                     });
                     const reply2 = yield dwn.processMessage(alice.did, testRecord2.message, { dataStream: testRecord2.dataStream });
-                    expect(reply2.status.code).to.equal(202);
+                    expect(reply2.status.code).toBe(202);
                 }));
                 it('should fail if a write references a parent that has been deleted', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario:
@@ -2789,7 +2787,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // 1. Alice writes foo1
                     const fooOptions = {
                         author: alice,
@@ -2800,14 +2798,14 @@ export function testRecordsWriteHandler() {
                     };
                     const foo1 = yield TestDataGenerator.generateRecordsWrite(fooOptions);
                     const foo1WriteResponse = yield dwn.processMessage(alice.did, foo1.message, { dataStream: foo1.dataStream });
-                    expect(foo1WriteResponse.status.code).equals(202);
+                    expect(foo1WriteResponse.status.code).toBe(202);
                     // 2. Alice deletes foo1
                     const deleteFoo = yield TestDataGenerator.generateRecordsDelete({
                         author: alice,
                         recordId: foo1.message.recordId
                     });
                     const deleteFooReply = yield dwn.processMessage(alice.did, deleteFoo.message);
-                    expect(deleteFooReply.status.code).equals(202);
+                    expect(deleteFooReply.status.code).toBe(202);
                     // 3. Alice tries to write a bar1 referencing the deleted foo and should fail
                     const barOptions = {
                         author: alice,
@@ -2819,8 +2817,8 @@ export function testRecordsWriteHandler() {
                     };
                     const bar1 = yield TestDataGenerator.generateRecordsWrite(barOptions);
                     const bar1WriteResponse = yield dwn.processMessage(alice.did, bar1.message, { dataStream: bar1.dataStream });
-                    expect(bar1WriteResponse.status.code).equals(400);
-                    expect(bar1WriteResponse.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationIncorrectProtocolPath);
+                    expect(bar1WriteResponse.status.code).toBe(400);
+                    expect(bar1WriteResponse.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationIncorrectProtocolPath);
                 }));
                 it('should fail if a write references a mismatching parent that compared to the parent in the `contextId` ', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario:
@@ -2835,7 +2833,7 @@ export function testRecordsWriteHandler() {
                         protocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // 1. Alice writes foo1
                     const fooOptions = {
                         author: alice,
@@ -2846,7 +2844,7 @@ export function testRecordsWriteHandler() {
                     };
                     const foo1 = yield TestDataGenerator.generateRecordsWrite(fooOptions);
                     const foo1WriteResponse = yield dwn.processMessage(alice.did, foo1.message, { dataStream: foo1.dataStream });
-                    expect(foo1WriteResponse.status.code).equals(202);
+                    expect(foo1WriteResponse.status.code).toBe(202);
                     // 2. Alice tries to write a bar1 referencing the foo1 in parentId, but contextId does not reference the same parent
                     const barOptions = {
                         author: alice,
@@ -2875,8 +2873,8 @@ export function testRecordsWriteHandler() {
                     bar1.message.recordId = recordId;
                     bar1.message.authorization = { signature };
                     const bar1WriteResponse = yield dwn.processMessage(alice.did, bar1.message);
-                    expect(bar1WriteResponse.status.code).equals(400);
-                    expect(bar1WriteResponse.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationIncorrectContextId);
+                    expect(bar1WriteResponse.status.code).toBe(400);
+                    expect(bar1WriteResponse.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationIncorrectContextId);
                 }));
             });
             describe('grant based writes', () => {
@@ -2893,7 +2891,7 @@ export function testRecordsWriteHandler() {
                             protocolDefinition
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice gives Bob a permission grant
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -2907,7 +2905,7 @@ export function testRecordsWriteHandler() {
                         });
                         const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                         const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                        expect(permissionGrantWriteReply.status.code).to.equal(202);
+                        expect(permissionGrantWriteReply.status.code).toBe(202);
                         // Bob invokes the grant in order to write a record to the protocol
                         const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
                             author: bob,
@@ -2916,7 +2914,7 @@ export function testRecordsWriteHandler() {
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
                         const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                        expect(recordsWriteReply.status.code).to.equal(202);
+                        expect(recordsWriteReply.status.code).toBe(202);
                     }));
                     it('rejects writes of protocol records with mismatching protocol grant scopes', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice gives Bob a grant to write to a protocol. Bob tries and fails to
@@ -2930,7 +2928,7 @@ export function testRecordsWriteHandler() {
                             protocolDefinition
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice gives Bob a permission grant with a different protocol than what Bob will try to write to
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -2944,7 +2942,7 @@ export function testRecordsWriteHandler() {
                         });
                         const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                         const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                        expect(permissionGrantWriteReply.status.code).to.equal(202);
+                        expect(permissionGrantWriteReply.status.code).toBe(202);
                         // Bob invokes the grant, failing to write to a different protocol than the grant allows
                         const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
                             author: bob,
@@ -2953,8 +2951,8 @@ export function testRecordsWriteHandler() {
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
                         const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                        expect(recordsWriteReply.status.code).to.equal(401);
-                        expect(recordsWriteReply.status.detail).to.contain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolMismatch);
+                        expect(recordsWriteReply.status.code).toBe(401);
+                        expect(recordsWriteReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolMismatch);
                     }));
                     it('allows writes of protocol records with matching contextId grant scopes', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice gives Bob a grant to write to a specific contextId.
@@ -2968,7 +2966,7 @@ export function testRecordsWriteHandler() {
                             protocolDefinition
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates the context that she will give Bob access to
                         const alicesRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -2979,7 +2977,7 @@ export function testRecordsWriteHandler() {
                             dataFormat: protocolDefinition.types.email.dataFormats[0],
                         });
                         const alicesRecordsWriteReply = yield dwn.processMessage(alice.did, alicesRecordsWrite.message, { dataStream: alicesRecordsWrite.dataStream });
-                        expect(alicesRecordsWriteReply.status.code).to.equal(202);
+                        expect(alicesRecordsWriteReply.status.code).toBe(202);
                         // Alice gives Bob a permission grant
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -2994,7 +2992,7 @@ export function testRecordsWriteHandler() {
                         });
                         const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                         const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                        expect(permissionGrantWriteReply.status.code).to.equal(202);
+                        expect(permissionGrantWriteReply.status.code).toBe(202);
                         // Bob invokes the grant in order to write a record to the protocol
                         const bobsRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: bob,
@@ -3006,7 +3004,7 @@ export function testRecordsWriteHandler() {
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
                         const bobsRecordsWriteReply = yield dwn.processMessage(alice.did, bobsRecordsWrite.message, { dataStream: bobsRecordsWrite.dataStream });
-                        expect(bobsRecordsWriteReply.status.code).to.equal(202);
+                        expect(bobsRecordsWriteReply.status.code).toBe(202);
                     }));
                     it('rejects writes of protocol records with mismatching contextId grant scopes', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice gives Bob a grant to write to a specific contextId. Bob tries and fails to
@@ -3020,7 +3018,7 @@ export function testRecordsWriteHandler() {
                             protocolDefinition
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates the context that she will give Bob access to
                         const alicesRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -3031,7 +3029,7 @@ export function testRecordsWriteHandler() {
                             dataFormat: protocolDefinition.types.email.dataFormats[0],
                         });
                         const alicesRecordsWriteReply = yield dwn.processMessage(alice.did, alicesRecordsWrite.message, { dataStream: alicesRecordsWrite.dataStream });
-                        expect(alicesRecordsWriteReply.status.code).to.equal(202);
+                        expect(alicesRecordsWriteReply.status.code).toBe(202);
                         // Alice gives Bob a permission grant
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -3046,7 +3044,7 @@ export function testRecordsWriteHandler() {
                         });
                         const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                         const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                        expect(permissionGrantWriteReply.status.code).to.equal(202);
+                        expect(permissionGrantWriteReply.status.code).toBe(202);
                         // Bob invokes the grant in order to write a record to the protocol
                         const bobsRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: bob,
@@ -3058,8 +3056,8 @@ export function testRecordsWriteHandler() {
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
                         const bobsRecordsWriteReply = yield dwn.processMessage(alice.did, bobsRecordsWrite.message, { dataStream: bobsRecordsWrite.dataStream });
-                        expect(bobsRecordsWriteReply.status.code).to.equal(401);
-                        expect(bobsRecordsWriteReply.status.detail).to.contain(DwnErrorCode.RecordsGrantAuthorizationScopeContextIdMismatch);
+                        expect(bobsRecordsWriteReply.status.code).toBe(401);
+                        expect(bobsRecordsWriteReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeContextIdMismatch);
                     }));
                     it('allows writes of protocol records with matching protocolPath grant scopes', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice gives Bob a grant to write to a specific protocolPath.
@@ -3073,7 +3071,7 @@ export function testRecordsWriteHandler() {
                             protocolDefinition
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice gives Bob a permission grant
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -3088,7 +3086,7 @@ export function testRecordsWriteHandler() {
                         });
                         const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                         const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                        expect(permissionGrantWriteReply.status.code).to.equal(202);
+                        expect(permissionGrantWriteReply.status.code).toBe(202);
                         // Bob invokes the grant in order to write a record to the protocol
                         const bobsRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: bob,
@@ -3097,7 +3095,7 @@ export function testRecordsWriteHandler() {
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
                         const bobsRecordsWriteReply = yield dwn.processMessage(alice.did, bobsRecordsWrite.message, { dataStream: bobsRecordsWrite.dataStream });
-                        expect(bobsRecordsWriteReply.status.code).to.equal(202);
+                        expect(bobsRecordsWriteReply.status.code).toBe(202);
                     }));
                     it('rejects writes of protocol records with mismatching protocolPath grant scopes', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice gives Bob a grant to write to a specific protocolPath. Bob tries and fails to
@@ -3111,7 +3109,7 @@ export function testRecordsWriteHandler() {
                             protocolDefinition
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice gives Bob a permission grant
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -3126,7 +3124,7 @@ export function testRecordsWriteHandler() {
                         });
                         const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                         const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                        expect(permissionGrantWriteReply.status.code).to.equal(202);
+                        expect(permissionGrantWriteReply.status.code).toBe(202);
                         // Bob invokes the grant in order to write a record to the protocol
                         const bobsRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: bob,
@@ -3135,8 +3133,8 @@ export function testRecordsWriteHandler() {
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
                         const bobsRecordsWriteReply = yield dwn.processMessage(alice.did, bobsRecordsWrite.message, { dataStream: bobsRecordsWrite.dataStream });
-                        expect(bobsRecordsWriteReply.status.code).to.equal(401);
-                        expect(bobsRecordsWriteReply.status.detail).to.contain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolPathMismatch);
+                        expect(bobsRecordsWriteReply.status.code).toBe(401);
+                        expect(bobsRecordsWriteReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolPathMismatch);
                     }));
                 });
                 describe('grant condition published', () => {
@@ -3152,7 +3150,7 @@ export function testRecordsWriteHandler() {
                             protocolDefinition,
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates a grant for Bob with `published` === required
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -3169,7 +3167,7 @@ export function testRecordsWriteHandler() {
                         });
                         const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                         const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                        expect(permissionGrantWriteReply.status.code).to.equal(202);
+                        expect(permissionGrantWriteReply.status.code).toBe(202);
                         const permissionGrantId = permissionGrant.recordsWrite.message.recordId;
                         // Bob is able to write a published record
                         const publishedRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
@@ -3180,7 +3178,7 @@ export function testRecordsWriteHandler() {
                             permissionGrantId
                         });
                         const publishedRecordsWriteReply = yield dwn.processMessage(alice.did, publishedRecordsWrite.message, { dataStream: publishedRecordsWrite.dataStream });
-                        expect(publishedRecordsWriteReply.status.code).to.equal(202);
+                        expect(publishedRecordsWriteReply.status.code).toBe(202);
                         // Bob is not able to write an unpublished record
                         const unpublishedRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: bob,
@@ -3190,8 +3188,8 @@ export function testRecordsWriteHandler() {
                             permissionGrantId
                         });
                         const unpublishedRecordsWriteReply = yield dwn.processMessage(alice.did, unpublishedRecordsWrite.message, { dataStream: unpublishedRecordsWrite.dataStream });
-                        expect(unpublishedRecordsWriteReply.status.code).to.equal(401);
-                        expect(unpublishedRecordsWriteReply.status.detail).to.contain(DwnErrorCode.RecordsGrantAuthorizationConditionPublicationRequired);
+                        expect(unpublishedRecordsWriteReply.status.code).toBe(401);
+                        expect(unpublishedRecordsWriteReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationConditionPublicationRequired);
                     }));
                     it('Rejects published records if grant condition `published` === prohibited', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice gives Bob a grant with condition `published` === prohibited.
@@ -3205,7 +3203,7 @@ export function testRecordsWriteHandler() {
                             protocolDefinition,
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates a grant for Bob with `published` === prohibited
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -3222,7 +3220,7 @@ export function testRecordsWriteHandler() {
                         });
                         const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                         const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                        expect(permissionGrantWriteReply.status.code).to.equal(202);
+                        expect(permissionGrantWriteReply.status.code).toBe(202);
                         const permissionGrantId = permissionGrant.recordsWrite.message.recordId;
                         // Bob not is able to write a published record
                         const publishedRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
@@ -3233,8 +3231,8 @@ export function testRecordsWriteHandler() {
                             permissionGrantId
                         });
                         const publishedRecordsWriteReply = yield dwn.processMessage(alice.did, publishedRecordsWrite.message, { dataStream: publishedRecordsWrite.dataStream });
-                        expect(publishedRecordsWriteReply.status.code).to.equal(401);
-                        expect(publishedRecordsWriteReply.status.detail).to.contain(DwnErrorCode.RecordsGrantAuthorizationConditionPublicationProhibited);
+                        expect(publishedRecordsWriteReply.status.code).toBe(401);
+                        expect(publishedRecordsWriteReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationConditionPublicationProhibited);
                         // Bob is able to write an unpublished record
                         const unpublishedRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: bob,
@@ -3244,7 +3242,7 @@ export function testRecordsWriteHandler() {
                             permissionGrantId
                         });
                         const unpublishedRecordsWriteReply = yield dwn.processMessage(alice.did, unpublishedRecordsWrite.message, { dataStream: unpublishedRecordsWrite.dataStream });
-                        expect(unpublishedRecordsWriteReply.status.code).to.equal(202);
+                        expect(unpublishedRecordsWriteReply.status.code).toBe(202);
                     }));
                     it('Allows both published and unpublished records if grant condition `published` is undefined', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice gives Bob a grant without condition `published`.
@@ -3258,7 +3256,7 @@ export function testRecordsWriteHandler() {
                             protocolDefinition,
                         });
                         const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolsConfigureReply.status.code).to.equal(202);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates a grant for Bob with `published` === prohibited
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -3275,7 +3273,7 @@ export function testRecordsWriteHandler() {
                         });
                         const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                         const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
-                        expect(permissionGrantWriteReply.status.code).to.equal(202);
+                        expect(permissionGrantWriteReply.status.code).toBe(202);
                         const permissionGrantId = permissionGrant.recordsWrite.message.recordId;
                         // Bob is able to write a published record
                         const publishedRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
@@ -3286,7 +3284,7 @@ export function testRecordsWriteHandler() {
                             permissionGrantId
                         });
                         const publishedRecordsWriteReply = yield dwn.processMessage(alice.did, publishedRecordsWrite.message, { dataStream: publishedRecordsWrite.dataStream });
-                        expect(publishedRecordsWriteReply.status.code).to.equal(202);
+                        expect(publishedRecordsWriteReply.status.code).toBe(202);
                         // Bob is able to write an unpublished record
                         const unpublishedRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
                             author: bob,
@@ -3296,7 +3294,7 @@ export function testRecordsWriteHandler() {
                             permissionGrantId
                         });
                         const unpublishedRecordsWriteReply = yield dwn.processMessage(alice.did, unpublishedRecordsWrite.message, { dataStream: unpublishedRecordsWrite.dataStream });
-                        expect(unpublishedRecordsWriteReply.status.code).to.equal(202);
+                        expect(unpublishedRecordsWriteReply.status.code).toBe(202);
                     }));
                 });
             });
@@ -3313,7 +3311,7 @@ export function testRecordsWriteHandler() {
                     data,
                 });
                 const prunedRecordsWriteReply = yield dwn.processMessage(alice.did, prunedRecordsWrite.message);
-                expect(prunedRecordsWriteReply.status.code).to.equal(204);
+                expect(prunedRecordsWriteReply.status.code).toBe(204);
                 // Update record to published, omitting dataStream
                 const recordsWrite = yield TestDataGenerator.generateFromRecordsWrite({
                     author: alice,
@@ -3322,8 +3320,8 @@ export function testRecordsWriteHandler() {
                     data,
                 });
                 const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message);
-                expect(recordsWriteReply.status.code).to.equal(400);
-                expect(recordsWriteReply.status.detail).to.contain(DwnErrorCode.RecordsWriteMissingDataInPrevious);
+                expect(recordsWriteReply.status.code).toBe(400);
+                expect(recordsWriteReply.status.detail).toContain(DwnErrorCode.RecordsWriteMissingDataInPrevious);
             }));
             it('should return 400 if dataStream is not provided and previous message does not contain encodedData', () => __awaiter(this, void 0, void 0, function* () {
                 // scenario: A sync writes a pruned initial RecordsWrite, without a `dataStream`. Alice does another regular
@@ -3338,7 +3336,7 @@ export function testRecordsWriteHandler() {
                     data,
                 });
                 const prunedRecordsWriteReply = yield dwn.processMessage(alice.did, prunedRecordsWrite.message);
-                expect(prunedRecordsWriteReply.status.code).to.equal(204);
+                expect(prunedRecordsWriteReply.status.code).toBe(204);
                 // Update record to published, omitting dataStream
                 const recordsWrite = yield TestDataGenerator.generateFromRecordsWrite({
                     author: alice,
@@ -3347,8 +3345,8 @@ export function testRecordsWriteHandler() {
                     data,
                 });
                 const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message);
-                expect(recordsWriteReply.status.code).to.equal(400);
-                expect(recordsWriteReply.status.detail).to.contain(DwnErrorCode.RecordsWriteMissingEncodedDataInPrevious);
+                expect(recordsWriteReply.status.code).toBe(400);
+                expect(recordsWriteReply.status.detail).toContain(DwnErrorCode.RecordsWriteMissingEncodedDataInPrevious);
             }));
             it('should return 400 if attempting a write after a delete', () => __awaiter(this, void 0, void 0, function* () {
                 const { message, author, dataStream } = yield TestDataGenerator.generateRecordsWrite({
@@ -3358,13 +3356,13 @@ export function testRecordsWriteHandler() {
                 const tenant = author.did;
                 TestStubGenerator.stubDidResolver(didResolver, [author]);
                 const initialWriteReply = yield dwn.processMessage(tenant, message, { dataStream });
-                expect(initialWriteReply.status.code).to.equal(202);
+                expect(initialWriteReply.status.code).toBe(202);
                 const recordsDelete = yield RecordsDelete.create({
                     recordId: message.recordId,
                     signer: Jws.createSigner(author),
                 });
                 const deleteReply = yield dwn.processMessage(tenant, recordsDelete.message);
-                expect(deleteReply.status.code).to.equal(202);
+                expect(deleteReply.status.code).toBe(202);
                 const newDataBytes = TestDataGenerator.randomBytes(100);
                 const newInvalidWrite = yield RecordsWrite.createFrom({
                     recordsWriteMessage: message,
@@ -3372,8 +3370,8 @@ export function testRecordsWriteHandler() {
                     data: newDataBytes
                 });
                 const newInvalidWriteReply = yield dwn.processMessage(tenant, newInvalidWrite.message, { dataStream: DataStream.fromBytes(newDataBytes) });
-                expect(newInvalidWriteReply.status.code).to.equal(400);
-                expect(newInvalidWriteReply.status.detail).to.contain(DwnErrorCode.RecordsWriteNotAllowedAfterDelete);
+                expect(newInvalidWriteReply.status.code).toBe(400);
+                expect(newInvalidWriteReply.status.detail).toContain(DwnErrorCode.RecordsWriteNotAllowedAfterDelete);
             }));
             it('should not allow referencing data across tenants', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c;
@@ -3388,15 +3386,15 @@ export function testRecordsWriteHandler() {
                     data
                 });
                 const aliceWriteReply = yield dwn.processMessage(alice.did, aliceWriteData.message, { dataStream: aliceWriteData.dataStream });
-                expect(aliceWriteReply.status.code).to.equal(202);
+                expect(aliceWriteReply.status.code).toBe(202);
                 const aliceQueryWriteAfterAliceWriteData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: aliceWriteData.message.recordId }
                 });
                 const aliceQueryWriteAfterAliceWriteReply = yield dwn.processMessage(alice.did, aliceQueryWriteAfterAliceWriteData.message);
-                expect(aliceQueryWriteAfterAliceWriteReply.status.code).to.equal(200);
-                expect((_a = aliceQueryWriteAfterAliceWriteReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(aliceQueryWriteAfterAliceWriteReply.entries[0].encodedData).to.equal(encodedData);
+                expect(aliceQueryWriteAfterAliceWriteReply.status.code).toBe(200);
+                expect((_a = aliceQueryWriteAfterAliceWriteReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(aliceQueryWriteAfterAliceWriteReply.entries[0].encodedData).toBe(encodedData);
                 // bob learns of the CID of data of alice and tries to gain unauthorized access by referencing it in his own DWN
                 const bobWriteData = yield TestDataGenerator.generateRecordsWrite({
                     author: bob,
@@ -3404,32 +3402,32 @@ export function testRecordsWriteHandler() {
                     dataSize: 4
                 });
                 const bobWriteReply = yield dwn.processMessage(bob.did, bobWriteData.message); // intentionally missing data stream
-                expect(bobWriteReply.status.code).to.equal(204); // NOTE: allows write here but does not allow read or query later
+                expect(bobWriteReply.status.code).toBe(204); // NOTE: allows write here but does not allow read or query later
                 const aliceQueryWriteAfterBobWriteData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: aliceWriteData.message.recordId }
                 });
                 const aliceQueryWriteAfterBobWriteReply = yield dwn.processMessage(alice.did, aliceQueryWriteAfterBobWriteData.message);
-                expect(aliceQueryWriteAfterBobWriteReply.status.code).to.equal(200);
-                expect((_b = aliceQueryWriteAfterBobWriteReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-                expect(aliceQueryWriteAfterBobWriteReply.entries[0].encodedData).to.equal(encodedData);
+                expect(aliceQueryWriteAfterBobWriteReply.status.code).toBe(200);
+                expect((_b = aliceQueryWriteAfterBobWriteReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(aliceQueryWriteAfterBobWriteReply.entries[0].encodedData).toBe(encodedData);
                 // verify that bob has not gained access to alice's data
                 const bobQueryAfterBobWriteData = yield TestDataGenerator.generateRecordsQuery({
                     author: bob,
                     filter: { recordId: bobWriteData.message.recordId }
                 });
                 const bobQueryAfterBobWriteReply = yield dwn.processMessage(bob.did, bobQueryAfterBobWriteData.message);
-                expect(bobQueryAfterBobWriteReply.status.code).to.equal(200);
-                expect((_c = bobQueryAfterBobWriteReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(0);
+                expect(bobQueryAfterBobWriteReply.status.code).toBe(200);
+                expect((_c = bobQueryAfterBobWriteReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(0);
             }));
-            describe('encodedData threshold', () => __awaiter(this, void 0, void 0, function* () {
+            describe('encodedData threshold', () => {
                 it('should call cloneAndAddEncodedData if dataSize is less than or equal to the threshold', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
                     const dataBytes = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded);
                     const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice, data: dataBytes });
                     const processEncoded = sinon.spy(RecordsWriteHandler.prototype, 'cloneAndAddEncodedData');
                     const writeMessage = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(writeMessage.status.code).to.equal(202);
+                    expect(writeMessage.status.code).toBe(202);
                     sinon.assert.calledOnce(processEncoded);
                 }));
                 it('should not call cloneAndAddEncodedData if dataSize is greater than the threshold', () => __awaiter(this, void 0, void 0, function* () {
@@ -3438,7 +3436,7 @@ export function testRecordsWriteHandler() {
                     const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice, data: dataBytes });
                     const processEncoded = sinon.spy(RecordsWriteHandler.prototype, 'cloneAndAddEncodedData');
                     const writeMessage = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(writeMessage.status.code).to.equal(202);
+                    expect(writeMessage.status.code).toBe(202);
                     sinon.assert.notCalled(processEncoded);
                 }));
                 it('should have encodedData field if dataSize is less than or equal to the threshold', () => __awaiter(this, void 0, void 0, function* () {
@@ -3446,30 +3444,30 @@ export function testRecordsWriteHandler() {
                     const dataBytes = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded);
                     const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice, data: dataBytes });
                     const writeMessage = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(writeMessage.status.code).to.equal(202);
+                    expect(writeMessage.status.code).toBe(202);
                     const messageCid = yield Message.getCid(message);
                     const storedMessage = yield messageStore.get(alice.did, messageCid);
-                    expect(storedMessage.encodedData).to.exist.and.not.be.undefined;
+                    expect(storedMessage.encodedData).toBeDefined();
                 }));
                 it('should not have encodedData field if dataSize greater than threshold', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
                     const dataBytes = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1);
                     const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice, data: dataBytes });
                     const writeMessage = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(writeMessage.status.code).to.equal(202);
+                    expect(writeMessage.status.code).toBe(202);
                     const messageCid = yield Message.getCid(message);
                     const storedMessage = yield messageStore.get(alice.did, messageCid);
-                    expect(storedMessage.encodedData).to.not.exist;
+                    expect(storedMessage.encodedData).toBeUndefined();
                 }));
                 it('should retain original RecordsWrite message but without the encodedData if data is under threshold', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
                     const dataBytes = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded);
                     const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice, data: dataBytes });
                     const writeMessage = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(writeMessage.status.code).to.equal(202);
+                    expect(writeMessage.status.code).toBe(202);
                     const messageCid = yield Message.getCid(message);
                     const storedMessage = yield messageStore.get(alice.did, messageCid);
-                    expect(storedMessage.encodedData).to.exist.and.not.be.undefined;
+                    expect(storedMessage.encodedData).toBeDefined();
                     const updatedDataBytes = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded);
                     const newWrite = yield RecordsWrite.createFrom({
                         recordsWriteMessage: message,
@@ -3479,13 +3477,13 @@ export function testRecordsWriteHandler() {
                     });
                     const updateDataStream = DataStream.fromBytes(updatedDataBytes);
                     const writeMessage2 = yield dwn.processMessage(alice.did, newWrite.message, { dataStream: updateDataStream });
-                    expect(writeMessage2.status.code).to.equal(202);
+                    expect(writeMessage2.status.code).toBe(202);
                     const originalWrite = yield messageStore.get(alice.did, messageCid);
-                    expect(originalWrite.encodedData).to.not.exist;
+                    expect(originalWrite.encodedData).toBeUndefined();
                     const newestWrite = yield messageStore.get(alice.did, yield Message.getCid(newWrite.message));
-                    expect(newestWrite.encodedData).to.exist.and.not.be.undefined;
+                    expect(newestWrite.encodedData).toBeDefined();
                 }));
-            }));
+            });
         });
         describe('authorization validation tests', () => {
             it('should return 400 if `recordId` in payload of the message signature mismatches with `recordId` in the message', () => __awaiter(this, void 0, void 0, function* () {
@@ -3501,10 +3499,10 @@ export function testRecordsWriteHandler() {
                 const didResolver = TestStubGenerator.createDidResolverStub(author);
                 const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
                 const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, eventLog, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, stateIndex, eventStream);
                 const reply = yield recordsWriteHandler.handle({ tenant, message, dataStream: dataStream });
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain('does not match recordId in authorization');
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain('does not match recordId in authorization');
             }));
             it('should return 400 if `contextId` in payload of message signature mismatches with `contextId` in the message', () => __awaiter(this, void 0, void 0, function* () {
                 // generate a message with protocol so that computed contextId is also computed and included in message
@@ -3520,10 +3518,10 @@ export function testRecordsWriteHandler() {
                 const didResolver = sinon.createStubInstance(UniversalResolver);
                 const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
                 const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, eventLog, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, stateIndex, eventStream);
                 const reply = yield recordsWriteHandler.handle({ tenant, message, dataStream: dataStream });
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain('does not match contextId in authorization');
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain('does not match contextId in authorization');
             }));
             it('should return 401 if `authorization` signature check fails', () => __awaiter(this, void 0, void 0, function* () {
                 const { author, message, dataStream } = yield TestDataGenerator.generateRecordsWrite();
@@ -3534,9 +3532,9 @@ export function testRecordsWriteHandler() {
                 const didResolver = TestStubGenerator.createDidResolverStub(mismatchingPersona);
                 const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
                 const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, eventLog, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, stateIndex, eventStream);
                 const reply = yield recordsWriteHandler.handle({ tenant, message, dataStream: dataStream });
-                expect(reply.status.code).to.equal(401);
+                expect(reply.status.code).toBe(401);
             }));
             it('should return 401 if an unauthorized author is attempting write', () => __awaiter(this, void 0, void 0, function* () {
                 const author = yield TestDataGenerator.generatePersona();
@@ -3545,10 +3543,10 @@ export function testRecordsWriteHandler() {
                 const didResolver = TestStubGenerator.createDidResolverStub(author);
                 const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
                 const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, eventLog, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, stateIndex, eventStream);
                 const tenant = yield (yield TestDataGenerator.generatePersona()).did; // unauthorized tenant
                 const reply = yield recordsWriteHandler.handle({ tenant, message, dataStream: dataStream });
-                expect(reply.status.code).to.equal(401);
+                expect(reply.status.code).toBe(401);
             }));
         });
         describe('attestation validation tests', () => {
@@ -3571,19 +3569,19 @@ export function testRecordsWriteHandler() {
                 const didResolver = TestStubGenerator.createDidResolverStub(author);
                 const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
                 const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, eventLog, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, stateIndex, eventStream);
                 const reply = yield recordsWriteHandler.handle({ tenant, message, dataStream: dataStream });
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain(`Only 'descriptorCid' is allowed in attestation payload`);
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain(`Only 'descriptorCid' is allowed in attestation payload`);
             }));
             it('should fail validation with 400 if more than 1 attester is given ', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 const bob = yield TestDataGenerator.generateDidKeyPersona();
                 const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [alice, bob] });
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, eventLog, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, stateIndex, eventStream);
                 const writeReply = yield recordsWriteHandler.handle({ tenant: alice.did, message, dataStream: dataStream });
-                expect(writeReply.status.code).to.equal(400);
-                expect(writeReply.status.detail).to.contain('implementation only supports 1 attester');
+                expect(writeReply.status.code).toBe(400);
+                expect(writeReply.status.detail).toContain('implementation only supports 1 attester');
             }));
             it('should fail validation with 400 if the `attestation` does not include the correct `descriptorCid`', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -3591,10 +3589,10 @@ export function testRecordsWriteHandler() {
                 // create another write and use its `attestation` value instead, that `attestation` will point to an entirely different `descriptorCid`
                 const anotherWrite = yield TestDataGenerator.generateRecordsWrite({ attesters: [alice] });
                 message.attestation = anotherWrite.message.attestation;
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, eventLog, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, stateIndex, eventStream);
                 const writeReply = yield recordsWriteHandler.handle({ tenant: alice.did, message, dataStream: dataStream });
-                expect(writeReply.status.code).to.equal(400);
-                expect(writeReply.status.detail).to.contain('does not match expected descriptorCid');
+                expect(writeReply.status.code).toBe(400);
+                expect(writeReply.status.detail).toContain('does not match expected descriptorCid');
             }));
             it('should fail validation with 400 if expected CID of `attestation` mismatches the `attestationCid` in `authorization`', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -3604,16 +3602,16 @@ export function testRecordsWriteHandler() {
                 const descriptorCid = yield Cid.computeCid(message.descriptor);
                 const attestationNotReferencedByAuthorization = yield RecordsWrite['createAttestation'](descriptorCid, Jws.createSigners([bob]));
                 message.attestation = attestationNotReferencedByAuthorization;
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, eventLog, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, stateIndex, eventStream);
                 const writeReply = yield recordsWriteHandler.handle({ tenant: alice.did, message, dataStream: dataStream });
-                expect(writeReply.status.code).to.equal(400);
-                expect(writeReply.status.detail).to.contain('does not match attestationCid');
+                expect(writeReply.status.code).toBe(400);
+                expect(writeReply.status.detail).toContain('does not match attestationCid');
             }));
         });
         describe('unknown error', () => {
             it('should throw if `recordsWriteHandler.processMessageWithoutDataStream()` throws unknown error', () => __awaiter(this, void 0, void 0, function* () {
                 // simulate an initial write to test non-data path, as initial writes without data are always accepted (bot not readable)
-                // https://github.com/TBD54566975/dwn-sdk-js/issues/628
+                // https://github.com/enboxorg/enbox/issues/628
                 const { author, message: initialWriteMessage, recordsWrite: initialWrite } = yield TestDataGenerator.generateRecordsWrite();
                 yield Time.minimalSleep();
                 const { message, dataStream } = yield TestDataGenerator.generateFromRecordsWrite({ author, existingWrite: initialWrite });
@@ -3622,16 +3620,16 @@ export function testRecordsWriteHandler() {
                 const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
                 messageStoreStub.query.resolves({ messages: [initialWriteMessage] });
                 const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-                const recordsWriteHandler = new RecordsWriteHandler(didResolverStub, messageStoreStub, dataStoreStub, eventLog, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler(didResolverStub, messageStoreStub, dataStoreStub, stateIndex, eventStream);
                 // simulate throwing unexpected error
                 sinon.stub(recordsWriteHandler, 'processMessageWithoutDataStream').throws(new Error('an unknown error in recordsWriteHandler.processMessageWithoutDataStream()'));
                 sinon.stub(recordsWriteHandler, 'processMessageWithDataStream').throws(new Error('an unknown error in recordsWriteHandler.processMessageWithDataStream()'));
                 let handlerPromise = recordsWriteHandler.handle({ tenant, message, dataStream: dataStream }); // with data stream
-                yield expect(handlerPromise).to.be.rejectedWith('an unknown error in recordsWriteHandler.processMessageWithDataStream()');
+                yield expect(handlerPromise).rejects.toThrow('an unknown error in recordsWriteHandler.processMessageWithDataStream()');
                 handlerPromise = recordsWriteHandler.handle({ tenant, message }); // without data stream
-                yield expect(handlerPromise).to.be.rejectedWith('an unknown error in recordsWriteHandler.processMessageWithoutDataStream()');
+                yield expect(handlerPromise).rejects.toThrow('an unknown error in recordsWriteHandler.processMessageWithoutDataStream()');
             }));
         });
-    }));
+    });
 }
 //# sourceMappingURL=records-write.spec.js.map