@enbox/dwn-sdk-js 0.0.2 → 0.0.4

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

@@ -7,18 +7,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { DataStoreLevel, DwnConstant, MessageStoreLevel, PermissionsProtocol, Time } from '../../src/index.js';
-import { DwnInterfaceName, DwnMethodName } from '../../src/index.js';
-import chaiAsPromised from 'chai-as-promised';
-import chatProtocolDefinition from '../vectors/protocol-definitions/chat.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 minimalProtocolDefinition from '../vectors/protocol-definitions/minimal.json' assert { type: 'json' };
-import nestedProtocol from '../vectors/protocol-definitions/nested.json' assert { type: 'json' };
+import chatProtocolDefinition from '../vectors/protocol-definitions/chat.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 minimalProtocolDefinition from '../vectors/protocol-definitions/minimal.json' with { type: 'json' };
+import nestedProtocol from '../vectors/protocol-definitions/nested.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 { authenticate } from '../../src/core/auth.js';
 import { DwnErrorCode } from '../../src/core/dwn-error.js';
@@ -30,16 +26,18 @@ import { TestDataGenerator } from '../utils/test-data-generator.js';
 import { TestEventStream } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
 import { TestStubGenerator } from '../utils/test-stub-generator.js';
-import { DataStream, Dwn, Jws, Protocols, ProtocolsConfigure, ProtocolsQuery, Records, RecordsDelete, RecordsRead, RecordsWrite, Secp256k1 } from '../../src/index.js';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
+import { DataStoreLevel, DwnConstant, MessageStoreLevel, PermissionsProtocol, Time } from '../../src/index.js';
+import { DataStream, DateSort, Dwn, Jws, Protocols, ProtocolsConfigure, ProtocolsQuery, Records, RecordsDelete, RecordsRead, RecordsWrite, Secp256k1 } from '../../src/index.js';
 import { DidKey, UniversalResolver } from '@enbox/dids';
-chai.use(chaiAsPromised);
+import { DwnInterfaceName, DwnMethodName } from '../../src/index.js';
 export function testRecordsReadHandler() {
     describe('RecordsReadHandler.handle()', () => {
         let didResolver;
         let messageStore;
         let dataStore;
         let resumableTaskStore;
-        let eventLog;
+        let stateIndex;
         let eventStream;
         let dwn;
         beforeEach(() => {
@@ -48,24 +46,24 @@ export function testRecordsReadHandler() {
         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 allow tenant to RecordsRead their own record', () => __awaiter(this, void 0, void 0, function* () {
@@ -74,7 +72,7 @@ export function testRecordsReadHandler() {
                 // insert data
                 const { message, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 // testing RecordsRead
                 const recordsRead = yield RecordsRead.create({
                     filter: {
@@ -83,19 +81,19 @@ export function testRecordsReadHandler() {
                     signer: Jws.createSigner(alice)
                 });
                 const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                expect(readReply.status.code).to.equal(200);
-                expect(readReply.entry.recordsWrite).to.exist;
-                expect((_a = readReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.authorization).to.deep.equal(message.authorization);
-                expect((_b = readReply.entry.recordsWrite) === null || _b === void 0 ? void 0 : _b.descriptor).to.deep.equal(message.descriptor);
+                expect(readReply.status.code).toBe(200);
+                expect(readReply.entry.recordsWrite).toBeDefined();
+                expect((_a = readReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.authorization).toEqual(message.authorization);
+                expect((_b = readReply.entry.recordsWrite) === null || _b === void 0 ? void 0 : _b.descriptor).toEqual(message.descriptor);
                 const dataFetched = yield DataStream.toBytes(readReply.entry.data);
-                expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).to.be.true;
+                expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).toBe(true);
             }));
             it('should not allow non-tenant to RecordsRead a record', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 // insert data
                 const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 // testing RecordsRead
                 const bob = yield TestDataGenerator.generateDidKeyPersona();
                 const recordsRead = yield RecordsRead.create({
@@ -105,32 +103,32 @@ export function testRecordsReadHandler() {
                     signer: Jws.createSigner(bob)
                 });
                 const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                expect(readReply.status.code).to.equal(401);
+                expect(readReply.status.code).toBe(401);
             }));
             it('should allow reading of data that is published without `authorization`', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 // insert public data
                 const { message, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({ author: alice, published: true });
                 const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 // testing public RecordsRead
                 const recordsRead = yield RecordsRead.create({
                     filter: {
                         recordId: message.recordId
                     }
                 });
-                expect(recordsRead.author).to.be.undefined; // making sure no author/authorization is created
+                expect(recordsRead.author).toBeUndefined(); // making sure no author/authorization is created
                 const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                expect(readReply.status.code).to.equal(200);
+                expect(readReply.status.code).toBe(200);
                 const dataFetched = yield DataStream.toBytes(readReply.entry.data);
-                expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).to.be.true;
+                expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).toBe(true);
             }));
             it('should allow an authenticated user to RecordRead data that is published', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 // insert public data
                 const { message, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({ author: alice, published: true });
                 const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 // testing public RecordsRead
                 const bob = yield TestDataGenerator.generateDidKeyPersona();
                 const recordsRead = yield RecordsRead.create({
@@ -140,9 +138,9 @@ export function testRecordsReadHandler() {
                     signer: Jws.createSigner(bob)
                 });
                 const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                expect(readReply.status.code).to.equal(200);
+                expect(readReply.status.code).toBe(200);
                 const dataFetched = yield DataStream.toBytes(readReply.entry.data);
-                expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).to.be.true;
+                expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).toBe(true);
             }));
             it('should allow a non-tenant to read RecordsRead data they have received', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -154,7 +152,7 @@ export function testRecordsReadHandler() {
                     recipient: bob.did,
                 });
                 const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 // Bob reads the data that Alice sent him
                 const recordsRead = yield RecordsRead.create({
                     filter: {
@@ -163,25 +161,25 @@ export function testRecordsReadHandler() {
                     signer: Jws.createSigner(bob)
                 });
                 const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                expect(readReply.status.code).to.equal(200);
-                expect(readReply.entry.recordsWrite).to.exist;
-                expect((_a = readReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.descriptor).to.exist;
+                expect(readReply.status.code).toBe(200);
+                expect(readReply.entry.recordsWrite).toBeDefined();
+                expect((_a = readReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.descriptor).toBeDefined();
                 const dataFetched = yield DataStream.toBytes(readReply.entry.data);
-                expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).to.be.true;
+                expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).toBe(true);
             }));
             it('should return 400 when fetching initial write for a deleted record fails', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 // Write a record
                 const { message: writeMessage, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const writeReply = yield dwn.processMessage(alice.did, writeMessage, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 // Delete the record
                 const recordsDelete = yield RecordsDelete.create({
                     signer: Jws.createSigner(alice),
                     recordId: writeMessage.recordId
                 });
                 const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                expect(deleteReply.status.code).to.equal(202);
+                expect(deleteReply.status.code).toBe(202);
                 // Stub the messageStore.query method to simulate failure in fetching initial write
                 const queryStub = sinon.stub(dwn['messageStore'], 'query');
                 queryStub.onFirstCall().resolves({ messages: [recordsDelete.message] });
@@ -193,8 +191,8 @@ export function testRecordsReadHandler() {
                 });
                 const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
                 // Verify the response
-                expect(readReply.status.code).to.equal(400);
-                expect(readReply.status.detail).to.contain(DwnErrorCode.RecordsReadInitialWriteNotFound);
+                expect(readReply.status.code).toBe(400);
+                expect(readReply.status.detail).toContain(DwnErrorCode.RecordsReadInitialWriteNotFound);
                 // Restore the original messageStore.query method
                 queryStub.restore();
             }));
@@ -223,7 +221,7 @@ export function testRecordsReadHandler() {
                     protocolDefinition: protocolDefinition,
                 });
                 const configureProtocolReply = yield dwn.processMessage(alice.did, configureProtocol.message);
-                expect(configureProtocolReply.status.code).to.equal(202);
+                expect(configureProtocolReply.status.code).toBe(202);
                 // Bob writes a record to Alice's DWN
                 const { message: writeMessage, dataStream } = yield TestDataGenerator.generateRecordsWrite({
                     author: bob,
@@ -231,14 +229,14 @@ export function testRecordsReadHandler() {
                     protocolPath: 'foo'
                 });
                 const writeReply = yield dwn.processMessage(alice.did, writeMessage, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 // Bob deletes the record
                 const recordsDelete = yield RecordsDelete.create({
                     signer: Jws.createSigner(bob),
                     recordId: writeMessage.recordId
                 });
                 const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                expect(deleteReply.status.code).to.equal(202);
+                expect(deleteReply.status.code).toBe(202);
                 // Carol attempts to read the deleted record
                 const recordsRead = yield RecordsRead.create({
                     filter: { recordId: writeMessage.recordId },
@@ -246,8 +244,8 @@ export function testRecordsReadHandler() {
                 });
                 const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
                 // Verify the response
-                expect(readReply.status.code).to.equal(401);
-                expect(readReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                expect(readReply.status.code).toBe(401);
+                expect(readReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
             }));
             it('should allow a non-tenant to read RecordsRead data they have authored', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -275,7 +273,7 @@ export function testRecordsReadHandler() {
                     protocolDefinition: protocolDefinition,
                 });
                 const configureProtocolReply = yield dwn.processMessage(alice.did, configureProtocol.message);
-                expect(configureProtocolReply.status.code).to.equal(202);
+                expect(configureProtocolReply.status.code).toBe(202);
                 // Bob writes a foo record to Alice's DWN
                 const { message, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({
                     author: bob,
@@ -283,7 +281,7 @@ export function testRecordsReadHandler() {
                     protocolPath: 'foo',
                 });
                 const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 // Bob reads the record he sent to Alice from Alice's DWN
                 const recordsRead = yield RecordsRead.create({
                     filter: {
@@ -292,11 +290,11 @@ export function testRecordsReadHandler() {
                     signer: Jws.createSigner(bob)
                 });
                 const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                expect(readReply.status.code).to.equal(200);
-                expect(readReply.entry.recordsWrite).to.exist;
-                expect((_a = readReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.descriptor).to.exist;
+                expect(readReply.status.code).toBe(200);
+                expect(readReply.entry.recordsWrite).toBeDefined();
+                expect((_a = readReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.descriptor).toBeDefined();
                 const dataFetched = yield DataStream.toBytes(readReply.entry.data);
-                expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).to.be.true;
+                expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).toBe(true);
                 // carol attempts to read Bob's record
                 const carolRecordsRead = yield RecordsRead.create({
                     filter: {
@@ -305,24 +303,24 @@ export function testRecordsReadHandler() {
                     signer: Jws.createSigner(carol)
                 });
                 const carolReadReply = yield dwn.processMessage(alice.did, carolRecordsRead.message);
-                expect(carolReadReply.status.code).to.equal(401);
+                expect(carolReadReply.status.code).toBe(401);
             }));
             it('should include `initialWrite` property if RecordsWrite is not initial write', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 const write = yield TestDataGenerator.generateRecordsWrite({ author: alice, published: false });
                 const writeReply = yield dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 // write an update to the record
                 const write2 = yield RecordsWrite.createFrom({ recordsWriteMessage: write.message, published: true, signer: Jws.createSigner(alice) });
                 const write2Reply = yield dwn.processMessage(alice.did, write2.message);
-                expect(write2Reply.status.code).to.equal(202);
+                expect(write2Reply.status.code).toBe(202);
                 // make sure result returned now has `initialWrite` property
                 const messageData = yield RecordsRead.create({ filter: { recordId: write.message.recordId }, signer: Jws.createSigner(alice) });
                 const reply = yield dwn.processMessage(alice.did, messageData.message);
-                expect(reply.status.code).to.equal(200);
-                expect(reply.entry.initialWrite).to.exist;
-                expect((_a = reply.entry.initialWrite) === null || _a === void 0 ? void 0 : _a.recordId).to.equal(write.message.recordId);
+                expect(reply.status.code).toBe(200);
+                expect(reply.entry.initialWrite).toBeDefined();
+                expect((_a = reply.entry.initialWrite) === null || _a === void 0 ? void 0 : _a.recordId).toBe(write.message.recordId);
             }));
             describe('protocol based reads', () => {
                 it('should allow read with allow-anyone rule', () => __awaiter(this, void 0, void 0, function* () {
@@ -336,7 +334,7 @@ export function testRecordsReadHandler() {
                         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 image to her DWN
                     const encodedImage = new TextEncoder().encode('cafe-aesthetic.jpg');
                     const imageRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
@@ -349,7 +347,7 @@ export function testRecordsReadHandler() {
                         recipient: alice.did
                     });
                     const imageReply = yield dwn.processMessage(alice.did, imageRecordsWrite.message, { dataStream: imageRecordsWrite.dataStream });
-                    expect(imageReply.status.code).to.equal(202);
+                    expect(imageReply.status.code).toBe(202);
                     // Bob (anyone) reads the image that Alice wrote
                     const imageRecordsRead = yield RecordsRead.create({
                         filter: {
@@ -358,7 +356,7 @@ export function testRecordsReadHandler() {
                         signer: Jws.createSigner(bob)
                     });
                     const imageReadReply = yield dwn.processMessage(alice.did, imageRecordsRead.message);
-                    expect(imageReadReply.status.code).to.equal(200);
+                    expect(imageReadReply.status.code).toBe(200);
                 }));
                 it('should not allow anonymous reads when there is no allow-anyone rule', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Alice's writes a record to a protocol. An anonymous read his Alice's DWN and is rejected
@@ -371,7 +369,7 @@ export function testRecordsReadHandler() {
                         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 message to the minimal protocol
                     const recordsWrite = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -382,7 +380,7 @@ export function testRecordsReadHandler() {
                         data: new TextEncoder().encode('foo')
                     });
                     const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
-                    expect(recordsWriteReply.status.code).to.equal(202);
+                    expect(recordsWriteReply.status.code).toBe(202);
                     // Anonymous tries and fails to read Alice's message
                     const recordsRead = yield RecordsRead.create({
                         filter: {
@@ -390,8 +388,8 @@ export function testRecordsReadHandler() {
                         }
                     });
                     const recordsReadReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                    expect(recordsReadReply.status.code).to.equal(401);
-                    expect(recordsReadReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                    expect(recordsReadReply.status.code).toBe(401);
+                    expect(recordsReadReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                 }));
                 describe('recipient rules', () => {
                     it('should allow read with ancestor recipient rule', () => __awaiter(this, void 0, void 0, function* () {
@@ -407,7 +405,7 @@ export function testRecordsReadHandler() {
                             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 an email with Bob as recipient
                         const encodedEmail = new TextEncoder().encode('Dear Bob, hello!');
                         const emailRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
@@ -420,7 +418,7 @@ export function testRecordsReadHandler() {
                             recipient: bob.did
                         });
                         const imageReply = yield dwn.processMessage(alice.did, emailRecordsWrite.message, { dataStream: emailRecordsWrite.dataStream });
-                        expect(imageReply.status.code).to.equal(202);
+                        expect(imageReply.status.code).toBe(202);
                         // Bob reads Alice's email
                         const bobRecordsRead = yield RecordsRead.create({
                             filter: {
@@ -429,7 +427,7 @@ export function testRecordsReadHandler() {
                             signer: Jws.createSigner(bob)
                         });
                         const bobReadReply = yield dwn.processMessage(alice.did, bobRecordsRead.message);
-                        expect(bobReadReply.status.code).to.equal(200);
+                        expect(bobReadReply.status.code).toBe(200);
                         // ImposterBob is not able to read Alice's email
                         const imposterRecordsRead = yield RecordsRead.create({
                             filter: {
@@ -438,8 +436,8 @@ export function testRecordsReadHandler() {
                             signer: Jws.createSigner(imposterBob)
                         });
                         const imposterReadReply = yield dwn.processMessage(alice.did, imposterRecordsRead.message);
-                        expect(imposterReadReply.status.code).to.equal(401);
-                        expect(imposterReadReply.status.detail).to.include(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                        expect(imposterReadReply.status.code).toBe(401);
+                        expect(imposterReadReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                     }));
                 });
                 describe('author action rules', () => {
@@ -456,7 +454,7 @@ export function testRecordsReadHandler() {
                             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 an email with Bob as recipient
                         const encodedEmail = new TextEncoder().encode('Dear Alice, hello!');
                         const emailRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
@@ -469,7 +467,7 @@ export function testRecordsReadHandler() {
                             recipient: alice.did
                         });
                         const imageReply = yield dwn.processMessage(alice.did, emailRecordsWrite.message, { dataStream: emailRecordsWrite.dataStream });
-                        expect(imageReply.status.code).to.equal(202);
+                        expect(imageReply.status.code).toBe(202);
                         // Bob reads the email he just sent
                         const bobRecordsRead = yield RecordsRead.create({
                             filter: {
@@ -478,7 +476,7 @@ export function testRecordsReadHandler() {
                             signer: Jws.createSigner(bob)
                         });
                         const bobReadReply = yield dwn.processMessage(alice.did, bobRecordsRead.message);
-                        expect(bobReadReply.status.code).to.equal(200);
+                        expect(bobReadReply.status.code).toBe(200);
                         // ImposterBob is not able to read the email
                         const imposterRecordsRead = yield RecordsRead.create({
                             filter: {
@@ -487,8 +485,8 @@ export function testRecordsReadHandler() {
                             signer: Jws.createSigner(imposterBob)
                         });
                         const imposterReadReply = yield dwn.processMessage(alice.did, imposterRecordsRead.message);
-                        expect(imposterReadReply.status.code).to.equal(401);
-                        expect(imposterReadReply.status.detail).to.include(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
+                        expect(imposterReadReply.status.code).toBe(401);
+                        expect(imposterReadReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                     }));
                 });
                 describe('filter based reads', () => {
@@ -500,7 +498,7 @@ export function testRecordsReadHandler() {
                             protocolDefinition
                         });
                         const protocolConfigReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolConfigReply.status.code).to.equal(202);
+                        expect(protocolConfigReply.status.code).toBe(202);
                         const foo1Write = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
@@ -511,7 +509,7 @@ export function testRecordsReadHandler() {
                             recipient: alice.did
                         });
                         const foo1WriteReply = yield dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
-                        expect(foo1WriteReply.status.code).to.equal(202);
+                        expect(foo1WriteReply.status.code).toBe(202);
                         const fooPathRead = yield RecordsRead.create({
                             filter: {
                                 protocol: protocolDefinition.protocol,
@@ -520,10 +518,10 @@ export function testRecordsReadHandler() {
                             signer: Jws.createSigner(alice),
                         });
                         const fooPathReply = yield dwn.processMessage(alice.did, fooPathRead.message);
-                        expect(fooPathReply.status.code).to.equal(200);
-                        expect(fooPathReply.entry.recordsWrite.recordId).to.equal(foo1Write.message.recordId);
+                        expect(fooPathReply.status.code).toBe(200);
+                        expect(fooPathReply.entry.recordsWrite.recordId).toBe(foo1Write.message.recordId);
                     }));
-                    it('should throw if requested filter has more than a single result', () => __awaiter(this, void 0, void 0, function* () {
+                    it('should return the most recently updated record when filter matches multiple results', () => __awaiter(this, void 0, void 0, function* () {
                         const alice = yield TestDataGenerator.generateDidKeyPersona();
                         const protocolDefinition = Object.assign({}, nestedProtocol);
                         const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
@@ -531,40 +529,272 @@ export function testRecordsReadHandler() {
                             protocolDefinition
                         });
                         const protocolConfigReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                        expect(protocolConfigReply.status.code).to.equal(202);
+                        expect(protocolConfigReply.status.code).toBe(202);
                         const foo1Write = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'foo',
                             schema: protocolDefinition.types.foo.schema,
                             dataFormat: protocolDefinition.types.foo.dataFormats[0],
-                            data: new TextEncoder().encode('foo'),
+                            data: new TextEncoder().encode('foo1'),
                             recipient: alice.did
                         });
                         const foo1WriteReply = yield dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
-                        expect(foo1WriteReply.status.code).to.equal(202);
+                        expect(foo1WriteReply.status.code).toBe(202);
+                        yield Time.minimalSleep();
                         const foo2Write = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'foo',
                             schema: protocolDefinition.types.foo.schema,
                             dataFormat: protocolDefinition.types.foo.dataFormats[0],
-                            data: new TextEncoder().encode('foo'),
+                            data: new TextEncoder().encode('foo2'),
+                            recipient: alice.did
+                        });
+                        const foo2WriteReply = yield dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
+                        expect(foo2WriteReply.status.code).toBe(202);
+                        // default sort is updatedDescending, so the most recently updated record should be returned
+                        const fooPathRead = yield RecordsRead.create({
+                            filter: {
+                                protocol: protocolDefinition.protocol,
+                                protocolPath: 'foo',
+                            },
+                            signer: Jws.createSigner(alice),
+                        });
+                        const fooPathReply = yield dwn.processMessage(alice.did, fooPathRead.message);
+                        expect(fooPathReply.status.code).toBe(200);
+                        expect(fooPathReply.entry.recordsWrite.recordId).toBe(foo2Write.message.recordId);
+                    }));
+                    it('should return the oldest record when `dateSort` is `CreatedAscending` and filter matches multiple results', () => __awaiter(this, void 0, void 0, function* () {
+                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        const protocolDefinition = Object.assign({}, nestedProtocol);
+                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                            author: alice,
+                            protocolDefinition
+                        });
+                        const protocolConfigReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        expect(protocolConfigReply.status.code).toBe(202);
+                        const foo1Write = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            protocol: protocolDefinition.protocol,
+                            protocolPath: 'foo',
+                            schema: protocolDefinition.types.foo.schema,
+                            dataFormat: protocolDefinition.types.foo.dataFormats[0],
+                            data: new TextEncoder().encode('foo1'),
+                            recipient: alice.did
+                        });
+                        const foo1WriteReply = yield dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
+                        expect(foo1WriteReply.status.code).toBe(202);
+                        yield Time.minimalSleep();
+                        const foo2Write = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            protocol: protocolDefinition.protocol,
+                            protocolPath: 'foo',
+                            schema: protocolDefinition.types.foo.schema,
+                            dataFormat: protocolDefinition.types.foo.dataFormats[0],
+                            data: new TextEncoder().encode('foo2'),
+                            recipient: alice.did
+                        });
+                        const foo2WriteReply = yield dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
+                        expect(foo2WriteReply.status.code).toBe(202);
+                        // with createdAscending sort, the oldest record should be returned
+                        const fooPathRead = yield RecordsRead.create({
+                            filter: {
+                                protocol: protocolDefinition.protocol,
+                                protocolPath: 'foo',
+                            },
+                            dateSort: DateSort.CreatedAscending,
+                            signer: Jws.createSigner(alice),
+                        });
+                        const fooPathReply = yield dwn.processMessage(alice.did, fooPathRead.message);
+                        expect(fooPathReply.status.code).toBe(200);
+                        expect(fooPathReply.entry.recordsWrite.recordId).toBe(foo1Write.message.recordId);
+                    }));
+                    it('should return the newest record when `dateSort` is `CreatedDescending` and filter matches multiple results', () => __awaiter(this, void 0, void 0, function* () {
+                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        const protocolDefinition = Object.assign({}, nestedProtocol);
+                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                            author: alice,
+                            protocolDefinition
+                        });
+                        const protocolConfigReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        expect(protocolConfigReply.status.code).toBe(202);
+                        const foo1Write = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            protocol: protocolDefinition.protocol,
+                            protocolPath: 'foo',
+                            schema: protocolDefinition.types.foo.schema,
+                            dataFormat: protocolDefinition.types.foo.dataFormats[0],
+                            data: new TextEncoder().encode('foo1'),
+                            recipient: alice.did
+                        });
+                        const foo1WriteReply = yield dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
+                        expect(foo1WriteReply.status.code).toBe(202);
+                        yield Time.minimalSleep();
+                        const foo2Write = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            protocol: protocolDefinition.protocol,
+                            protocolPath: 'foo',
+                            schema: protocolDefinition.types.foo.schema,
+                            dataFormat: protocolDefinition.types.foo.dataFormats[0],
+                            data: new TextEncoder().encode('foo2'),
+                            recipient: alice.did
+                        });
+                        const foo2WriteReply = yield dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
+                        expect(foo2WriteReply.status.code).toBe(202);
+                        const fooPathRead = yield RecordsRead.create({
+                            filter: {
+                                protocol: protocolDefinition.protocol,
+                                protocolPath: 'foo',
+                            },
+                            dateSort: DateSort.CreatedDescending,
+                            signer: Jws.createSigner(alice),
+                        });
+                        const fooPathReply = yield dwn.processMessage(alice.did, fooPathRead.message);
+                        expect(fooPathReply.status.code).toBe(200);
+                        expect(fooPathReply.entry.recordsWrite.recordId).toBe(foo2Write.message.recordId);
+                    }));
+                    it('should return the oldest updated record when `dateSort` is `UpdatedAscending`', () => __awaiter(this, void 0, void 0, function* () {
+                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        const protocolDefinition = Object.assign({}, nestedProtocol);
+                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                            author: alice,
+                            protocolDefinition
+                        });
+                        const protocolConfigReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        expect(protocolConfigReply.status.code).toBe(202);
+                        const foo1Write = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            protocol: protocolDefinition.protocol,
+                            protocolPath: 'foo',
+                            schema: protocolDefinition.types.foo.schema,
+                            dataFormat: protocolDefinition.types.foo.dataFormats[0],
+                            data: new TextEncoder().encode('foo1'),
+                            recipient: alice.did
+                        });
+                        const foo1WriteReply = yield dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
+                        expect(foo1WriteReply.status.code).toBe(202);
+                        yield Time.minimalSleep();
+                        const foo2Write = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            protocol: protocolDefinition.protocol,
+                            protocolPath: 'foo',
+                            schema: protocolDefinition.types.foo.schema,
+                            dataFormat: protocolDefinition.types.foo.dataFormats[0],
+                            data: new TextEncoder().encode('foo2'),
+                            recipient: alice.did
+                        });
+                        const foo2WriteReply = yield dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
+                        expect(foo2WriteReply.status.code).toBe(202);
+                        const fooPathRead = yield RecordsRead.create({
+                            filter: {
+                                protocol: protocolDefinition.protocol,
+                                protocolPath: 'foo',
+                            },
+                            dateSort: DateSort.UpdatedAscending,
+                            signer: Jws.createSigner(alice),
+                        });
+                        const fooPathReply = yield dwn.processMessage(alice.did, fooPathRead.message);
+                        expect(fooPathReply.status.code).toBe(200);
+                        expect(fooPathReply.entry.recordsWrite.recordId).toBe(foo1Write.message.recordId);
+                    }));
+                    it('should return the most recently updated record when `dateSort` is `UpdatedDescending`', () => __awaiter(this, void 0, void 0, function* () {
+                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        const protocolDefinition = Object.assign({}, nestedProtocol);
+                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                            author: alice,
+                            protocolDefinition
+                        });
+                        const protocolConfigReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        expect(protocolConfigReply.status.code).toBe(202);
+                        const foo1Write = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            protocol: protocolDefinition.protocol,
+                            protocolPath: 'foo',
+                            schema: protocolDefinition.types.foo.schema,
+                            dataFormat: protocolDefinition.types.foo.dataFormats[0],
+                            data: new TextEncoder().encode('foo1'),
+                            recipient: alice.did
+                        });
+                        const foo1WriteReply = yield dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
+                        expect(foo1WriteReply.status.code).toBe(202);
+                        yield Time.minimalSleep();
+                        const foo2Write = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            protocol: protocolDefinition.protocol,
+                            protocolPath: 'foo',
+                            schema: protocolDefinition.types.foo.schema,
+                            dataFormat: protocolDefinition.types.foo.dataFormats[0],
+                            data: new TextEncoder().encode('foo2'),
                             recipient: alice.did
                         });
                         const foo2WriteReply = yield dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
-                        expect(foo2WriteReply.status.code).to.equal(202);
-                        // Since there are two 'foo' records, this should fail.
+                        expect(foo2WriteReply.status.code).toBe(202);
                         const fooPathRead = yield RecordsRead.create({
                             filter: {
                                 protocol: protocolDefinition.protocol,
                                 protocolPath: 'foo',
                             },
+                            dateSort: DateSort.UpdatedDescending,
                             signer: Jws.createSigner(alice),
                         });
                         const fooPathReply = yield dwn.processMessage(alice.did, fooPathRead.message);
-                        expect(fooPathReply.status.code).to.equal(400);
-                        expect(fooPathReply.status.detail).to.contain(DwnErrorCode.RecordsReadReturnedMultiple);
+                        expect(fooPathReply.status.code).toBe(200);
+                        expect(fooPathReply.entry.recordsWrite.recordId).toBe(foo2Write.message.recordId);
+                    }));
+                    it('should return the earliest published record when `dateSort` is `PublishedAscending`', () => __awaiter(this, void 0, void 0, function* () {
+                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        const schema = 'aSchema';
+                        const write1 = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            schema,
+                            published: true,
+                        });
+                        const write1Reply = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                        expect(write1Reply.status.code).toBe(202);
+                        yield Time.minimalSleep();
+                        const write2 = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            schema,
+                            published: true,
+                        });
+                        const write2Reply = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                        expect(write2Reply.status.code).toBe(202);
+                        const read = yield RecordsRead.create({
+                            filter: { schema },
+                            dateSort: DateSort.PublishedAscending,
+                            signer: Jws.createSigner(alice),
+                        });
+                        const readReply = yield dwn.processMessage(alice.did, read.message);
+                        expect(readReply.status.code).toBe(200);
+                        expect(readReply.entry.recordsWrite.recordId).toBe(write1.message.recordId);
+                    }));
+                    it('should return the latest published record when `dateSort` is `PublishedDescending`', () => __awaiter(this, void 0, void 0, function* () {
+                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        const schema = 'aSchema';
+                        const write1 = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            schema,
+                            published: true,
+                        });
+                        const write1Reply = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                        expect(write1Reply.status.code).toBe(202);
+                        yield Time.minimalSleep();
+                        const write2 = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            schema,
+                            published: true,
+                        });
+                        const write2Reply = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                        expect(write2Reply.status.code).toBe(202);
+                        const read = yield RecordsRead.create({
+                            filter: { schema },
+                            dateSort: DateSort.PublishedDescending,
+                            signer: Jws.createSigner(alice),
+                        });
+                        const readReply = yield dwn.processMessage(alice.did, read.message);
+                        expect(readReply.status.code).toBe(200);
+                        expect(readReply.entry.recordsWrite.recordId).toBe(write2.message.recordId);
                     }));
                 });
                 describe('protocolRole based reads', () => {
@@ -579,7 +809,7 @@ export function testRecordsReadHandler() {
                             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,
@@ -589,7 +819,7 @@ export function testRecordsReadHandler() {
                             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 writes a 'chat' record
                         const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -599,7 +829,7 @@ export function testRecordsReadHandler() {
                             data: new TextEncoder().encode('Bob can read this cuz he is my 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 reads Alice's chat record
                         const readChatRecord = yield RecordsRead.create({
                             signer: Jws.createSigner(bob),
@@ -609,7 +839,7 @@ export function testRecordsReadHandler() {
                             protocolRole: 'friend'
                         });
                         const chatReadReply = yield dwn.processMessage(alice.did, readChatRecord.message);
-                        expect(chatReadReply.status.code).to.equal(200);
+                        expect(chatReadReply.status.code).toBe(200);
                     }));
                     it('rejects root-level role authorized reads if the protocolRole is not a valid protocol path to an active role record', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice writes a chat message writes a chat message. Bob tries to invoke the 'chat' role,
@@ -622,7 +852,7 @@ export function testRecordsReadHandler() {
                             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
                         const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -632,7 +862,7 @@ export function testRecordsReadHandler() {
                             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 readChatRecord = yield RecordsRead.create({
                             signer: Jws.createSigner(bob),
@@ -642,8 +872,8 @@ export function testRecordsReadHandler() {
                             protocolRole: 'chat'
                         });
                         const chatReadReply = yield dwn.processMessage(alice.did, readChatRecord.message);
-                        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 reads if there is no active role for the recipient', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice writes a chat message writes a chat message. Bob tries to invoke a role,
@@ -656,7 +886,7 @@ export function testRecordsReadHandler() {
                             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
                         const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -666,7 +896,7 @@ export function testRecordsReadHandler() {
                             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 'friend' role but he is not a 'friend'
                         const readChatRecord = yield RecordsRead.create({
                             signer: Jws.createSigner(bob),
@@ -676,8 +906,8 @@ export function testRecordsReadHandler() {
                             protocolRole: 'friend',
                         });
                         const chatReadReply = yield dwn.processMessage(alice.did, readChatRecord.message);
-                        expect(chatReadReply.status.code).to.equal(401);
-                        expect(chatReadReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
+                        expect(chatReadReply.status.code).toBe(401);
+                        expect(chatReadReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
                     }));
                     it('can authorize a read using a context role', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice creates a thread and adds Bob to the 'thread/participant' role. Alice writes a chat message.
@@ -690,7 +920,7 @@ export function testRecordsReadHandler() {
                             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,
@@ -698,7 +928,7 @@ export function testRecordsReadHandler() {
                             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,
@@ -708,7 +938,7 @@ export function testRecordsReadHandler() {
                             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,
@@ -717,7 +947,7 @@ export function testRecordsReadHandler() {
                             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 is able to read his own 'participant' role
                         // He doesn't need to invoke the role because recipients of a record are always authorized to read it
                         const participantRead = yield RecordsRead.create({
@@ -729,7 +959,7 @@ export function testRecordsReadHandler() {
                             },
                         });
                         const participantReadReply = yield dwn.processMessage(alice.did, participantRead.message);
-                        expect(participantReadReply.status.code).to.equal(200);
+                        expect(participantReadReply.status.code).toBe(200);
                         // Bob is able to read the thread root record
                         const threadRead = yield RecordsRead.create({
                             signer: Jws.createSigner(bob),
@@ -739,7 +969,7 @@ export function testRecordsReadHandler() {
                             protocolRole: 'thread/participant'
                         });
                         const threadReadReply = yield dwn.processMessage(alice.did, threadRead.message);
-                        expect(threadReadReply.status.code).to.equal(200);
+                        expect(threadReadReply.status.code).toBe(200);
                         // Bob invokes his 'participant' role to read the chat message
                         const chatRead = yield RecordsRead.create({
                             signer: Jws.createSigner(bob),
@@ -749,7 +979,7 @@ export function testRecordsReadHandler() {
                             protocolRole: 'thread/participant'
                         });
                         const chatReadReply = yield dwn.processMessage(alice.did, chatRead.message);
-                        expect(chatReadReply.status.code).to.equal(200);
+                        expect(chatReadReply.status.code).toBe(200);
                     }));
                     it('should not allow context role to be invoked against a wrong context', () => __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
@@ -762,7 +992,7 @@ export function testRecordsReadHandler() {
                             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,
@@ -771,7 +1001,7 @@ export function testRecordsReadHandler() {
                             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,
@@ -781,7 +1011,7 @@ export function testRecordsReadHandler() {
                             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,
@@ -790,7 +1020,7 @@ export function testRecordsReadHandler() {
                             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 writes a chat message in the thread
                         const chatRecord = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -799,7 +1029,7 @@ export function testRecordsReadHandler() {
                             parentContextId: threadRecord2.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 'participant' role to read the chat message
                         const chatRead = yield RecordsRead.create({
                             signer: Jws.createSigner(bob),
@@ -809,8 +1039,8 @@ export function testRecordsReadHandler() {
                             protocolRole: 'thread/participant'
                         });
                         const chatReadReply = yield dwn.processMessage(alice.did, chatRead.message);
-                        expect(chatReadReply.status.code).to.equal(401);
-                        expect(chatReadReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
+                        expect(chatReadReply.status.code).toBe(401);
+                        expect(chatReadReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
                     }));
                 });
             });
@@ -824,7 +1054,7 @@ export function testRecordsReadHandler() {
                         author: alice,
                     });
                     const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                    expect(recordsWriteReply.status.code).to.equal(202);
+                    expect(recordsWriteReply.status.code).toBe(202);
                     // Alice gives Bob a permission grant with scope RecordsRead
                     const permissionGrant = yield PermissionsProtocol.createGrant({
                         signer: Jws.createSigner(alice),
@@ -838,7 +1068,7 @@ export function testRecordsReadHandler() {
                     });
                     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 tries to RecordsRead
                     const recordsRead = yield RecordsRead.create({
                         filter: {
@@ -848,8 +1078,8 @@ export function testRecordsReadHandler() {
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
                     const recordsReadReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                    expect(recordsReadReply.status.code).to.equal(401);
-                    expect(recordsReadReply.status.detail).to.contain(DwnErrorCode.GrantAuthorizationMethodMismatch);
+                    expect(recordsReadReply.status.code).toBe(401);
+                    expect(recordsReadReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationMethodMismatch);
                 }));
                 describe('protocol records', () => {
                     it('allows reads of protocol records with unrestricted grant scopes', () => __awaiter(this, void 0, void 0, function* () {
@@ -864,7 +1094,7 @@ export function testRecordsReadHandler() {
                             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 record which Bob will later try to read
                         const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -872,7 +1102,7 @@ export function testRecordsReadHandler() {
                             protocolPath: 'foo',
                         });
                         const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                        expect(recordsWriteReply.status.code).to.equal(202);
+                        expect(recordsWriteReply.status.code).toBe(202);
                         // Alice gives Bob a permission grant with scope RecordsRead
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -886,7 +1116,7 @@ export function testRecordsReadHandler() {
                         });
                         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 is unable to read the record without using the permission grant
                         const recordsReadWithoutGrant = yield RecordsRead.create({
                             filter: {
@@ -895,8 +1125,8 @@ export function testRecordsReadHandler() {
                             signer: Jws.createSigner(bob),
                         });
                         const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
-                        expect(recordsReadWithoutGrantReply.status.code).to.equal(401);
-                        expect(recordsReadWithoutGrantReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionRulesNotFound);
+                        expect(recordsReadWithoutGrantReply.status.code).toBe(401);
+                        expect(recordsReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionRulesNotFound);
                         // Bob is able to read the record when he uses the permission grant
                         const recordsReadWithGrant = yield RecordsRead.create({
                             filter: {
@@ -906,7 +1136,7 @@ export function testRecordsReadHandler() {
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
                         const recordsReadWithGrantReply = yield dwn.processMessage(alice.did, recordsReadWithGrant.message);
-                        expect(recordsReadWithGrantReply.status.code).to.equal(200);
+                        expect(recordsReadWithGrantReply.status.code).toBe(200);
                     }));
                     it('allows reads of protocol records with matching protocol grant scopes', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice writes a protocol record. Alice gives Bob a grant to read all records in the protocol
@@ -920,7 +1150,7 @@ export function testRecordsReadHandler() {
                             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 record which Bob will later try to read
                         const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -928,7 +1158,7 @@ export function testRecordsReadHandler() {
                             protocolPath: 'foo',
                         });
                         const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                        expect(recordsWriteReply.status.code).to.equal(202);
+                        expect(recordsWriteReply.status.code).toBe(202);
                         // Alice gives Bob a permission grant with scope RecordsRead
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -942,7 +1172,7 @@ export function testRecordsReadHandler() {
                         });
                         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 is unable to read the record without using the permission grant
                         const recordsReadWithoutGrant = yield RecordsRead.create({
                             filter: {
@@ -951,8 +1181,8 @@ export function testRecordsReadHandler() {
                             signer: Jws.createSigner(bob),
                         });
                         const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
-                        expect(recordsReadWithoutGrantReply.status.code).to.equal(401);
-                        expect(recordsReadWithoutGrantReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationActionRulesNotFound);
+                        expect(recordsReadWithoutGrantReply.status.code).toBe(401);
+                        expect(recordsReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionRulesNotFound);
                         // Bob is able to read the record when he uses the permission grant
                         const recordsReadWithGrant = yield RecordsRead.create({
                             filter: {
@@ -962,7 +1192,7 @@ export function testRecordsReadHandler() {
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
                         const recordsReadWithGrantReply = yield dwn.processMessage(alice.did, recordsReadWithGrant.message);
-                        expect(recordsReadWithGrantReply.status.code).to.equal(200);
+                        expect(recordsReadWithGrantReply.status.code).toBe(200);
                     }));
                     it('rejects reads of protocol records with mismatching protocol grant scopes', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice writes a protocol record. Alice gives Bob a grant to read a different protocol
@@ -976,7 +1206,7 @@ export function testRecordsReadHandler() {
                             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 record which Bob will later try to read
                         const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -984,7 +1214,7 @@ export function testRecordsReadHandler() {
                             protocolPath: 'foo',
                         });
                         const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                        expect(recordsWriteReply.status.code).to.equal(202);
+                        expect(recordsWriteReply.status.code).toBe(202);
                         // Alice gives Bob a permission grant with scope RecordsRead
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -998,7 +1228,7 @@ export function testRecordsReadHandler() {
                         });
                         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 is unable to read the record using the mismatched permission grant
                         const recordsReadWithoutGrant = yield RecordsRead.create({
                             filter: {
@@ -1008,8 +1238,8 @@ export function testRecordsReadHandler() {
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
                         const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
-                        expect(recordsReadWithoutGrantReply.status.code).to.equal(401);
-                        expect(recordsReadWithoutGrantReply.status.detail).to.contain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolMismatch);
+                        expect(recordsReadWithoutGrantReply.status.code).toBe(401);
+                        expect(recordsReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolMismatch);
                     }));
                     it('allows reads of records in the contextId specified in the grant', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice grants Bob access to RecordsRead records with a specific contextId.
@@ -1023,7 +1253,7 @@ export function testRecordsReadHandler() {
                             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 record which Bob will later try to read
                         const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1031,7 +1261,7 @@ export function testRecordsReadHandler() {
                             protocolPath: 'foo',
                         });
                         const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                        expect(recordsWriteReply.status.code).to.equal(202);
+                        expect(recordsWriteReply.status.code).toBe(202);
                         // Alice gives Bob a permission grant with scope RecordsRead
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -1046,7 +1276,7 @@ export function testRecordsReadHandler() {
                         });
                         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 is unable to read the record using the mismatched permission grant
                         const recordsReadWithoutGrant = yield RecordsRead.create({
                             filter: {
@@ -1056,7 +1286,7 @@ export function testRecordsReadHandler() {
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
                         const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
-                        expect(recordsReadWithoutGrantReply.status.code).to.equal(200);
+                        expect(recordsReadWithoutGrantReply.status.code).toBe(200);
                     }));
                     it('rejects reads of records in a different contextId than is specified in the grant', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice grants Bob access to RecordsRead records with a specific contextId.
@@ -1070,7 +1300,7 @@ export function testRecordsReadHandler() {
                             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 record which Bob will later try to read
                         const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1078,7 +1308,7 @@ export function testRecordsReadHandler() {
                             protocolPath: 'foo',
                         });
                         const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                        expect(recordsWriteReply.status.code).to.equal(202);
+                        expect(recordsWriteReply.status.code).toBe(202);
                         // Alice gives Bob a permission grant with scope RecordsRead
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -1093,7 +1323,7 @@ export function testRecordsReadHandler() {
                         });
                         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 is unable to read the record using the mismatched permission grant
                         const recordsReadWithoutGrant = yield RecordsRead.create({
                             filter: {
@@ -1103,8 +1333,8 @@ export function testRecordsReadHandler() {
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
                         const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
-                        expect(recordsReadWithoutGrantReply.status.code).to.equal(401);
-                        expect(recordsReadWithoutGrantReply.status.detail).to.contain(DwnErrorCode.RecordsGrantAuthorizationScopeContextIdMismatch);
+                        expect(recordsReadWithoutGrantReply.status.code).toBe(401);
+                        expect(recordsReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeContextIdMismatch);
                     }));
                     it('allows reads of records in the protocolPath specified in the grant', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice grants Bob access to RecordsRead records with a specific protocolPath.
@@ -1118,7 +1348,7 @@ export function testRecordsReadHandler() {
                             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 record which Bob will later try to read
                         const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1126,7 +1356,7 @@ export function testRecordsReadHandler() {
                             protocolPath: 'foo',
                         });
                         const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                        expect(recordsWriteReply.status.code).to.equal(202);
+                        expect(recordsWriteReply.status.code).toBe(202);
                         // Alice gives Bob a permission grant with scope RecordsRead
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -1141,7 +1371,7 @@ export function testRecordsReadHandler() {
                         });
                         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 is unable to read the record using the mismatched permission grant
                         const recordsReadWithoutGrant = yield RecordsRead.create({
                             filter: {
@@ -1151,7 +1381,7 @@ export function testRecordsReadHandler() {
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
                         const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
-                        expect(recordsReadWithoutGrantReply.status.code).to.equal(200);
+                        expect(recordsReadWithoutGrantReply.status.code).toBe(200);
                     }));
                     it('rejects reads of records in a different protocolPath than is specified in the grant', () => __awaiter(this, void 0, void 0, function* () {
                         // scenario: Alice grants Bob access to RecordsRead records with a specific protocolPath.
@@ -1165,7 +1395,7 @@ export function testRecordsReadHandler() {
                             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 record which Bob will later try to read
                         const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1173,7 +1403,7 @@ export function testRecordsReadHandler() {
                             protocolPath: 'foo',
                         });
                         const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                        expect(recordsWriteReply.status.code).to.equal(202);
+                        expect(recordsWriteReply.status.code).toBe(202);
                         // Alice gives Bob a permission grant with scope RecordsRead
                         const permissionGrant = yield PermissionsProtocol.createGrant({
                             signer: Jws.createSigner(alice),
@@ -1188,7 +1418,7 @@ export function testRecordsReadHandler() {
                         });
                         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 is unable to read the record using the mismatched permission grant
                         const recordsReadWithoutGrant = yield RecordsRead.create({
                             filter: {
@@ -1198,8 +1428,8 @@ export function testRecordsReadHandler() {
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
                         const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
-                        expect(recordsReadWithoutGrantReply.status.code).to.equal(401);
-                        expect(recordsReadWithoutGrantReply.status.detail).to.contain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolPathMismatch);
+                        expect(recordsReadWithoutGrantReply.status.code).toBe(401);
+                        expect(recordsReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolPathMismatch);
                     }));
                 });
             });
@@ -1212,7 +1442,7 @@ export function testRecordsReadHandler() {
                     signer: Jws.createSigner(alice)
                 });
                 const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                expect(readReply.status.code).to.equal(404);
+                expect(readReply.status.code).toBe(404);
             }));
             it('should return 404 RecordRead if data has been deleted', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -1220,22 +1450,22 @@ export function testRecordsReadHandler() {
                 // insert public data
                 const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice, published: true });
                 const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 // ensure data is inserted
                 const queryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: message.recordId }
                 });
                 const reply = yield dwn.processMessage(alice.did, queryData.message);
-                expect(reply.status.code).to.equal(200);
-                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+                expect(reply.status.code).toBe(200);
+                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
                 // RecordsDelete
                 const recordsDelete = yield RecordsDelete.create({
                     recordId: message.recordId,
                     signer: Jws.createSigner(alice)
                 });
                 const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                expect(deleteReply.status.code).to.equal(202);
+                expect(deleteReply.status.code).toBe(202);
                 // RecordsRead
                 const recordsRead = yield RecordsRead.create({
                     filter: {
@@ -1244,7 +1474,7 @@ export function testRecordsReadHandler() {
                     signer: Jws.createSigner(alice)
                 });
                 const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                expect(readReply.status.code).to.equal(404);
+                expect(readReply.status.code).toBe(404);
             }));
             it('should return 404 underlying data store cannot locate the data when data is above threshold', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1255,7 +1485,7 @@ export function testRecordsReadHandler() {
                     data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1)
                 });
                 const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 // testing RecordsRead
                 const recordsRead = yield RecordsRead.create({
                     filter: {
@@ -1264,7 +1494,7 @@ export function testRecordsReadHandler() {
                     signer: Jws.createSigner(alice)
                 });
                 const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                expect(readReply.status.code).to.equal(404);
+                expect(readReply.status.code).toBe(404);
             }));
             describe('data from encodedData', () => {
                 it('should not get data from DataStore if encodedData exists', () => __awaiter(this, void 0, void 0, function* () {
@@ -1275,7 +1505,7 @@ export function testRecordsReadHandler() {
                         data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded)
                     });
                     const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(writeReply.status.code).to.equal(202);
+                    expect(writeReply.status.code).toBe(202);
                     const recordRead = yield RecordsRead.create({
                         filter: {
                             recordId: message.recordId,
@@ -1284,12 +1514,12 @@ export function testRecordsReadHandler() {
                     });
                     const dataStoreGet = sinon.spy(dataStore, 'get');
                     const recordsReadResponse = yield dwn.processMessage(alice.did, recordRead.message);
-                    expect(recordsReadResponse.status.code).to.equal(200);
-                    expect(recordsReadResponse.entry.recordsWrite).to.exist;
-                    expect(recordsReadResponse.entry.data).to.exist;
+                    expect(recordsReadResponse.status.code).toBe(200);
+                    expect(recordsReadResponse.entry.recordsWrite).toBeDefined();
+                    expect(recordsReadResponse.entry.data).toBeDefined();
                     sinon.assert.notCalled(dataStoreGet);
                     const readData = yield DataStream.toBytes(recordsReadResponse.entry.data);
-                    expect(readData).to.eql(dataBytes);
+                    expect(readData).toEqual(dataBytes);
                 }));
                 it('should get data from DataStore if encodedData does not exist', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1299,7 +1529,7 @@ export function testRecordsReadHandler() {
                         data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1)
                     });
                     const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(writeReply.status.code).to.equal(202);
+                    expect(writeReply.status.code).toBe(202);
                     const recordRead = yield RecordsRead.create({
                         filter: {
                             recordId: message.recordId,
@@ -1308,12 +1538,12 @@ export function testRecordsReadHandler() {
                     });
                     const dataStoreGet = sinon.spy(dataStore, 'get');
                     const recordsReadResponse = yield dwn.processMessage(alice.did, recordRead.message);
-                    expect(recordsReadResponse.status.code).to.equal(200);
-                    expect(recordsReadResponse.entry.recordsWrite).to.exist;
-                    expect(recordsReadResponse.entry.data).to.exist;
+                    expect(recordsReadResponse.status.code).toBe(200);
+                    expect(recordsReadResponse.entry.recordsWrite).toBeDefined();
+                    expect(recordsReadResponse.entry.data).toBeDefined();
                     sinon.assert.calledOnce(dataStoreGet);
                     const readData = yield DataStream.toBytes(recordsReadResponse.entry.data);
-                    expect(readData).to.eql(dataBytes);
+                    expect(readData).toEqual(dataBytes);
                 }));
             });
             describe('encryption scenarios', () => {
@@ -1328,7 +1558,7 @@ export function testRecordsReadHandler() {
                     const dataEncryptionKey = TestDataGenerator.randomBytes(32);
                     const encryptedDataStream = yield Encryption.aes256CtrEncrypt(dataEncryptionKey, dataEncryptionInitializationVector, originalDataStream);
                     const encryptedDataBytes = yield DataStream.toBytes(encryptedDataStream);
-                    // TODO: #450 - Should not require a root key to specify the derivation scheme (https://github.com/TBD54566975/dwn-sdk-js/issues/450)
+                    // TODO: #450 - Should not require a root key to specify the derivation scheme (https://github.com/enboxorg/enbox/issues/450)
                     const rootPrivateKeyWithSchemasScheme = {
                         rootKeyId: alice.keyId,
                         derivationScheme: KeyDerivationScheme.Schemas,
@@ -1368,7 +1598,7 @@ export function testRecordsReadHandler() {
                         encryptionInput
                     });
                     const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(writeReply.status.code).to.equal(202);
+                    expect(writeReply.status.code).toBe(202);
                     const recordsRead = yield RecordsRead.create({
                         filter: {
                             recordId: message.recordId,
@@ -1377,26 +1607,26 @@ export function testRecordsReadHandler() {
                     });
                     // test able to derive correct key using `schemas` scheme from root key to decrypt the message
                     const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                    expect(readReply.status.code).to.equal(200);
+                    expect(readReply.status.code).toBe(200);
                     const recordsWriteMessage = readReply.entry.recordsWrite;
                     const cipherStream = readReply.entry.data;
                     const plaintextDataStream = yield Records.decrypt(recordsWriteMessage, schemaDerivedPrivateKey, cipherStream);
                     const plaintextBytes = yield DataStream.toBytes(plaintextDataStream);
-                    expect(ArrayUtility.byteArraysEqual(plaintextBytes, originalData)).to.be.true;
+                    expect(ArrayUtility.byteArraysEqual(plaintextBytes, originalData)).toBe(true);
                     // test able to derive correct key using `dataFormat` scheme from root key to decrypt the message
                     const readReply2 = yield dwn.processMessage(alice.did, recordsRead.message); // send the same read message to get a new cipher stream
-                    expect(readReply2.status.code).to.equal(200);
+                    expect(readReply2.status.code).toBe(200);
                     const cipherStream2 = readReply2.entry.data;
                     const plaintextDataStream2 = yield Records.decrypt(recordsWriteMessage, rootPrivateKeyWithDataFormatsScheme, cipherStream2);
                     const plaintextBytes2 = yield DataStream.toBytes(plaintextDataStream2);
-                    expect(ArrayUtility.byteArraysEqual(plaintextBytes2, originalData)).to.be.true;
+                    expect(ArrayUtility.byteArraysEqual(plaintextBytes2, originalData)).toBe(true);
                     // test unable to decrypt the message if dataFormat-derived key is derived without taking `schema` as input to derivation path
                     const readReply3 = yield dwn.processMessage(alice.did, recordsRead.message); // process the same read message to get a new cipher stream
-                    expect(readReply3.status.code).to.equal(200);
+                    expect(readReply3.status.code).toBe(200);
                     const cipherStream3 = readReply3.entry.data;
                     const invalidDerivationPath = [KeyDerivationScheme.DataFormats, message.descriptor.dataFormat];
                     const inValidDescendantPrivateKey = yield HdKey.derivePrivateKey(rootPrivateKeyWithDataFormatsScheme, invalidDerivationPath);
-                    yield expect(Records.decrypt(recordsWriteMessage, inValidDescendantPrivateKey, cipherStream3)).to.be.rejectedWith(DwnErrorCode.RecordsInvalidAncestorKeyDerivationSegment);
+                    yield expect(Records.decrypt(recordsWriteMessage, inValidDescendantPrivateKey, cipherStream3)).rejects.toThrow(DwnErrorCode.RecordsInvalidAncestorKeyDerivationSegment);
                 }));
                 it('should be able to decrypt flat-space schema-less record with the correct derived key', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Alice writes into her own DWN an encrypted record and she is able to decrypt it
@@ -1409,7 +1639,7 @@ export function testRecordsReadHandler() {
                     const dataEncryptionKey = TestDataGenerator.randomBytes(32);
                     const encryptedDataStream = yield Encryption.aes256CtrEncrypt(dataEncryptionKey, dataEncryptionInitializationVector, originalDataStream);
                     const encryptedDataBytes = yield DataStream.toBytes(encryptedDataStream);
-                    // TODO: #450 - Should not require a root key to specify the derivation scheme (https://github.com/TBD54566975/dwn-sdk-js/issues/450)
+                    // TODO: #450 - Should not require a root key to specify the derivation scheme (https://github.com/enboxorg/enbox/issues/450)
                     const rootPrivateKeyWithDataFormatsScheme = {
                         rootKeyId: alice.keyId,
                         derivationScheme: KeyDerivationScheme.DataFormats,
@@ -1435,7 +1665,7 @@ export function testRecordsReadHandler() {
                     });
                     const dataStream = DataStream.fromBytes(encryptedDataBytes);
                     const writeReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                    expect(writeReply.status.code).to.equal(202);
+                    expect(writeReply.status.code).toBe(202);
                     const recordsRead = yield RecordsRead.create({
                         filter: {
                             recordId: recordsWrite.message.recordId,
@@ -1444,12 +1674,12 @@ export function testRecordsReadHandler() {
                     });
                     // test able to derive correct key using `dataFormat` scheme from root key to decrypt the message
                     const readReply = yield dwn.processMessage(alice.did, recordsRead.message); // send the same read message to get a new cipher stream
-                    expect(readReply.status.code).to.equal(200);
+                    expect(readReply.status.code).toBe(200);
                     const cipherStream = readReply.entry.data;
                     const recordsWriteMessage = readReply.entry.recordsWrite;
                     const plaintextDataStream = yield Records.decrypt(recordsWriteMessage, rootPrivateKeyWithDataFormatsScheme, cipherStream);
                     const plaintextBytes = yield DataStream.toBytes(plaintextDataStream);
-                    expect(ArrayUtility.byteArraysEqual(plaintextBytes, originalData)).to.be.true;
+                    expect(ArrayUtility.byteArraysEqual(plaintextBytes, originalData)).toBe(true);
                 }));
                 it('should only be able to decrypt record with a correct derived private key  - `protocol-context` derivation scheme', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Bob initiated an encrypted chat thread with Alice,
@@ -1466,7 +1696,7 @@ export function testRecordsReadHandler() {
                         protocolDefinition: protocolDefinitionForAlice
                     });
                     const protocolsConfigureForAliceReply = yield dwn.processMessage(alice.did, protocolsConfigureForAlice.message);
-                    expect(protocolsConfigureForAliceReply.status.code).to.equal(202);
+                    expect(protocolsConfigureForAliceReply.status.code).toBe(202);
                     // Bob configures chat protocol with encryption
                     const protocolDefinitionForBob = yield Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, bob.keyId, bob.keyPair.privateJwk);
                     const protocolsConfigureForBob = yield TestDataGenerator.generateProtocolsConfigure({
@@ -1474,7 +1704,7 @@ export function testRecordsReadHandler() {
                         protocolDefinition: protocolDefinitionForBob
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(bob.did, protocolsConfigureForBob.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // Bob queries for Alice's chat protocol definition
                     const protocolsQuery = yield ProtocolsQuery.create({
                         filter: { protocol: chatProtocolDefinition.protocol }
@@ -1484,7 +1714,7 @@ export function testRecordsReadHandler() {
                     // Bob verifies that the chat protocol definition is authored by Alice
                     yield authenticate(protocolsConfigureMessageReceived.authorization, didResolver);
                     const protocolsConfigureFetched = yield ProtocolsConfigure.parse(protocolsConfigureMessageReceived);
-                    expect(protocolsConfigureFetched.author).to.equal(alice.did);
+                    expect(protocolsConfigureFetched.author).toBe(alice.did);
                     // Bob creates an initiating a chat thread RecordsWrite
                     const plaintextMessageToAlice = TestDataGenerator.randomBytes(100);
                     const { message: threadMessage, dataStream, recordsWrite, encryptedDataBytes, encryptionInput } = yield TestDataGenerator.generateProtocolEncryptedRecordsWrite({
@@ -1497,7 +1727,7 @@ export function testRecordsReadHandler() {
                     });
                     // Bob writes the encrypted chat thread to Alice's DWN
                     const bobToAliceWriteReply = yield dwn.processMessage(alice.did, threadMessage, { dataStream });
-                    expect(bobToAliceWriteReply.status.code).to.equal(202);
+                    expect(bobToAliceWriteReply.status.code).toBe(202);
                     // Bob also needs to write the same encrypted chat thread to his own DWN
                     // Opportunity here to create a much nicer utility method for this entire block
                     const bobToBobRecordsWrite = yield RecordsWrite.createFrom({
@@ -1523,7 +1753,7 @@ export function testRecordsReadHandler() {
                     yield bobToBobRecordsWrite.sign({ signer: Jws.createSigner(bob) });
                     const dataStreamForBobsDwn = DataStream.fromBytes(encryptedDataBytes);
                     const bobToBobWriteReply = yield dwn.processMessage(bob.did, bobToBobRecordsWrite.message, { dataStream: dataStreamForBobsDwn });
-                    expect(bobToBobWriteReply.status.code).to.equal(202);
+                    expect(bobToBobWriteReply.status.code).toBe(202);
                     // NOTE: we know Alice is able to decrypt the message using protocol-path derived key through other tests, so we won't verify it again
                     // test that anyone with the protocol-context derived private key is able to decrypt the message
                     const recordsRead = yield RecordsRead.create({
@@ -1533,14 +1763,14 @@ export function testRecordsReadHandler() {
                         signer: Jws.createSigner(alice)
                     });
                     const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                    expect(readReply.status.code).to.equal(200);
+                    expect(readReply.status.code).toBe(200);
                     const fetchedRecordsWrite = readReply.entry.recordsWrite;
                     const cipherStream = readReply.entry.data;
                     const derivationPathFromReadContext = Records.constructKeyDerivationPathUsingProtocolContextScheme(fetchedRecordsWrite.contextId);
                     const protocolContextDerivedPrivateJwk = yield HdKey.derivePrivateKey(bobRootPrivateKey, derivationPathFromReadContext);
                     const plaintextDataStream = yield Records.decrypt(fetchedRecordsWrite, protocolContextDerivedPrivateJwk, cipherStream);
                     const plaintextBytes = yield DataStream.toBytes(plaintextDataStream);
-                    expect(ArrayUtility.byteArraysEqual(plaintextBytes, plaintextMessageToAlice)).to.be.true;
+                    expect(ArrayUtility.byteArraysEqual(plaintextBytes, plaintextMessageToAlice)).toBe(true);
                     // verify that Alice is able to send an encrypted message using the protocol-context derived public key and Bob is able to decrypt it
                     // NOTE: we will skip verification of Bob's protocol configuration because we have test the such scenario above as well as in other tests
                     const { derivedPublicKey: protocolContextDerivedPublicJwkReturned, rootKeyId: protocolContextDerivingRootKeyIdReturned } = fetchedRecordsWrite.encryption.keyEncryption.find(encryptedKey => encryptedKey.derivationScheme === KeyDerivationScheme.ProtocolContext);
@@ -1552,13 +1782,13 @@ export function testRecordsReadHandler() {
                         protocolPath: 'thread/message',
                         protocolParentContextId: fetchedRecordsWrite.contextId,
                         protocolContextDerivingRootKeyId: protocolContextDerivingRootKeyIdReturned,
-                        protocolContextDerivedPublicJwk: protocolContextDerivedPublicJwkReturned,
+                        protocolContextDerivedPublicKeyJwk: protocolContextDerivedPublicJwkReturned,
                         encryptSymmetricKeyWithProtocolPathDerivedKey: true,
                         encryptSymmetricKeyWithProtocolContextDerivedKey: true
                     });
                     // Alice sends the message to Bob
                     const aliceWriteReply = yield dwn.processMessage(bob.did, recordsWriteToBob.message, { dataStream: recordsWriteToBob.dataStream });
-                    expect(aliceWriteReply.status.code).to.equal(202);
+                    expect(aliceWriteReply.status.code).toBe(202);
                     // test that Bob is able to read and decrypt Alice's message
                     const recordsReadByBob = yield RecordsRead.create({
                         filter: {
@@ -1567,12 +1797,12 @@ export function testRecordsReadHandler() {
                         signer: Jws.createSigner(bob)
                     });
                     const readByBobReply = yield dwn.processMessage(bob.did, recordsReadByBob.message);
-                    expect(readByBobReply.status.code).to.equal(200);
+                    expect(readByBobReply.status.code).toBe(200);
                     const fetchedRecordsWrite2 = readByBobReply.entry.recordsWrite;
                     const cipherStream2 = readByBobReply.entry.data;
                     const plaintextDataStream2 = yield Records.decrypt(fetchedRecordsWrite2, protocolContextDerivedPrivateJwk, cipherStream2);
                     const plaintextBytes2 = yield DataStream.toBytes(plaintextDataStream2);
-                    expect(ArrayUtility.byteArraysEqual(plaintextBytes2, plaintextMessageToBob)).to.be.true;
+                    expect(ArrayUtility.byteArraysEqual(plaintextBytes2, plaintextMessageToBob)).toBe(true);
                 }));
                 it('should only be able to decrypt record with a correct derived private key  - `protocols` derivation scheme', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Bob writes into Alice's DWN an encrypted "email", alice is able to decrypt it
@@ -1589,7 +1819,7 @@ export function testRecordsReadHandler() {
                         protocolDefinition: encryptedProtocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigure.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // Bob queries for Alice's email protocol definition
                     const protocolsQuery = yield ProtocolsQuery.create({
                         filter: { protocol: emailProtocolDefinition.protocol }
@@ -1599,7 +1829,7 @@ export function testRecordsReadHandler() {
                     // Bob verifies that the email protocol definition is authored by Alice
                     yield authenticate(protocolsConfigureMessageReceived.authorization, didResolver);
                     const protocolsConfigureFetched = yield ProtocolsConfigure.parse(protocolsConfigureMessageReceived);
-                    expect(protocolsConfigureFetched.author).to.equal(alice.did);
+                    expect(protocolsConfigureFetched.author).toBe(alice.did);
                     // Bob encrypts his email to Alice with a randomly generated symmetric key
                     const bobMessageBytes = TestDataGenerator.randomBytes(100);
                     const bobMessageStream = DataStream.fromBytes(bobMessageBytes);
@@ -1610,7 +1840,7 @@ export function testRecordsReadHandler() {
                     // Bob generates an encrypted RecordsWrite,
                     // the public encryption key designated by Alice is used to encrypt the symmetric key Bob generated above
                     const publicJwk = (_a = protocolsConfigureFetched.message.descriptor.definition.structure.email.$encryption) === null || _a === void 0 ? void 0 : _a.publicKeyJwk;
-                    expect(publicJwk).to.not.be.undefined;
+                    expect(publicJwk).toBeDefined();
                     const encryptionInput = {
                         initializationVector: dataEncryptionInitializationVector,
                         key: dataEncryptionKey,
@@ -1631,7 +1861,7 @@ export function testRecordsReadHandler() {
                     });
                     // Bob writes the encrypted email to Alice's DWN
                     const bobWriteReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                    expect(bobWriteReply.status.code).to.equal(202);
+                    expect(bobWriteReply.status.code).toBe(202);
                     // Alice reads the encrypted email
                     // assume Alice already made query to get the `recordId` of the email
                     const recordsRead = yield RecordsRead.create({
@@ -1641,7 +1871,7 @@ export function testRecordsReadHandler() {
                         signer: Jws.createSigner(alice)
                     });
                     const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
-                    expect(readReply.status.code).to.equal(200);
+                    expect(readReply.status.code).toBe(200);
                     // test that Alice is able decrypt the encrypted email from Bob using the root key
                     const rootPrivateKey = {
                         rootKeyId: alice.keyId,
@@ -1652,35 +1882,35 @@ export function testRecordsReadHandler() {
                     const cipherStream = readReply.entry.data;
                     const plaintextDataStream = yield Records.decrypt(fetchedRecordsWrite, rootPrivateKey, cipherStream);
                     const plaintextBytes = yield DataStream.toBytes(plaintextDataStream);
-                    expect(ArrayUtility.byteArraysEqual(plaintextBytes, bobMessageBytes)).to.be.true;
+                    expect(ArrayUtility.byteArraysEqual(plaintextBytes, bobMessageBytes)).toBe(true);
                     // test that a correct derived key is able decrypt the encrypted email from Bob
                     const readReply2 = yield dwn.processMessage(alice.did, recordsRead.message);
-                    expect(readReply2.status.code).to.equal(200);
+                    expect(readReply2.status.code).toBe(200);
                     const relativeDescendantDerivationPath = Records.constructKeyDerivationPath(KeyDerivationScheme.ProtocolPath, fetchedRecordsWrite);
                     const derivedPrivateKey = yield HdKey.derivePrivateKey(rootPrivateKey, relativeDescendantDerivationPath);
                     const fetchedRecordsWrite2 = readReply2.entry.recordsWrite;
                     const cipherStream2 = readReply2.entry.data;
                     const plaintextDataStream2 = yield Records.decrypt(fetchedRecordsWrite2, derivedPrivateKey, cipherStream2);
                     const plaintextBytes2 = yield DataStream.toBytes(plaintextDataStream2);
-                    expect(ArrayUtility.byteArraysEqual(plaintextBytes2, bobMessageBytes)).to.be.true;
+                    expect(ArrayUtility.byteArraysEqual(plaintextBytes2, bobMessageBytes)).toBe(true);
                     // test unable to decrypt the message if derived key has an unexpected path
                     const invalidDerivationPath = [KeyDerivationScheme.ProtocolPath, protocolDefinition.protocol, 'invalidContextId'];
                     const inValidDescendantPrivateKey = yield HdKey.derivePrivateKey(rootPrivateKey, invalidDerivationPath);
-                    yield expect(Records.decrypt(fetchedRecordsWrite, inValidDescendantPrivateKey, cipherStream)).to.be.rejectedWith(DwnErrorCode.RecordsInvalidAncestorKeyDerivationSegment);
+                    yield expect(Records.decrypt(fetchedRecordsWrite, inValidDescendantPrivateKey, cipherStream)).rejects.toThrow(DwnErrorCode.RecordsInvalidAncestorKeyDerivationSegment);
                     // test unable to decrypt the message if no derivation scheme used by the message matches the scheme used by the given private key
                     const privateKeyWithMismatchingDerivationScheme = {
                         rootKeyId: alice.keyId,
                         derivationScheme: 'scheme-that-is-not-protocol-context',
                         derivedPrivateKey: alice.keyPair.privateJwk
                     };
-                    yield expect(Records.decrypt(fetchedRecordsWrite, privateKeyWithMismatchingDerivationScheme, cipherStream)).to.be.rejectedWith(DwnErrorCode.RecordsDecryptNoMatchingKeyEncryptedFound);
+                    yield expect(Records.decrypt(fetchedRecordsWrite, privateKeyWithMismatchingDerivationScheme, cipherStream)).rejects.toThrow(DwnErrorCode.RecordsDecryptNoMatchingKeyEncryptedFound);
                     // test unable to decrypt the message if public key ID does not match the derived private key
                     const privateKeyWithMismatchingKeyId = {
                         rootKeyId: 'mismatchingKeyId',
                         derivationScheme: KeyDerivationScheme.ProtocolPath,
                         derivedPrivateKey: alice.keyPair.privateJwk
                     };
-                    yield expect(Records.decrypt(fetchedRecordsWrite, privateKeyWithMismatchingKeyId, cipherStream)).to.be.rejectedWith(DwnErrorCode.RecordsDecryptNoMatchingKeyEncryptedFound);
+                    yield expect(Records.decrypt(fetchedRecordsWrite, privateKeyWithMismatchingKeyId, cipherStream)).rejects.toThrow(DwnErrorCode.RecordsDecryptNoMatchingKeyEncryptedFound);
                 }));
             });
         });
@@ -1700,7 +1930,7 @@ export function testRecordsReadHandler() {
             const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
             const recordsReadHandler = new RecordsReadHandler(didResolver, messageStoreStub, dataStoreStub);
             const reply = yield recordsReadHandler.handle({ tenant: alice.did, message: recordsRead.message });
-            expect(reply.status.code).to.equal(401);
+            expect(reply.status.code).toBe(401);
         }));
         it('should return 400 if fail parsing the message', () => __awaiter(this, void 0, void 0, function* () {
             const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -1717,7 +1947,7 @@ export function testRecordsReadHandler() {
             // stub the `parse()` function to throw an error
             sinon.stub(RecordsRead, 'parse').throws('anyError');
             const reply = yield recordsReadHandler.handle({ tenant: alice.did, message: recordsRead.message });
-            expect(reply.status.code).to.equal(400);
+            expect(reply.status.code).toBe(400);
         }));
     });
 }