@enbox/dwn-sdk-js 0.0.2 → 0.0.4

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

@@ -14,13 +14,12 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
-import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
-import chai, { expect } from 'chai';
-import freeForAll from '../vectors/protocol-definitions/free-for-all.json' assert { type: 'json' };
-import friendRoleProtocolDefinition from '../vectors/protocol-definitions/friend-role.json' assert { type: 'json' };
-import nestedProtocol from '../vectors/protocol-definitions/nested.json' assert { type: 'json' };
-import threadRoleProtocolDefinition from '../vectors/protocol-definitions/thread-role.json' assert { type: 'json' };
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
+import freeForAll from '../vectors/protocol-definitions/free-for-all.json' with { type: 'json' };
+import friendRoleProtocolDefinition from '../vectors/protocol-definitions/friend-role.json' with { type: 'json' };
+import nestedProtocol from '../vectors/protocol-definitions/nested.json' with { type: 'json' };
+import threadRoleProtocolDefinition from '../vectors/protocol-definitions/thread-role.json' with { type: 'json' };
 import { ArrayUtility } from '../../src/utils/array.js';
 import { DateSort } from '../../src/types/records-types.js';
 import { DwnConstant } from '../../src/core/dwn-constant.js';
@@ -37,7 +36,6 @@ import { TestStores } from '../test-stores.js';
 import { TestStubGenerator } from '../utils/test-stub-generator.js';
 import { DataStoreLevel, Dwn, MessageStoreLevel, RecordsWrite, Time } from '../../src/index.js';
 import { DidKey, UniversalResolver } from '@enbox/dids';
-chai.use(chaiAsPromised);
 export function testRecordsQueryHandler() {
     describe('RecordsQueryHandler.handle()', () => {
         beforeEach(() => {
@@ -48,29 +46,29 @@ export function testRecordsQueryHandler() {
             let messageStore;
             let dataStore;
             let resumableTaskStore;
-            let eventLog;
+            let stateIndex;
             let eventStream;
             let dwn;
             // 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 reject when published is set to false with a dateSort set to sorting by `PublishedAscending` or `PublishedDescending`', () => __awaiter(this, void 0, void 0, function* () {
@@ -79,17 +77,17 @@ export function testRecordsQueryHandler() {
                 const query = yield TestDataGenerator.generateRecordsQuery({ author: alice, filter: { published: false } });
                 //control
                 let reply = yield dwn.processMessage(alice.did, query.message);
-                expect(reply.status.code).to.equal(200);
+                expect(reply.status.code).toBe(200);
                 // modify dateSort to publishedAscending
                 query.message.descriptor.dateSort = DateSort.PublishedAscending;
                 reply = yield dwn.processMessage(alice.did, query.message);
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.include('queries must not filter for `published:false` and sort');
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain('queries must not filter for `published:false` and sort');
                 // modify dateSort to publishedDescending
                 query.message.descriptor.dateSort = DateSort.PublishedDescending;
                 reply = yield dwn.processMessage(alice.did, query.message);
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.include('queries must not filter for `published:false` and sort');
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain('queries must not filter for `published:false` and sort');
             }));
             it('should return recordId, descriptor, authorization and attestation', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -99,15 +97,15 @@ export function testRecordsQueryHandler() {
                 const dataFormat = 'myAwesomeDataFormat';
                 const write = yield TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [bob], dataFormat });
                 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);
                 const query = yield TestDataGenerator.generateRecordsQuery({ author: alice, filter: { dataFormat } });
                 const reply = yield dwn.processMessage(alice.did, query.message);
-                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
                 const entry = reply.entries[0];
-                expect(entry.authorization).to.deep.equal(write.message.authorization);
-                expect(entry.attestation).to.deep.equal(write.message.attestation);
-                expect(entry.descriptor).to.deep.equal(write.message.descriptor);
-                expect(entry.recordId).to.equal(write.message.recordId);
+                expect(entry.authorization).toEqual(write.message.authorization);
+                expect(entry.attestation).toEqual(write.message.attestation);
+                expect(entry.descriptor).toEqual(write.message.descriptor);
+                expect(entry.recordId).toBe(write.message.recordId);
             }));
             it('should return records matching the query', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
@@ -125,14 +123,14 @@ export function testRecordsQueryHandler() {
                 const writeReply1 = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
                 const writeReply2 = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
                 const writeReply3 = yield dwn.processMessage(alice.did, write3.message, { dataStream: write3.dataStream });
-                expect(writeReply1.status.code).to.equal(202);
-                expect(writeReply2.status.code).to.equal(202);
-                expect(writeReply3.status.code).to.equal(202);
+                expect(writeReply1.status.code).toBe(202);
+                expect(writeReply2.status.code).toBe(202);
+                expect(writeReply3.status.code).toBe(202);
                 // testing singular conditional query
                 const messageData = yield TestDataGenerator.generateRecordsQuery({ author: alice, filter: { dataFormat } });
                 const reply = yield dwn.processMessage(alice.did, messageData.message);
-                expect(reply.status.code).to.equal(200);
-                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(2); // only 2 entries should match the query on protocol
+                expect(reply.status.code).toBe(200);
+                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2); // only 2 entries should match the query on protocol
                 // testing multi-conditional query, reuse data generated above for bob
                 const messageData2 = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -142,8 +140,8 @@ export function testRecordsQueryHandler() {
                     }
                 });
                 const reply2 = yield dwn.processMessage(alice.did, messageData2.message);
-                expect(reply2.status.code).to.equal(200);
-                expect((_b = reply2.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1); // only 1 entry should match the query
+                expect(reply2.status.code).toBe(200);
+                expect((_b = reply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1); // only 1 entry should match the query
             }));
             it('should return `encodedData` if data size is within the spec threshold', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -151,12 +149,12 @@ export function testRecordsQueryHandler() {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 const write = yield TestDataGenerator.generateRecordsWrite({ author: alice, data });
                 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);
                 const messageData = yield TestDataGenerator.generateRecordsQuery({ author: alice, filter: { recordId: write.message.recordId } });
                 const reply = yield dwn.processMessage(alice.did, messageData.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.entries[0].encodedData).to.equal(Encoder.bytesToBase64Url(data));
+                expect(reply.status.code).toBe(200);
+                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(reply.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(data));
             }));
             it('should not return `encodedData` if data size is greater then spec threshold', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -164,30 +162,30 @@ export function testRecordsQueryHandler() {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 const write = yield TestDataGenerator.generateRecordsWrite({ author: alice, data });
                 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);
                 const messageData = yield TestDataGenerator.generateRecordsQuery({ author: alice, filter: { recordId: write.message.recordId } });
                 const reply = yield dwn.processMessage(alice.did, messageData.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.entries[0].encodedData).to.be.undefined;
+                expect(reply.status.code).toBe(200);
+                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(reply.entries[0].encodedData).toBeUndefined();
             }));
             it('should include `initialWrite` property if RecordsWrite is not initial write', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
                 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 TestDataGenerator.generateRecordsQuery({ author: alice, filter: { recordId: write.message.recordId } });
                 const reply = yield dwn.processMessage(alice.did, messageData.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.entries[0].initialWrite).to.exist;
-                expect((_b = reply.entries[0].initialWrite) === null || _b === void 0 ? void 0 : _b.recordId).to.equal(write.message.recordId);
+                expect(reply.status.code).toBe(200);
+                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(reply.entries[0].initialWrite).toBeDefined();
+                expect((_b = reply.entries[0].initialWrite) === null || _b === void 0 ? void 0 : _b.recordId).toBe(write.message.recordId);
             }));
             it('should be able to query by attester', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c;
@@ -199,28 +197,28 @@ export function testRecordsQueryHandler() {
                 // insert data
                 const writeReply1 = yield dwn.processMessage(alice.did, recordsWrite1.message, { dataStream: recordsWrite1.dataStream });
                 const writeReply2 = yield dwn.processMessage(alice.did, recordsWrite2.message, { dataStream: recordsWrite2.dataStream });
-                expect(writeReply1.status.code).to.equal(202);
-                expect(writeReply2.status.code).to.equal(202);
+                expect(writeReply1.status.code).toBe(202);
+                expect(writeReply2.status.code).toBe(202);
                 // testing attester filter
                 const recordsQuery1 = yield TestDataGenerator.generateRecordsQuery({ author: alice, filter: { attester: alice.did } });
                 const reply1 = yield dwn.processMessage(alice.did, recordsQuery1.message);
-                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
                 const reply1Attester = Jws.getSignerDid(reply1.entries[0].attestation.signatures[0]);
-                expect(reply1Attester).to.equal(alice.did);
+                expect(reply1Attester).toBe(alice.did);
                 // testing attester + another filter
                 const recordsQuery2 = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { attester: bob.did, schema: recordsWrite2.message.descriptor.schema }
                 });
                 const reply2 = yield dwn.processMessage(alice.did, recordsQuery2.message);
-                expect((_b = reply2.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
+                expect((_b = reply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
                 const reply2Attester = Jws.getSignerDid(reply2.entries[0].attestation.signatures[0]);
-                expect(reply2Attester).to.equal(bob.did);
+                expect(reply2Attester).toBe(bob.did);
                 // testing attester filter that yields no results
                 const carol = yield TestDataGenerator.generateDidKeyPersona();
                 const recordsQuery3 = yield TestDataGenerator.generateRecordsQuery({ author: alice, filter: { attester: carol.did } });
                 const reply3 = yield dwn.processMessage(alice.did, recordsQuery3.message);
-                expect((_c = reply3.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(0);
+                expect((_c = reply3.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(0);
             }));
             it('should be able to query by author', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c, _d;
@@ -234,7 +232,7 @@ export function testRecordsQueryHandler() {
                     protocolDefinition
                 });
                 const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                expect(protocolsConfigureReply.status.code).to.equal(202);
+                expect(protocolsConfigureReply.status.code).toBe(202);
                 const aliceAuthorWrite = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: protocolDefinition.protocol,
@@ -243,7 +241,7 @@ export function testRecordsQueryHandler() {
                     protocolPath: 'post'
                 });
                 const aliceAuthorReply = yield dwn.processMessage(alice.did, aliceAuthorWrite.message, { dataStream: aliceAuthorWrite.dataStream });
-                expect(aliceAuthorReply.status.code).to.equal(202);
+                expect(aliceAuthorReply.status.code).toBe(202);
                 const bobAuthorWrite = yield TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     protocol: protocolDefinition.protocol,
@@ -252,7 +250,7 @@ export function testRecordsQueryHandler() {
                     protocolPath: 'post'
                 });
                 const bobAuthorReply = yield dwn.processMessage(alice.did, bobAuthorWrite.message, { dataStream: bobAuthorWrite.dataStream });
-                expect(bobAuthorReply.status.code).to.equal(202);
+                expect(bobAuthorReply.status.code).toBe(202);
                 // alice queries with an empty filter, gets both
                 let recordsQuery = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -264,8 +262,8 @@ export function testRecordsQueryHandler() {
                     }
                 });
                 let queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(queryReply.status.code).to.equal(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(2);
+                expect(queryReply.status.code).toBe(200);
+                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
                 // filter for bob as author
                 recordsQuery = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -278,9 +276,9 @@ export function testRecordsQueryHandler() {
                     }
                 });
                 queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(queryReply.status.code).to.equal(200);
-                expect((_b = queryReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-                expect(queryReply.entries[0].recordId).to.equal(bobAuthorWrite.message.recordId);
+                expect(queryReply.status.code).toBe(200);
+                expect((_b = queryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(queryReply.entries[0].recordId).toBe(bobAuthorWrite.message.recordId);
                 // empty array for author should return all same as undefined author field
                 recordsQuery = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -293,8 +291,8 @@ export function testRecordsQueryHandler() {
                     }
                 });
                 queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(queryReply.status.code).to.equal(200);
-                expect((_c = queryReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(2);
+                expect(queryReply.status.code).toBe(200);
+                expect((_c = queryReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(2);
                 // query for both authors explicitly
                 recordsQuery = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -307,8 +305,8 @@ export function testRecordsQueryHandler() {
                     }
                 });
                 queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(queryReply.status.code).to.equal(200);
-                expect((_d = queryReply.entries) === null || _d === void 0 ? void 0 : _d.length).to.equal(2);
+                expect(queryReply.status.code).toBe(200);
+                expect((_d = queryReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(2);
             }));
             it('should be able to query by recipient', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c, _d, _e;
@@ -323,7 +321,7 @@ export function testRecordsQueryHandler() {
                     protocolDefinition
                 });
                 const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                expect(protocolsConfigureReply.status.code).to.equal(202);
+                expect(protocolsConfigureReply.status.code).toBe(202);
                 const aliceToBob = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: bob.did,
@@ -333,7 +331,7 @@ export function testRecordsQueryHandler() {
                     protocolPath: 'post'
                 });
                 const aliceToBobReply = yield dwn.processMessage(alice.did, aliceToBob.message, { dataStream: aliceToBob.dataStream });
-                expect(aliceToBobReply.status.code).to.equal(202);
+                expect(aliceToBobReply.status.code).toBe(202);
                 const aliceToCarol = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: carol.did,
@@ -343,7 +341,7 @@ export function testRecordsQueryHandler() {
                     protocolPath: 'post'
                 });
                 const aliceToCarolReply = yield dwn.processMessage(alice.did, aliceToCarol.message, { dataStream: aliceToCarol.dataStream });
-                expect(aliceToCarolReply.status.code).to.equal(202);
+                expect(aliceToCarolReply.status.code).toBe(202);
                 // alice queries with an empty filter, gets both
                 let recordsQuery = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -355,8 +353,8 @@ export function testRecordsQueryHandler() {
                     }
                 });
                 let queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(queryReply.status.code).to.equal(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(2);
+                expect(queryReply.status.code).toBe(200);
+                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
                 // filter for bob as recipient
                 recordsQuery = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -369,9 +367,9 @@ export function testRecordsQueryHandler() {
                     }
                 });
                 queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(queryReply.status.code).to.equal(200);
-                expect((_b = queryReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-                expect(queryReply.entries[0].recordId).to.equal(aliceToBob.message.recordId);
+                expect(queryReply.status.code).toBe(200);
+                expect((_b = queryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(queryReply.entries[0].recordId).toBe(aliceToBob.message.recordId);
                 // filter for carol as recipient
                 recordsQuery = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -384,9 +382,9 @@ export function testRecordsQueryHandler() {
                     }
                 });
                 queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(queryReply.status.code).to.equal(200);
-                expect((_c = queryReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(1);
-                expect(queryReply.entries[0].recordId).to.equal(aliceToCarol.message.recordId);
+                expect(queryReply.status.code).toBe(200);
+                expect((_c = queryReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
+                expect(queryReply.entries[0].recordId).toBe(aliceToCarol.message.recordId);
                 // empty array for recipient should return all same as undefined recipient field
                 recordsQuery = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -399,8 +397,8 @@ export function testRecordsQueryHandler() {
                     }
                 });
                 queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(queryReply.status.code).to.equal(200);
-                expect((_d = queryReply.entries) === null || _d === void 0 ? void 0 : _d.length).to.equal(2);
+                expect(queryReply.status.code).toBe(200);
+                expect((_d = queryReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(2);
                 // query for both recipients explicitly
                 recordsQuery = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -413,8 +411,8 @@ export function testRecordsQueryHandler() {
                     }
                 });
                 queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(queryReply.status.code).to.equal(200);
-                expect((_e = queryReply.entries) === null || _e === void 0 ? void 0 : _e.length).to.equal(2);
+                expect(queryReply.status.code).toBe(200);
+                expect((_e = queryReply.entries) === null || _e === void 0 ? void 0 : _e.length).toBe(2);
             }));
             it('should be able to query for published records', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c, _d, _e, _f, _g, _h, _j;
@@ -423,29 +421,29 @@ export function testRecordsQueryHandler() {
                 // create a published record
                 const publishedWrite = yield TestDataGenerator.generateRecordsWrite({ author: alice, published: true, schema: 'post' });
                 const publishedWriteReply = yield dwn.processMessage(alice.did, publishedWrite.message, { dataStream: publishedWrite.dataStream });
-                expect(publishedWriteReply.status.code).to.equal(202);
+                expect(publishedWriteReply.status.code).toBe(202);
                 // create an unpublished record
                 const draftWrite = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'post' });
                 const draftWriteReply = yield dwn.processMessage(alice.did, draftWrite.message, { dataStream: draftWrite.dataStream });
-                expect(draftWriteReply.status.code).to.equal(202);
+                expect(draftWriteReply.status.code).toBe(202);
                 // query for only published records
                 const publishedPostQuery = yield TestDataGenerator.generateRecordsQuery({ author: alice, filter: { schema: 'post', published: true } });
                 let publishedPostReply = yield dwn.processMessage(alice.did, publishedPostQuery.message);
-                expect(publishedPostReply.status.code).to.equal(200);
-                expect((_a = publishedPostReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(publishedPostReply.entries[0].recordId).to.equal(publishedWrite.message.recordId);
+                expect(publishedPostReply.status.code).toBe(200);
+                expect((_a = publishedPostReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(publishedPostReply.entries[0].recordId).toBe(publishedWrite.message.recordId);
                 // make an query for published records from non owner
                 const notOwnerPostQuery = yield TestDataGenerator.generateRecordsQuery({ author: bob, filter: { schema: 'post', published: true } });
                 let notOwnerPublishedPostReply = yield dwn.processMessage(alice.did, notOwnerPostQuery.message);
-                expect(notOwnerPublishedPostReply.status.code).to.equal(200);
-                expect((_b = notOwnerPublishedPostReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-                expect(notOwnerPublishedPostReply.entries[0].recordId).to.equal(publishedWrite.message.recordId);
+                expect(notOwnerPublishedPostReply.status.code).toBe(200);
+                expect((_b = notOwnerPublishedPostReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(notOwnerPublishedPostReply.entries[0].recordId).toBe(publishedWrite.message.recordId);
                 // anonymous query for published records
                 const anonymousPostQuery = yield RecordsQuery.create({ filter: { schema: 'post', published: true } });
                 let anonymousPublishedPostReply = yield dwn.processMessage(alice.did, anonymousPostQuery.message);
-                expect(anonymousPublishedPostReply.status.code).to.equal(200);
-                expect((_c = anonymousPublishedPostReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(1);
-                expect(anonymousPublishedPostReply.entries[0].recordId).to.equal(publishedWrite.message.recordId);
+                expect(anonymousPublishedPostReply.status.code).toBe(200);
+                expect((_c = anonymousPublishedPostReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
+                expect(anonymousPublishedPostReply.entries[0].recordId).toBe(publishedWrite.message.recordId);
                 // publish the unpublished record
                 const publishedDraftWrite = yield RecordsWrite.createFrom({
                     recordsWriteMessage: draftWrite.message,
@@ -453,26 +451,26 @@ export function testRecordsQueryHandler() {
                     signer: Jws.createSigner(alice)
                 });
                 const publishedDraftReply = yield dwn.processMessage(alice.did, publishedDraftWrite.message);
-                expect(publishedDraftReply.status.code).to.equal(202);
+                expect(publishedDraftReply.status.code).toBe(202);
                 // issue the same query for published records
                 publishedPostReply = yield dwn.processMessage(alice.did, publishedPostQuery.message);
-                expect(publishedPostReply.status.code).to.equal(200);
-                expect((_d = publishedPostReply.entries) === null || _d === void 0 ? void 0 : _d.length).to.equal(2);
+                expect(publishedPostReply.status.code).toBe(200);
+                expect((_d = publishedPostReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(2);
                 const returnedRecordIds = (_e = publishedPostReply.entries) === null || _e === void 0 ? void 0 : _e.map(e => e.recordId);
                 // ensure that both records now exist in results
-                expect(returnedRecordIds).to.have.members([publishedWrite.message.recordId, draftWrite.message.recordId]);
+                expect(returnedRecordIds).toEqual(expect.arrayContaining([publishedWrite.message.recordId, draftWrite.message.recordId]));
                 // query after publishing from non owner
                 notOwnerPublishedPostReply = yield dwn.processMessage(alice.did, anonymousPostQuery.message);
-                expect(notOwnerPublishedPostReply.status.code).to.equal(200);
-                expect((_f = notOwnerPublishedPostReply.entries) === null || _f === void 0 ? void 0 : _f.length).to.equal(2);
+                expect(notOwnerPublishedPostReply.status.code).toBe(200);
+                expect((_f = notOwnerPublishedPostReply.entries) === null || _f === void 0 ? void 0 : _f.length).toBe(2);
                 const nonOwnerReturnedRecordIds = (_g = notOwnerPublishedPostReply.entries) === null || _g === void 0 ? void 0 : _g.map(e => e.recordId);
-                expect(nonOwnerReturnedRecordIds).to.have.members([publishedWrite.message.recordId, draftWrite.message.recordId]);
+                expect(nonOwnerReturnedRecordIds).toEqual(expect.arrayContaining([publishedWrite.message.recordId, draftWrite.message.recordId]));
                 // anonymous query after publishing
                 anonymousPublishedPostReply = yield dwn.processMessage(alice.did, anonymousPostQuery.message);
-                expect(anonymousPublishedPostReply.status.code).to.equal(200);
-                expect((_h = anonymousPublishedPostReply.entries) === null || _h === void 0 ? void 0 : _h.length).to.equal(2);
+                expect(anonymousPublishedPostReply.status.code).toBe(200);
+                expect((_h = anonymousPublishedPostReply.entries) === null || _h === void 0 ? void 0 : _h.length).toBe(2);
                 const anonymousReturnedRecordIds = (_j = anonymousPublishedPostReply.entries) === null || _j === void 0 ? void 0 : _j.map(e => e.recordId);
-                expect(anonymousReturnedRecordIds).to.have.members([publishedWrite.message.recordId, draftWrite.message.recordId]);
+                expect(anonymousReturnedRecordIds).toEqual(expect.arrayContaining([publishedWrite.message.recordId, draftWrite.message.recordId]));
             }));
             it('should be able to query for unpublished records', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
@@ -480,17 +478,17 @@ export function testRecordsQueryHandler() {
                 // create a published record
                 const publishedWrite = yield TestDataGenerator.generateRecordsWrite({ author: alice, published: true, schema: 'post' });
                 const publishedWriteReply = yield dwn.processMessage(alice.did, publishedWrite.message, { dataStream: publishedWrite.dataStream });
-                expect(publishedWriteReply.status.code).to.equal(202);
+                expect(publishedWriteReply.status.code).toBe(202);
                 // create an unpublished record
                 const draftWrite = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'post' });
                 const draftWriteReply = yield dwn.processMessage(alice.did, draftWrite.message, { dataStream: draftWrite.dataStream });
-                expect(draftWriteReply.status.code).to.equal(202);
+                expect(draftWriteReply.status.code).toBe(202);
                 // query for only unpublished records
                 const unpublishedPostQuery = yield TestDataGenerator.generateRecordsQuery({ author: alice, filter: { schema: 'post', published: false } });
                 let unpublishedPostReply = yield dwn.processMessage(alice.did, unpublishedPostQuery.message);
-                expect(unpublishedPostReply.status.code).to.equal(200);
-                expect((_a = unpublishedPostReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(unpublishedPostReply.entries[0].recordId).to.equal(draftWrite.message.recordId);
+                expect(unpublishedPostReply.status.code).toBe(200);
+                expect((_a = unpublishedPostReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(unpublishedPostReply.entries[0].recordId).toBe(draftWrite.message.recordId);
                 // publish the unpublished record
                 const publishedDraftWrite = yield RecordsWrite.createFrom({
                     recordsWriteMessage: draftWrite.message,
@@ -498,11 +496,11 @@ export function testRecordsQueryHandler() {
                     signer: Jws.createSigner(alice)
                 });
                 const publishedDraftReply = yield dwn.processMessage(alice.did, publishedDraftWrite.message);
-                expect(publishedDraftReply.status.code).to.equal(202);
+                expect(publishedDraftReply.status.code).toBe(202);
                 // issue the same query for unpublished records
                 unpublishedPostReply = yield dwn.processMessage(alice.did, unpublishedPostQuery.message);
-                expect(unpublishedPostReply.status.code).to.equal(200);
-                expect((_b = unpublishedPostReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(0);
+                expect(unpublishedPostReply.status.code).toBe(200);
+                expect((_b = unpublishedPostReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
             }));
             it('should not be able to query for unpublished records if unauthorized', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c, _d;
@@ -511,16 +509,16 @@ export function testRecordsQueryHandler() {
                 // create a published record
                 const publishedWrite = yield TestDataGenerator.generateRecordsWrite({ author: alice, published: true, schema: 'post' });
                 const publishedWriteReply = yield dwn.processMessage(alice.did, publishedWrite.message, { dataStream: publishedWrite.dataStream });
-                expect(publishedWriteReply.status.code).to.equal(202);
+                expect(publishedWriteReply.status.code).toBe(202);
                 // create an unpublished record
                 const draftWrite = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'post' });
                 const draftWriteReply = yield dwn.processMessage(alice.did, draftWrite.message, { dataStream: draftWrite.dataStream });
-                expect(draftWriteReply.status.code).to.equal(202);
+                expect(draftWriteReply.status.code).toBe(202);
                 // bob queries for unpublished records returns zero
                 const unpublishedNotOwner = yield TestDataGenerator.generateRecordsQuery({ author: bob, filter: { schema: 'post', published: false } });
                 let notOwnerPostReply = yield dwn.processMessage(alice.did, unpublishedNotOwner.message);
-                expect(notOwnerPostReply.status.code).to.equal(200);
-                expect((_a = notOwnerPostReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(0);
+                expect(notOwnerPostReply.status.code).toBe(200);
+                expect((_a = notOwnerPostReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
                 // publish the unpublished record
                 const publishedDraftWrite = yield RecordsWrite.createFrom({
                     recordsWriteMessage: draftWrite.message,
@@ -528,21 +526,21 @@ export function testRecordsQueryHandler() {
                     signer: Jws.createSigner(alice)
                 });
                 const publishedDraftReply = yield dwn.processMessage(alice.did, publishedDraftWrite.message);
-                expect(publishedDraftReply.status.code).to.equal(202);
+                expect(publishedDraftReply.status.code).toBe(202);
                 // without published filter
                 let publishedNotOwner = yield TestDataGenerator.generateRecordsQuery({ author: bob, filter: { schema: 'post' } });
                 let publishedNotOwnerReply = yield dwn.processMessage(alice.did, publishedNotOwner.message);
-                expect(publishedNotOwnerReply.status.code).to.equal(200);
-                expect((_b = publishedNotOwnerReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(2);
+                expect(publishedNotOwnerReply.status.code).toBe(200);
+                expect((_b = publishedNotOwnerReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(2);
                 // with explicit published true
                 publishedNotOwner = yield TestDataGenerator.generateRecordsQuery({ author: bob, filter: { schema: 'post', published: true } });
                 publishedNotOwnerReply = yield dwn.processMessage(alice.did, publishedNotOwner.message);
-                expect(publishedNotOwnerReply.status.code).to.equal(200);
-                expect((_c = publishedNotOwnerReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(2);
+                expect(publishedNotOwnerReply.status.code).toBe(200);
+                expect((_c = publishedNotOwnerReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(2);
                 // with explicit published false after publishing should still return nothing
                 notOwnerPostReply = yield dwn.processMessage(alice.did, unpublishedNotOwner.message);
-                expect(notOwnerPostReply.status.code).to.equal(200);
-                expect((_d = notOwnerPostReply.entries) === null || _d === void 0 ? void 0 : _d.length).to.equal(0);
+                expect(notOwnerPostReply.status.code).toBe(200);
+                expect((_d = notOwnerPostReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(0);
             }));
             it('should be able to query for a record by a dataCid', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -550,14 +548,14 @@ export function testRecordsQueryHandler() {
                 // create a record
                 const writeRecord = yield TestDataGenerator.generateRecordsWrite({ author: alice });
                 const writeRecordReply = yield dwn.processMessage(alice.did, writeRecord.message, { dataStream: writeRecord.dataStream });
-                expect(writeRecordReply.status.code).to.equal(202);
+                expect(writeRecordReply.status.code).toBe(202);
                 const recordDataCid = writeRecord.message.descriptor.dataCid;
                 // query for the record by it's dataCid
                 const dataCidQuery = yield TestDataGenerator.generateRecordsQuery({ author: alice, filter: { dataCid: recordDataCid } });
                 const dataCidQueryReply = yield dwn.processMessage(alice.did, dataCidQuery.message);
-                expect(dataCidQueryReply.status.code).to.equal(200);
-                expect((_a = dataCidQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(dataCidQueryReply.entries[0].recordId).to.equal(writeRecord.message.recordId);
+                expect(dataCidQueryReply.status.code).toBe(200);
+                expect((_a = dataCidQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(dataCidQueryReply.entries[0].recordId).toBe(writeRecord.message.recordId);
             }));
             it('should be able to query with `dataSize` filter (half-open range)', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c, _d, _e, _f, _g, _h;
@@ -569,55 +567,55 @@ export function testRecordsQueryHandler() {
                 const writeReply1 = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
                 const writeReply2 = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
                 const writeReply3 = yield dwn.processMessage(alice.did, write3.message, { dataStream: write3.dataStream });
-                expect(writeReply1.status.code).to.equal(202);
-                expect(writeReply2.status.code).to.equal(202);
-                expect(writeReply3.status.code).to.equal(202);
+                expect(writeReply1.status.code).toBe(202);
+                expect(writeReply2.status.code).toBe(202);
+                expect(writeReply3.status.code).toBe(202);
                 // testing gt
                 const recordsQuery1 = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dataSize: { gt: 10 } },
                 });
                 const reply1 = yield dwn.processMessage(alice.did, recordsQuery1.message);
-                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(2);
-                expect((_b = reply1.entries) === null || _b === void 0 ? void 0 : _b.map((entry) => entry.encodedData)).to.have.members([
+                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
+                expect((_b = reply1.entries) === null || _b === void 0 ? void 0 : _b.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
                     Encoder.bytesToBase64Url(write2.dataBytes),
                     Encoder.bytesToBase64Url(write3.dataBytes)
-                ]);
+                ]));
                 // testing lt
                 const recordsQuery2 = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dataSize: { lt: 100 } },
                 });
                 const reply2 = yield dwn.processMessage(alice.did, recordsQuery2.message);
-                expect((_c = reply2.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(2);
-                expect((_d = reply2.entries) === null || _d === void 0 ? void 0 : _d.map((entry) => entry.encodedData)).to.have.members([
+                expect((_c = reply2.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(2);
+                expect((_d = reply2.entries) === null || _d === void 0 ? void 0 : _d.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
                     Encoder.bytesToBase64Url(write1.dataBytes),
                     Encoder.bytesToBase64Url(write2.dataBytes)
-                ]);
+                ]));
                 // testing gte
                 const recordsQuery3 = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dataSize: { gte: 10 } },
                 });
                 const reply3 = yield dwn.processMessage(alice.did, recordsQuery3.message);
-                expect((_e = reply3.entries) === null || _e === void 0 ? void 0 : _e.length).to.equal(3);
-                expect((_f = reply3.entries) === null || _f === void 0 ? void 0 : _f.map((entry) => entry.encodedData)).to.have.members([
+                expect((_e = reply3.entries) === null || _e === void 0 ? void 0 : _e.length).toBe(3);
+                expect((_f = reply3.entries) === null || _f === void 0 ? void 0 : _f.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
                     Encoder.bytesToBase64Url(write1.dataBytes),
                     Encoder.bytesToBase64Url(write2.dataBytes),
                     Encoder.bytesToBase64Url(write3.dataBytes)
-                ]);
+                ]));
                 // testing lte
                 const recordsQuery4 = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dataSize: { lte: 100 } },
                 });
                 const reply4 = yield dwn.processMessage(alice.did, recordsQuery4.message);
-                expect((_g = reply4.entries) === null || _g === void 0 ? void 0 : _g.length).to.equal(3);
-                expect((_h = reply4.entries) === null || _h === void 0 ? void 0 : _h.map((entry) => entry.encodedData)).to.have.members([
+                expect((_g = reply4.entries) === null || _g === void 0 ? void 0 : _g.length).toBe(3);
+                expect((_h = reply4.entries) === null || _h === void 0 ? void 0 : _h.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
                     Encoder.bytesToBase64Url(write1.dataBytes),
                     Encoder.bytesToBase64Url(write2.dataBytes),
                     Encoder.bytesToBase64Url(write3.dataBytes)
-                ]);
+                ]));
             }));
             it('should be able to range query with `dataSize` filter (open & closed range)', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c, _d, _e, _f;
@@ -629,43 +627,43 @@ export function testRecordsQueryHandler() {
                 const writeReply1 = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
                 const writeReply2 = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
                 const writeReply3 = yield dwn.processMessage(alice.did, write3.message, { dataStream: write3.dataStream });
-                expect(writeReply1.status.code).to.equal(202);
-                expect(writeReply2.status.code).to.equal(202);
-                expect(writeReply3.status.code).to.equal(202);
+                expect(writeReply1.status.code).toBe(202);
+                expect(writeReply2.status.code).toBe(202);
+                expect(writeReply3.status.code).toBe(202);
                 // testing range using gt & lt
                 const recordsQuery1 = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dataSize: { gt: 10, lt: 60 } },
                 });
                 const reply1 = yield dwn.processMessage(alice.did, recordsQuery1.message);
-                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(reply1.entries[0].recordId).to.equal(write2.message.recordId);
+                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(reply1.entries[0].recordId).toBe(write2.message.recordId);
                 // testing range using gte & lt
                 const recordsQuery2 = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dataSize: { gte: 10, lt: 60 } },
                 });
                 const reply2 = yield dwn.processMessage(alice.did, recordsQuery2.message);
-                expect((_b = reply2.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(2);
+                expect((_b = reply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(2);
                 const reply2RecordIds = (_c = reply2.entries) === null || _c === void 0 ? void 0 : _c.map(e => e.recordId);
-                expect(reply2RecordIds).to.have.members([write1.message.recordId, write2.message.recordId]);
+                expect(reply2RecordIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId]));
                 // testing range using gt & lte
                 const recordsQuery3 = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dataSize: { gt: 50, lte: 100 } },
                 });
                 const reply3 = yield dwn.processMessage(alice.did, recordsQuery3.message);
-                expect((_d = reply3.entries) === null || _d === void 0 ? void 0 : _d.length).to.equal(1);
-                expect(reply3.entries[0].recordId).to.equal(write3.message.recordId);
+                expect((_d = reply3.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(1);
+                expect(reply3.entries[0].recordId).toBe(write3.message.recordId);
                 // testing range using gte & lte
                 const recordsQuery4 = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dataSize: { gte: 10, lte: 100 } },
                 });
                 const reply4 = yield dwn.processMessage(alice.did, recordsQuery4.message);
-                expect((_e = reply4.entries) === null || _e === void 0 ? void 0 : _e.length).to.equal(3);
+                expect((_e = reply4.entries) === null || _e === void 0 ? void 0 : _e.length).toBe(3);
                 const reply4RecordIds = (_f = reply4.entries) === null || _f === void 0 ? void 0 : _f.map(e => e.recordId);
-                expect(reply4RecordIds).to.have.members([write1.message.recordId, write2.message.recordId, write3.message.recordId]);
+                expect(reply4RecordIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId, write3.message.recordId]));
             }));
             it('should be able to range query by `dateCreated`', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c, _d;
@@ -682,9 +680,9 @@ export function testRecordsQueryHandler() {
                 const writeReply1 = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
                 const writeReply2 = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
                 const writeReply3 = yield dwn.processMessage(alice.did, write3.message, { dataStream: write3.dataStream });
-                expect(writeReply1.status.code).to.equal(202);
-                expect(writeReply2.status.code).to.equal(202);
-                expect(writeReply3.status.code).to.equal(202);
+                expect(writeReply1.status.code).toBe(202);
+                expect(writeReply2.status.code).toBe(202);
+                expect(writeReply3.status.code).toBe(202);
                 // testing `from` range
                 const lastDayOf2021 = Time.createTimestamp({ year: 2021, month: 12, day: 31 });
                 const recordsQuery1 = yield TestDataGenerator.generateRecordsQuery({
@@ -693,9 +691,9 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply1 = yield dwn.processMessage(alice.did, recordsQuery1.message);
-                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(2);
-                expect(reply1.entries[0].encodedData).to.equal(Encoder.bytesToBase64Url(write2.dataBytes));
-                expect(reply1.entries[1].encodedData).to.equal(Encoder.bytesToBase64Url(write3.dataBytes));
+                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
+                expect(reply1.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(write2.dataBytes));
+                expect(reply1.entries[1].encodedData).toBe(Encoder.bytesToBase64Url(write3.dataBytes));
                 // testing `to` range
                 const lastDayOf2022 = Time.createTimestamp({ year: 2022, month: 12, day: 31 });
                 const recordsQuery2 = yield TestDataGenerator.generateRecordsQuery({
@@ -704,9 +702,9 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply2 = yield dwn.processMessage(alice.did, recordsQuery2.message);
-                expect((_b = reply2.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(2);
-                expect(reply2.entries[0].encodedData).to.equal(Encoder.bytesToBase64Url(write1.dataBytes));
-                expect(reply2.entries[1].encodedData).to.equal(Encoder.bytesToBase64Url(write2.dataBytes));
+                expect((_b = reply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(2);
+                expect(reply2.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(write1.dataBytes));
+                expect(reply2.entries[1].encodedData).toBe(Encoder.bytesToBase64Url(write2.dataBytes));
                 // testing `from` and `to` range
                 const lastDayOf2023 = Time.createTimestamp({ year: 2023, month: 12, day: 31 });
                 const recordsQuery3 = yield TestDataGenerator.generateRecordsQuery({
@@ -715,8 +713,8 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply3 = yield dwn.processMessage(alice.did, recordsQuery3.message);
-                expect((_c = reply3.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(1);
-                expect(reply3.entries[0].encodedData).to.equal(Encoder.bytesToBase64Url(write3.dataBytes));
+                expect((_c = reply3.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
+                expect(reply3.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(write3.dataBytes));
                 // testing edge case where value equals `from` and `to`
                 const recordsQuery4 = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -724,8 +722,8 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply4 = yield dwn.processMessage(alice.did, recordsQuery4.message);
-                expect((_d = reply4.entries) === null || _d === void 0 ? void 0 : _d.length).to.equal(1);
-                expect(reply4.entries[0].encodedData).to.equal(Encoder.bytesToBase64Url(write2.dataBytes));
+                expect((_d = reply4.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(1);
+                expect(reply4.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(write2.dataBytes));
             }));
             it('should not return records that were published and then unpublished ', () => __awaiter(this, void 0, void 0, function* () {
                 // scenario: 3 records authored by alice, published on first of 2021, 2022, and 2023 respectively
@@ -749,9 +747,9 @@ export function testRecordsQueryHandler() {
                 const writeReply1 = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
                 const writeReply2 = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
                 const writeReply3 = yield dwn.processMessage(alice.did, write3.message, { dataStream: write3.dataStream });
-                expect(writeReply1.status.code).to.equal(202);
-                expect(writeReply2.status.code).to.equal(202);
-                expect(writeReply3.status.code).to.equal(202);
+                expect(writeReply1.status.code).toBe(202);
+                expect(writeReply2.status.code).toBe(202);
+                expect(writeReply3.status.code).toBe(202);
                 // confirm range before un-publishing.
                 const lastDayOf2021 = Time.createTimestamp({ year: 2021, month: 12, day: 31 });
                 const ownerRangeQuery = yield TestDataGenerator.generateRecordsQuery({
@@ -760,9 +758,9 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply1 = yield dwn.processMessage(alice.did, ownerRangeQuery.message);
-                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(2);
+                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
                 const reply1RecordIds = (_b = reply1.entries) === null || _b === void 0 ? void 0 : _b.map(e => e.recordId);
-                expect(reply1RecordIds).to.have.members([write2.message.recordId, write3.message.recordId]);
+                expect(reply1RecordIds).toEqual(expect.arrayContaining([write2.message.recordId, write3.message.recordId]));
                 // confirm published true filter before un-publishing
                 const ownerPublishedQuery = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -770,30 +768,30 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 let ownerPublishedReply = yield dwn.processMessage(alice.did, ownerPublishedQuery.message);
-                expect(ownerPublishedReply.status.code).to.equal(200);
-                expect((_c = ownerPublishedReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(3);
+                expect(ownerPublishedReply.status.code).toBe(200);
+                expect((_c = ownerPublishedReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(3);
                 const ownerPublishedIds = (_d = ownerPublishedReply.entries) === null || _d === void 0 ? void 0 : _d.map(e => e.recordId);
-                expect(ownerPublishedIds).to.have.members([write1.message.recordId, write2.message.recordId, write3.message.recordId]);
+                expect(ownerPublishedIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId, write3.message.recordId]));
                 // confirm for anonymous query before un-publishing
                 const anonymousRangeQuery = yield RecordsQuery.create({
                     filter: { datePublished: { from: lastDayOf2021 } },
                     dateSort: DateSort.CreatedAscending
                 });
                 let anonymousRangeReply = yield dwn.processMessage(alice.did, anonymousRangeQuery.message);
-                expect(anonymousRangeReply.status.code).to.equal(200);
-                expect((_e = anonymousRangeReply.entries) === null || _e === void 0 ? void 0 : _e.length).to.equal(2);
+                expect(anonymousRangeReply.status.code).toBe(200);
+                expect((_e = anonymousRangeReply.entries) === null || _e === void 0 ? void 0 : _e.length).toBe(2);
                 const anonymousReplyIds = (_f = anonymousRangeReply.entries) === null || _f === void 0 ? void 0 : _f.map(e => e.recordId);
-                expect(anonymousReplyIds).to.have.members([write2.message.recordId, write3.message.recordId]);
+                expect(anonymousReplyIds).toEqual(expect.arrayContaining([write2.message.recordId, write3.message.recordId]));
                 // confirm anonymous published true filter before un-publishing
                 const anonymousPublishedQuery = yield RecordsQuery.create({
                     filter: { published: true },
                     dateSort: DateSort.CreatedAscending
                 });
                 let anonymousPublishedReply = yield dwn.processMessage(alice.did, anonymousPublishedQuery.message);
-                expect(anonymousPublishedReply.status.code).to.equal(200);
-                expect((_g = anonymousPublishedReply.entries) === null || _g === void 0 ? void 0 : _g.length).to.equal(3);
+                expect(anonymousPublishedReply.status.code).toBe(200);
+                expect((_g = anonymousPublishedReply.entries) === null || _g === void 0 ? void 0 : _g.length).toBe(3);
                 const anonymousPublishedIds = (_h = anonymousPublishedReply.entries) === null || _h === void 0 ? void 0 : _h.map(e => e.recordId);
-                expect(anonymousPublishedIds).to.have.members([write1.message.recordId, write2.message.recordId, write3.message.recordId]);
+                expect(anonymousPublishedIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId, write3.message.recordId]));
                 //unpublish records
                 const write1Unpublish = yield RecordsWrite.createFrom({
                     signer: Jws.createSigner(alice),
@@ -813,25 +811,25 @@ export function testRecordsQueryHandler() {
                 const unpublished1Response = yield dwn.processMessage(alice.did, write1Unpublish.message);
                 const unpublished2Response = yield dwn.processMessage(alice.did, write2Unpublish.message);
                 const unpublished3Response = yield dwn.processMessage(alice.did, write3Unpublish.message);
-                expect(unpublished1Response.status.code).to.equal(202);
-                expect(unpublished2Response.status.code).to.equal(202);
-                expect(unpublished3Response.status.code).to.equal(202);
+                expect(unpublished1Response.status.code).toBe(202);
+                expect(unpublished2Response.status.code).toBe(202);
+                expect(unpublished3Response.status.code).toBe(202);
                 // try datePublished range query as an anonymous user after unpublish
                 anonymousRangeReply = yield dwn.processMessage(alice.did, anonymousRangeQuery.message);
-                expect(anonymousRangeReply.status.code).to.equal(200);
-                expect((_j = anonymousRangeReply.entries) === null || _j === void 0 ? void 0 : _j.length).to.equal(0);
+                expect(anonymousRangeReply.status.code).toBe(200);
+                expect((_j = anonymousRangeReply.entries) === null || _j === void 0 ? void 0 : _j.length).toBe(0);
                 // try published:true filter as an anonymous user after unpublish
                 anonymousPublishedReply = yield dwn.processMessage(alice.did, anonymousPublishedQuery.message);
-                expect(anonymousPublishedReply.status.code).to.equal(200);
-                expect((_k = anonymousPublishedReply.entries) === null || _k === void 0 ? void 0 : _k.length).to.equal(0);
+                expect(anonymousPublishedReply.status.code).toBe(200);
+                expect((_k = anonymousPublishedReply.entries) === null || _k === void 0 ? void 0 : _k.length).toBe(0);
                 // try datePublished range query as owner after unpublish
                 const ownerRangeReply = yield dwn.processMessage(alice.did, ownerRangeQuery.message);
-                expect(ownerRangeReply.status.code).to.equal(200);
-                expect((_l = ownerRangeReply.entries) === null || _l === void 0 ? void 0 : _l.length).to.equal(0);
+                expect(ownerRangeReply.status.code).toBe(200);
+                expect((_l = ownerRangeReply.entries) === null || _l === void 0 ? void 0 : _l.length).toBe(0);
                 // try published:true filter as owner after unpublish
                 ownerPublishedReply = yield dwn.processMessage(alice.did, ownerPublishedQuery.message);
-                expect(ownerPublishedReply.status.code).to.equal(200);
-                expect((_m = ownerPublishedReply.entries) === null || _m === void 0 ? void 0 : _m.length).to.equal(0);
+                expect(ownerPublishedReply.status.code).toBe(200);
+                expect((_m = ownerPublishedReply.entries) === null || _m === void 0 ? void 0 : _m.length).toBe(0);
             }));
             it('should be able to range query by `datePublished`', () => __awaiter(this, void 0, void 0, function* () {
                 // scenario: 3 records authored by alice, published on first of 2021, 2022, and 2023 respectively
@@ -855,9 +853,9 @@ export function testRecordsQueryHandler() {
                 const writeReply1 = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
                 const writeReply2 = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
                 const writeReply3 = yield dwn.processMessage(alice.did, write3.message, { dataStream: write3.dataStream });
-                expect(writeReply1.status.code).to.equal(202);
-                expect(writeReply2.status.code).to.equal(202);
-                expect(writeReply3.status.code).to.equal(202);
+                expect(writeReply1.status.code).toBe(202);
+                expect(writeReply2.status.code).toBe(202);
+                expect(writeReply3.status.code).toBe(202);
                 // testing `from` range
                 const lastDayOf2021 = Time.createTimestamp({ year: 2021, month: 12, day: 31 });
                 const recordsQuery1 = yield TestDataGenerator.generateRecordsQuery({
@@ -866,9 +864,9 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply1 = yield dwn.processMessage(alice.did, recordsQuery1.message);
-                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(2);
+                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
                 const reply1RecordIds = (_b = reply1.entries) === null || _b === void 0 ? void 0 : _b.map(e => e.recordId);
-                expect(reply1RecordIds).to.have.members([write2.message.recordId, write3.message.recordId]);
+                expect(reply1RecordIds).toEqual(expect.arrayContaining([write2.message.recordId, write3.message.recordId]));
                 // testing `to` range
                 const lastDayOf2022 = Time.createTimestamp({ year: 2022, month: 12, day: 31 });
                 const recordsQuery2 = yield TestDataGenerator.generateRecordsQuery({
@@ -877,9 +875,9 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply2 = yield dwn.processMessage(alice.did, recordsQuery2.message);
-                expect((_c = reply2.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(2);
+                expect((_c = reply2.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(2);
                 const reply2RecordIds = (_d = reply2.entries) === null || _d === void 0 ? void 0 : _d.map(e => e.recordId);
-                expect(reply2RecordIds).to.have.members([write1.message.recordId, write2.message.recordId]);
+                expect(reply2RecordIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId]));
                 // testing `from` and `to` range
                 const lastDayOf2023 = Time.createTimestamp({ year: 2023, month: 12, day: 31 });
                 const recordsQuery3 = yield TestDataGenerator.generateRecordsQuery({
@@ -888,8 +886,8 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply3 = yield dwn.processMessage(alice.did, recordsQuery3.message);
-                expect((_e = reply3.entries) === null || _e === void 0 ? void 0 : _e.length).to.equal(1);
-                expect(reply3.entries[0].recordId).to.equal(write3.message.recordId);
+                expect((_e = reply3.entries) === null || _e === void 0 ? void 0 : _e.length).toBe(1);
+                expect(reply3.entries[0].recordId).toBe(write3.message.recordId);
                 // testing edge case where value equals `from` and `to`
                 const recordsQuery4 = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -897,18 +895,18 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply4 = yield dwn.processMessage(alice.did, recordsQuery4.message);
-                expect((_f = reply4.entries) === null || _f === void 0 ? void 0 : _f.length).to.equal(1);
-                expect(reply4.entries[0].recordId).to.equal(write2.message.recordId);
+                expect((_f = reply4.entries) === null || _f === void 0 ? void 0 : _f.length).toBe(1);
+                expect(reply4.entries[0].recordId).toBe(write2.message.recordId);
                 // check for anonymous range query
                 const anonymousRecordQuery = yield RecordsQuery.create({
                     filter: { datePublished: { from: lastDayOf2021 } },
                     dateSort: DateSort.CreatedAscending
                 });
                 const anonymousReply = yield dwn.processMessage(alice.did, anonymousRecordQuery.message);
-                expect(anonymousReply.status.code).to.equal(200);
-                expect((_g = anonymousReply.entries) === null || _g === void 0 ? void 0 : _g.length).to.equal(2);
+                expect(anonymousReply.status.code).toBe(200);
+                expect((_g = anonymousReply.entries) === null || _g === void 0 ? void 0 : _g.length).toBe(2);
                 const anonymousReplyIds = (_h = anonymousReply.entries) === null || _h === void 0 ? void 0 : _h.map(e => e.recordId);
-                expect(anonymousReplyIds).to.have.members([write2.message.recordId, write3.message.recordId]);
+                expect(anonymousReplyIds).toEqual(expect.arrayContaining([write2.message.recordId, write3.message.recordId]));
                 // check for non owner range query
                 const bob = yield TestDataGenerator.generateDidKeyPersona();
                 const nonOwnerRange = yield TestDataGenerator.generateRecordsQuery({
@@ -917,10 +915,10 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const nonOwnerReply = yield dwn.processMessage(alice.did, nonOwnerRange.message);
-                expect(nonOwnerReply.status.code).to.equal(200);
-                expect((_j = nonOwnerReply.entries) === null || _j === void 0 ? void 0 : _j.length).to.equal(2);
+                expect(nonOwnerReply.status.code).toBe(200);
+                expect((_j = nonOwnerReply.entries) === null || _j === void 0 ? void 0 : _j.length).toBe(2);
                 const nonOwnerReplyIds = (_k = nonOwnerReply.entries) === null || _k === void 0 ? void 0 : _k.map(e => e.recordId);
-                expect(nonOwnerReplyIds).to.have.members([write2.message.recordId, write3.message.recordId]);
+                expect(nonOwnerReplyIds).toEqual(expect.arrayContaining([write2.message.recordId, write3.message.recordId]));
             }));
             it('should be able to range query by `dateUpdated`', () => __awaiter(this, void 0, void 0, function* () {
                 // scenario: alice creates 3 records on the first day of 2020.
@@ -945,9 +943,9 @@ export function testRecordsQueryHandler() {
                 const writeReply1 = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
                 const writeReply2 = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
                 const writeReply3 = yield dwn.processMessage(alice.did, write3.message, { dataStream: write3.dataStream });
-                expect(writeReply1.status.code).to.equal(202);
-                expect(writeReply2.status.code).to.equal(202);
-                expect(writeReply3.status.code).to.equal(202);
+                expect(writeReply1.status.code).toBe(202);
+                expect(writeReply2.status.code).toBe(202);
+                expect(writeReply3.status.code).toBe(202);
                 // update to published
                 const write1Update = yield RecordsWrite.createFrom({
                     recordsWriteMessage: write1.message,
@@ -973,9 +971,9 @@ export function testRecordsQueryHandler() {
                 const writeReplyUpdate1 = yield dwn.processMessage(alice.did, write1Update.message);
                 const writeReplyUpdate2 = yield dwn.processMessage(alice.did, write2Update.message);
                 const writeReplyUpdate3 = yield dwn.processMessage(alice.did, write3Update.message);
-                expect(writeReplyUpdate1.status.code).to.equal(202);
-                expect(writeReplyUpdate2.status.code).to.equal(202);
-                expect(writeReplyUpdate3.status.code).to.equal(202);
+                expect(writeReplyUpdate1.status.code).toBe(202);
+                expect(writeReplyUpdate2.status.code).toBe(202);
+                expect(writeReplyUpdate3.status.code).toBe(202);
                 // testing `from` range
                 const lastDayOf2021 = Time.createTimestamp({ year: 2021, month: 12, day: 31 });
                 const recordsQuery1 = yield TestDataGenerator.generateRecordsQuery({
@@ -984,9 +982,9 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply1 = yield dwn.processMessage(alice.did, recordsQuery1.message);
-                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(2);
+                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
                 const reply1RecordIds = (_b = reply1.entries) === null || _b === void 0 ? void 0 : _b.map(e => e.recordId);
-                expect(reply1RecordIds).to.have.members([write2.message.recordId, write3.message.recordId]);
+                expect(reply1RecordIds).toEqual(expect.arrayContaining([write2.message.recordId, write3.message.recordId]));
                 // testing `to` range
                 const lastDayOf2022 = Time.createTimestamp({ year: 2022, month: 12, day: 31 });
                 const recordsQuery2 = yield TestDataGenerator.generateRecordsQuery({
@@ -995,9 +993,9 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply2 = yield dwn.processMessage(alice.did, recordsQuery2.message);
-                expect((_c = reply2.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(2);
+                expect((_c = reply2.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(2);
                 const reply2RecordIds = (_d = reply2.entries) === null || _d === void 0 ? void 0 : _d.map(e => e.recordId);
-                expect(reply2RecordIds).to.have.members([write1.message.recordId, write2.message.recordId]);
+                expect(reply2RecordIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId]));
                 // testing `from` and `to` range
                 const lastDayOf2023 = Time.createTimestamp({ year: 2023, month: 12, day: 31 });
                 const recordsQuery3 = yield TestDataGenerator.generateRecordsQuery({
@@ -1006,8 +1004,8 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply3 = yield dwn.processMessage(alice.did, recordsQuery3.message);
-                expect((_e = reply3.entries) === null || _e === void 0 ? void 0 : _e.length).to.equal(1);
-                expect(reply3.entries[0].recordId).to.equal(write3.message.recordId);
+                expect((_e = reply3.entries) === null || _e === void 0 ? void 0 : _e.length).toBe(1);
+                expect(reply3.entries[0].recordId).toBe(write3.message.recordId);
                 // testing edge case where value equals `from` and `to`
                 const recordsQuery4 = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1015,8 +1013,8 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply4 = yield dwn.processMessage(alice.did, recordsQuery4.message);
-                expect((_f = reply4.entries) === null || _f === void 0 ? void 0 : _f.length).to.equal(1);
-                expect(reply4.entries[0].recordId).to.equal(write2.message.recordId);
+                expect((_f = reply4.entries) === null || _f === void 0 ? void 0 : _f.length).toBe(1);
+                expect(reply4.entries[0].recordId).toBe(write2.message.recordId);
             }));
             it('should be able use range and exact match queries at the same time', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -1040,9 +1038,9 @@ export function testRecordsQueryHandler() {
                 const writeReply1 = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
                 const writeReply2 = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
                 const writeReply3 = yield dwn.processMessage(alice.did, write3.message, { dataStream: write3.dataStream });
-                expect(writeReply1.status.code).to.equal(202);
-                expect(writeReply2.status.code).to.equal(202);
-                expect(writeReply3.status.code).to.equal(202);
+                expect(writeReply1.status.code).toBe(202);
+                expect(writeReply2.status.code).toBe(202);
+                expect(writeReply3.status.code).toBe(202);
                 // testing range criterion with another exact match
                 const lastDayOf2021 = Time.createTimestamp({ year: 2021, month: 12, day: 31 });
                 const lastDayOf2023 = Time.createTimestamp({ year: 2023, month: 12, day: 31 });
@@ -1055,8 +1053,8 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedAscending
                 });
                 const reply = yield dwn.processMessage(alice.did, recordsQuery5.message);
-                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(reply.entries[0].encodedData).to.equal(Encoder.bytesToBase64Url(write2.dataBytes));
+                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(reply.entries[0].encodedData).toBe(Encoder.bytesToBase64Url(write2.dataBytes));
             }));
             it('should include `authorization` in returned records', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -1066,15 +1064,15 @@ export function testRecordsQueryHandler() {
                 const mockResolution = TestDataGenerator.createDidResolutionResult(alice);
                 sinon.stub(didResolver, 'resolve').resolves(mockResolution);
                 const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 const queryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema: message.descriptor.schema }
                 });
                 const queryReply = yield dwn.processMessage(alice.did, queryData.message);
-                expect(queryReply.status.code).to.equal(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(queryReply.entries[0].authorization).to.deep.equal(message.authorization);
+                expect(queryReply.status.code).toBe(200);
+                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(queryReply.entries[0].authorization).toEqual(message.authorization);
             }));
             it('should include `attestation` in returned records', () => __awaiter(this, void 0, void 0, function* () {
                 // scenario: alice and bob attest to a message alice authored
@@ -1082,16 +1080,16 @@ export function testRecordsQueryHandler() {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [alice] });
                 const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
-                expect(writeReply.status.code).to.equal(202);
+                expect(writeReply.status.code).toBe(202);
                 const queryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema: message.descriptor.schema }
                 });
                 const queryReply = yield dwn.processMessage(alice.did, queryData.message);
-                expect(queryReply.status.code).to.equal(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+                expect(queryReply.status.code).toBe(200);
+                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
                 const recordsWriteMessage = queryReply.entries[0];
-                expect((_c = (_b = recordsWriteMessage.attestation) === null || _b === void 0 ? void 0 : _b.signatures) === null || _c === void 0 ? void 0 : _c.length).to.equal(1);
+                expect((_c = (_b = recordsWriteMessage.attestation) === null || _b === void 0 ? void 0 : _b.signatures) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
             }));
             it('should omit records that are not published if `dateSort` sorts on `datePublished`', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
@@ -1111,8 +1109,8 @@ export function testRecordsQueryHandler() {
                 // insert data
                 const publishedWriteReply = yield dwn.processMessage(alice.did, publishedWriteData.message, { dataStream: publishedWriteData.dataStream });
                 const unpublishedWriteReply = yield dwn.processMessage(alice.did, unpublishedWriteData.message, { dataStream: unpublishedWriteData.dataStream });
-                expect(publishedWriteReply.status.code).to.equal(202);
-                expect(unpublishedWriteReply.status.code).to.equal(202);
+                expect(publishedWriteReply.status.code).toBe(202);
+                expect(unpublishedWriteReply.status.code).toBe(202);
                 // test published date ascending sort does not include any records that are not published
                 const publishedAscendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1120,8 +1118,8 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 const publishedAscendingQueryReply = yield dwn.processMessage(alice.did, publishedAscendingQueryData.message);
-                expect((_a = publishedAscendingQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(publishedAscendingQueryReply.entries[0].recordId).to.equal(publishedWriteData.message.recordId);
+                expect((_a = publishedAscendingQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(publishedAscendingQueryReply.entries[0].recordId).toBe(publishedWriteData.message.recordId);
                 // test published date scending sort does not include any records that are not published
                 const publishedDescendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1129,8 +1127,8 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 const publishedDescendingQueryReply = yield dwn.processMessage(alice.did, publishedDescendingQueryData.message);
-                expect((_b = publishedDescendingQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-                expect(publishedDescendingQueryReply.entries[0].recordId).to.equal(publishedWriteData.message.recordId);
+                expect((_b = publishedDescendingQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(publishedDescendingQueryReply.entries[0].recordId).toBe(publishedWriteData.message.recordId);
             }));
             it('should sort records if `dateSort` is specified with and without a cursor', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
@@ -1151,9 +1149,9 @@ export function testRecordsQueryHandler() {
                 const writeReply2 = yield dwn.processMessage(alice.did, write2Data.message, { dataStream: write2Data.dataStream });
                 const writeReply1 = yield dwn.processMessage(alice.did, write1Data.message, { dataStream: write1Data.dataStream });
                 const writeReply3 = yield dwn.processMessage(alice.did, write3Data.message, { dataStream: write3Data.dataStream });
-                expect(writeReply1.status.code).to.equal(202);
-                expect(writeReply2.status.code).to.equal(202);
-                expect(writeReply3.status.code).to.equal(202);
+                expect(writeReply1.status.code).toBe(202);
+                expect(writeReply2.status.code).toBe(202);
+                expect(writeReply3.status.code).toBe(202);
                 // createdAscending test
                 let createdAscendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1161,10 +1159,10 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 let createdAscendingQueryReply = yield dwn.processMessage(alice.did, createdAscendingQueryData.message);
-                expect(createdAscendingQueryReply.entries.length).to.equal(3);
-                expect((_a = createdAscendingQueryReply.entries) === null || _a === void 0 ? void 0 : _a[0].recordId).to.equal(write1Data.message.recordId);
-                expect((_b = createdAscendingQueryReply.entries) === null || _b === void 0 ? void 0 : _b[1].recordId).to.equal(write2Data.message.recordId);
-                expect((_c = createdAscendingQueryReply.entries) === null || _c === void 0 ? void 0 : _c[2].recordId).to.equal(write3Data.message.recordId);
+                expect(createdAscendingQueryReply.entries.length).toBe(3);
+                expect((_a = createdAscendingQueryReply.entries) === null || _a === void 0 ? void 0 : _a[0].recordId).toBe(write1Data.message.recordId);
+                expect((_b = createdAscendingQueryReply.entries) === null || _b === void 0 ? void 0 : _b[1].recordId).toBe(write2Data.message.recordId);
+                expect((_c = createdAscendingQueryReply.entries) === null || _c === void 0 ? void 0 : _c[2].recordId).toBe(write3Data.message.recordId);
                 // to test with a cursor we first get a single record
                 createdAscendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1173,7 +1171,7 @@ export function testRecordsQueryHandler() {
                     pagination: { limit: 1 }
                 });
                 createdAscendingQueryReply = yield dwn.processMessage(alice.did, createdAscendingQueryData.message);
-                expect(createdAscendingQueryReply.entries.length).to.equal(1);
+                expect(createdAscendingQueryReply.entries.length).toBe(1);
                 // we then use the single record query's cursor to get the rest of the records
                 createdAscendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1182,9 +1180,9 @@ export function testRecordsQueryHandler() {
                     pagination: { cursor: createdAscendingQueryReply.cursor }
                 });
                 createdAscendingQueryReply = yield dwn.processMessage(alice.did, createdAscendingQueryData.message);
-                expect(createdAscendingQueryReply.entries.length).to.equal(2);
-                expect(createdAscendingQueryReply.entries[0].recordId).to.equal(write2Data.message.recordId);
-                expect(createdAscendingQueryReply.entries[1].recordId).to.equal(write3Data.message.recordId);
+                expect(createdAscendingQueryReply.entries.length).toBe(2);
+                expect(createdAscendingQueryReply.entries[0].recordId).toBe(write2Data.message.recordId);
+                expect(createdAscendingQueryReply.entries[1].recordId).toBe(write3Data.message.recordId);
                 // createdDescending test
                 let createdDescendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1192,10 +1190,10 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 let createdDescendingQueryReply = yield dwn.processMessage(alice.did, createdDescendingQueryData.message);
-                expect(createdDescendingQueryReply.entries.length).to.equal(3);
-                expect((_d = createdDescendingQueryReply.entries) === null || _d === void 0 ? void 0 : _d[0].recordId).to.equal(write3Data.message.recordId);
-                expect((_e = createdDescendingQueryReply.entries) === null || _e === void 0 ? void 0 : _e[1].recordId).to.equal(write2Data.message.recordId);
-                expect((_f = createdDescendingQueryReply.entries) === null || _f === void 0 ? void 0 : _f[2].recordId).to.equal(write1Data.message.recordId);
+                expect(createdDescendingQueryReply.entries.length).toBe(3);
+                expect((_d = createdDescendingQueryReply.entries) === null || _d === void 0 ? void 0 : _d[0].recordId).toBe(write3Data.message.recordId);
+                expect((_e = createdDescendingQueryReply.entries) === null || _e === void 0 ? void 0 : _e[1].recordId).toBe(write2Data.message.recordId);
+                expect((_f = createdDescendingQueryReply.entries) === null || _f === void 0 ? void 0 : _f[2].recordId).toBe(write1Data.message.recordId);
                 // to test with a cursor we first get a single record
                 createdDescendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1204,7 +1202,7 @@ export function testRecordsQueryHandler() {
                     pagination: { limit: 1 }
                 });
                 createdDescendingQueryReply = yield dwn.processMessage(alice.did, createdDescendingQueryData.message);
-                expect(createdDescendingQueryReply.entries.length).to.equal(1);
+                expect(createdDescendingQueryReply.entries.length).toBe(1);
                 // we then use the single record query's cursor to get the rest of the records
                 createdDescendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1213,9 +1211,9 @@ export function testRecordsQueryHandler() {
                     pagination: { cursor: createdDescendingQueryReply.cursor }
                 });
                 createdDescendingQueryReply = yield dwn.processMessage(alice.did, createdDescendingQueryData.message);
-                expect(createdDescendingQueryReply.entries.length).to.equal(2);
-                expect(createdDescendingQueryReply.entries[0].recordId).to.equal(write2Data.message.recordId);
-                expect(createdDescendingQueryReply.entries[1].recordId).to.equal(write1Data.message.recordId);
+                expect(createdDescendingQueryReply.entries.length).toBe(2);
+                expect(createdDescendingQueryReply.entries[0].recordId).toBe(write2Data.message.recordId);
+                expect(createdDescendingQueryReply.entries[1].recordId).toBe(write1Data.message.recordId);
                 // publishedAscending test
                 let publishedAscendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1223,10 +1221,10 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 let publishedAscendingQueryReply = yield dwn.processMessage(alice.did, publishedAscendingQueryData.message);
-                expect(publishedAscendingQueryReply.entries.length).to.equal(3);
-                expect((_g = publishedAscendingQueryReply.entries) === null || _g === void 0 ? void 0 : _g[0].recordId).to.equal(write1Data.message.recordId);
-                expect((_h = publishedAscendingQueryReply.entries) === null || _h === void 0 ? void 0 : _h[1].recordId).to.equal(write2Data.message.recordId);
-                expect((_j = publishedAscendingQueryReply.entries) === null || _j === void 0 ? void 0 : _j[2].recordId).to.equal(write3Data.message.recordId);
+                expect(publishedAscendingQueryReply.entries.length).toBe(3);
+                expect((_g = publishedAscendingQueryReply.entries) === null || _g === void 0 ? void 0 : _g[0].recordId).toBe(write1Data.message.recordId);
+                expect((_h = publishedAscendingQueryReply.entries) === null || _h === void 0 ? void 0 : _h[1].recordId).toBe(write2Data.message.recordId);
+                expect((_j = publishedAscendingQueryReply.entries) === null || _j === void 0 ? void 0 : _j[2].recordId).toBe(write3Data.message.recordId);
                 // to test with a cursor we first get a single record
                 publishedAscendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1235,7 +1233,7 @@ export function testRecordsQueryHandler() {
                     pagination: { limit: 1 }
                 });
                 publishedAscendingQueryReply = yield dwn.processMessage(alice.did, publishedAscendingQueryData.message);
-                expect(publishedAscendingQueryReply.entries.length).to.equal(1);
+                expect(publishedAscendingQueryReply.entries.length).toBe(1);
                 publishedAscendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.PublishedAscending,
@@ -1243,9 +1241,9 @@ export function testRecordsQueryHandler() {
                     pagination: { cursor: publishedAscendingQueryReply.cursor }
                 });
                 publishedAscendingQueryReply = yield dwn.processMessage(alice.did, publishedAscendingQueryData.message);
-                expect(publishedAscendingQueryReply.entries.length).to.equal(2);
-                expect(publishedAscendingQueryReply.entries[0].recordId).to.equal(write2Data.message.recordId);
-                expect(publishedAscendingQueryReply.entries[1].recordId).to.equal(write3Data.message.recordId);
+                expect(publishedAscendingQueryReply.entries.length).toBe(2);
+                expect(publishedAscendingQueryReply.entries[0].recordId).toBe(write2Data.message.recordId);
+                expect(publishedAscendingQueryReply.entries[1].recordId).toBe(write3Data.message.recordId);
                 // publishedDescending test
                 let publishedDescendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1253,10 +1251,10 @@ export function testRecordsQueryHandler() {
                     filter: { schema }
                 });
                 let publishedDescendingQueryReply = yield dwn.processMessage(alice.did, publishedDescendingQueryData.message);
-                expect(publishedDescendingQueryReply.entries.length).to.equal(3);
-                expect((_k = publishedDescendingQueryReply.entries) === null || _k === void 0 ? void 0 : _k[0].recordId).to.equal(write3Data.message.recordId);
-                expect((_l = publishedDescendingQueryReply.entries) === null || _l === void 0 ? void 0 : _l[1].recordId).to.equal(write2Data.message.recordId);
-                expect((_m = publishedDescendingQueryReply.entries) === null || _m === void 0 ? void 0 : _m[2].recordId).to.equal(write1Data.message.recordId);
+                expect(publishedDescendingQueryReply.entries.length).toBe(3);
+                expect((_k = publishedDescendingQueryReply.entries) === null || _k === void 0 ? void 0 : _k[0].recordId).toBe(write3Data.message.recordId);
+                expect((_l = publishedDescendingQueryReply.entries) === null || _l === void 0 ? void 0 : _l[1].recordId).toBe(write2Data.message.recordId);
+                expect((_m = publishedDescendingQueryReply.entries) === null || _m === void 0 ? void 0 : _m[2].recordId).toBe(write1Data.message.recordId);
                 publishedDescendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.PublishedDescending,
@@ -1264,7 +1262,7 @@ export function testRecordsQueryHandler() {
                     pagination: { limit: 1 }
                 });
                 publishedDescendingQueryReply = yield dwn.processMessage(alice.did, publishedDescendingQueryData.message);
-                expect(publishedDescendingQueryReply.entries.length).to.equal(1);
+                expect(publishedDescendingQueryReply.entries.length).toBe(1);
                 publishedDescendingQueryData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.PublishedDescending,
@@ -1272,9 +1270,115 @@ export function testRecordsQueryHandler() {
                     pagination: { cursor: publishedDescendingQueryReply.cursor }
                 });
                 publishedDescendingQueryReply = yield dwn.processMessage(alice.did, publishedDescendingQueryData.message);
-                expect(publishedDescendingQueryReply.entries.length).to.equal(2);
-                expect(publishedDescendingQueryReply.entries[0].recordId).to.equal(write2Data.message.recordId);
-                expect(publishedDescendingQueryReply.entries[1].recordId).to.equal(write1Data.message.recordId);
+                expect(publishedDescendingQueryReply.entries.length).toBe(2);
+                expect(publishedDescendingQueryReply.entries[0].recordId).toBe(write2Data.message.recordId);
+                expect(publishedDescendingQueryReply.entries[1].recordId).toBe(write1Data.message.recordId);
+            }));
+            it('should sort records by `updatedAscending` and `updatedDescending`', () => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d, _e, _f;
+                // insert three messages into DB
+                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                const schema = 'aSchema';
+                const write1Data = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema });
+                yield Time.minimalSleep();
+                const write2Data = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema });
+                yield Time.minimalSleep();
+                const write3Data = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema });
+                // insert data, intentionally out of order
+                const writeReply2 = yield dwn.processMessage(alice.did, write2Data.message, { dataStream: write2Data.dataStream });
+                const writeReply1 = yield dwn.processMessage(alice.did, write1Data.message, { dataStream: write1Data.dataStream });
+                const writeReply3 = yield dwn.processMessage(alice.did, write3Data.message, { dataStream: write3Data.dataStream });
+                expect(writeReply1.status.code).toBe(202);
+                expect(writeReply2.status.code).toBe(202);
+                expect(writeReply3.status.code).toBe(202);
+                // updatedAscending test
+                const updatedAscendingQueryData = yield TestDataGenerator.generateRecordsQuery({
+                    author: alice,
+                    dateSort: DateSort.UpdatedAscending,
+                    filter: { schema }
+                });
+                const updatedAscendingQueryReply = yield dwn.processMessage(alice.did, updatedAscendingQueryData.message);
+                expect(updatedAscendingQueryReply.entries.length).toBe(3);
+                expect((_a = updatedAscendingQueryReply.entries) === null || _a === void 0 ? void 0 : _a[0].recordId).toBe(write1Data.message.recordId);
+                expect((_b = updatedAscendingQueryReply.entries) === null || _b === void 0 ? void 0 : _b[1].recordId).toBe(write2Data.message.recordId);
+                expect((_c = updatedAscendingQueryReply.entries) === null || _c === void 0 ? void 0 : _c[2].recordId).toBe(write3Data.message.recordId);
+                // updatedDescending test
+                const updatedDescendingQueryData = yield TestDataGenerator.generateRecordsQuery({
+                    author: alice,
+                    dateSort: DateSort.UpdatedDescending,
+                    filter: { schema }
+                });
+                const updatedDescendingQueryReply = yield dwn.processMessage(alice.did, updatedDescendingQueryData.message);
+                expect(updatedDescendingQueryReply.entries.length).toBe(3);
+                expect((_d = updatedDescendingQueryReply.entries) === null || _d === void 0 ? void 0 : _d[0].recordId).toBe(write3Data.message.recordId);
+                expect((_e = updatedDescendingQueryReply.entries) === null || _e === void 0 ? void 0 : _e[1].recordId).toBe(write2Data.message.recordId);
+                expect((_f = updatedDescendingQueryReply.entries) === null || _f === void 0 ? void 0 : _f[2].recordId).toBe(write1Data.message.recordId);
+            }));
+            it('should sort by `messageTimestamp` (not `dateCreated`) when using updated sort with genuinely updated records', () => __awaiter(this, void 0, void 0, function* () {
+                // scenario: alice creates 3 records on the same day, then updates them in reverse order.
+                // updatedAscending should return them in order of their update, not creation.
+                const createdTimestamp = Time.createTimestamp({ year: 2020, month: 1, day: 1 });
+                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                const schema = 'aSchema';
+                const write1 = yield TestDataGenerator.generateRecordsWrite({
+                    author: alice, schema, dateCreated: createdTimestamp, messageTimestamp: createdTimestamp,
+                });
+                const write2 = yield TestDataGenerator.generateRecordsWrite({
+                    author: alice, schema, dateCreated: createdTimestamp, messageTimestamp: createdTimestamp,
+                });
+                const write3 = yield TestDataGenerator.generateRecordsWrite({
+                    author: alice, schema, dateCreated: createdTimestamp, messageTimestamp: createdTimestamp,
+                });
+                const writeReply1 = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                const writeReply2 = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                const writeReply3 = yield dwn.processMessage(alice.did, write3.message, { dataStream: write3.dataStream });
+                expect(writeReply1.status.code).toBe(202);
+                expect(writeReply2.status.code).toBe(202);
+                expect(writeReply3.status.code).toBe(202);
+                // update in reverse order: write3 first, then write2, then write1
+                const update3 = yield RecordsWrite.createFrom({
+                    recordsWriteMessage: write3.message,
+                    messageTimestamp: Time.createTimestamp({ year: 2021, month: 1, day: 1 }),
+                    signer: Jws.createSigner(alice),
+                });
+                const update2 = yield RecordsWrite.createFrom({
+                    recordsWriteMessage: write2.message,
+                    messageTimestamp: Time.createTimestamp({ year: 2022, month: 1, day: 1 }),
+                    signer: Jws.createSigner(alice),
+                });
+                const update1 = yield RecordsWrite.createFrom({
+                    recordsWriteMessage: write1.message,
+                    messageTimestamp: Time.createTimestamp({ year: 2023, month: 1, day: 1 }),
+                    signer: Jws.createSigner(alice),
+                });
+                const updateReply3 = yield dwn.processMessage(alice.did, update3.message);
+                const updateReply2 = yield dwn.processMessage(alice.did, update2.message);
+                const updateReply1 = yield dwn.processMessage(alice.did, update1.message);
+                expect(updateReply3.status.code).toBe(202);
+                expect(updateReply2.status.code).toBe(202);
+                expect(updateReply1.status.code).toBe(202);
+                // updatedAscending should return: write3 (2021), write2 (2022), write1 (2023)
+                const updatedAscQuery = yield TestDataGenerator.generateRecordsQuery({
+                    author: alice,
+                    dateSort: DateSort.UpdatedAscending,
+                    filter: { schema }
+                });
+                const updatedAscReply = yield dwn.processMessage(alice.did, updatedAscQuery.message);
+                expect(updatedAscReply.entries.length).toBe(3);
+                expect(updatedAscReply.entries[0].recordId).toBe(write3.message.recordId);
+                expect(updatedAscReply.entries[1].recordId).toBe(write2.message.recordId);
+                expect(updatedAscReply.entries[2].recordId).toBe(write1.message.recordId);
+                // updatedDescending should return: write1 (2023), write2 (2022), write3 (2021)
+                const updatedDescQuery = yield TestDataGenerator.generateRecordsQuery({
+                    author: alice,
+                    dateSort: DateSort.UpdatedDescending,
+                    filter: { schema }
+                });
+                const updatedDescReply = yield dwn.processMessage(alice.did, updatedDescQuery.message);
+                expect(updatedDescReply.entries.length).toBe(3);
+                expect(updatedDescReply.entries[0].recordId).toBe(write1.message.recordId);
+                expect(updatedDescReply.entries[1].recordId).toBe(write2.message.recordId);
+                expect(updatedDescReply.entries[2].recordId).toBe(write3.message.recordId);
             }));
             it('should tiebreak using `messageCid` when sorting encounters identical values', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -1291,11 +1395,11 @@ export function testRecordsQueryHandler() {
                 const [oldestWrite, middleWrite, newestWrite] = yield ArrayUtility.asyncSort([write1Data, write2Data, write3Data], (messageDataA, messageDataB) => { return Message.compareCid(messageDataA.message, messageDataB.message); });
                 // intentionally write the RecordsWrite of out lexicographical order to avoid the test query below accidentally having the correct order
                 const reply2 = yield dwn.processMessage(alice.did, middleWrite.message, { dataStream: middleWrite.dataStream });
-                expect(reply2.status.code).to.equal(202);
+                expect(reply2.status.code).toBe(202);
                 const reply3 = yield dwn.processMessage(alice.did, newestWrite.message, { dataStream: newestWrite.dataStream });
-                expect(reply3.status.code).to.equal(202);
+                expect(reply3.status.code).toBe(202);
                 const reply1 = yield dwn.processMessage(alice.did, oldestWrite.message, { dataStream: oldestWrite.dataStream });
-                expect(reply1.status.code).to.equal(202);
+                expect(reply1.status.code).toBe(202);
                 const queryMessageData = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema },
@@ -1303,11 +1407,11 @@ export function testRecordsQueryHandler() {
                 });
                 const queryReply = yield dwn.processMessage(alice.did, queryMessageData.message);
                 // verify that messages returned are sorted/tiebreak by `messageCid`
-                expect(queryReply.status.code).to.equal(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(3);
-                expect((queryReply.entries[0]).recordId).to.equal(oldestWrite.message.recordId);
-                expect((queryReply.entries[1]).recordId).to.equal(middleWrite.message.recordId);
-                expect((queryReply.entries[2]).recordId).to.equal(newestWrite.message.recordId);
+                expect(queryReply.status.code).toBe(200);
+                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(3);
+                expect((queryReply.entries[0]).recordId).toBe(oldestWrite.message.recordId);
+                expect((queryReply.entries[1]).recordId).toBe(middleWrite.message.recordId);
+                expect((queryReply.entries[2]).recordId).toBe(newestWrite.message.recordId);
                 // sort descending should be reversed
                 const queryMessageDescending = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
@@ -1315,9 +1419,9 @@ export function testRecordsQueryHandler() {
                     dateSort: DateSort.CreatedDescending
                 });
                 const descendingReply = yield dwn.processMessage(alice.did, queryMessageDescending.message);
-                expect((descendingReply.entries[0]).recordId).to.equal(newestWrite.message.recordId);
-                expect((descendingReply.entries[1]).recordId).to.equal(middleWrite.message.recordId);
-                expect((descendingReply.entries[2]).recordId).to.equal(oldestWrite.message.recordId);
+                expect((descendingReply.entries[0]).recordId).toBe(newestWrite.message.recordId);
+                expect((descendingReply.entries[1]).recordId).toBe(middleWrite.message.recordId);
+                expect((descendingReply.entries[2]).recordId).toBe(oldestWrite.message.recordId);
             }));
             it('should paginate all records in ascending order', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -1328,7 +1432,7 @@ export function testRecordsQueryHandler() {
                 })));
                 for (const message of messages) {
                     const result = yield dwn.processMessage(alice.did, message.message, { dataStream: message.dataStream });
-                    expect(result.status.code).to.equal(202);
+                    expect(result.status.code).toBe(202);
                 }
                 const limit = 5;
                 const results = [];
@@ -1346,15 +1450,15 @@ export function testRecordsQueryHandler() {
                         dateSort: DateSort.CreatedAscending
                     });
                     const pageReply = yield dwn.processMessage(alice.did, pageQuery.message);
-                    expect(pageReply.status.code).to.equal(200);
+                    expect(pageReply.status.code).toBe(200);
                     cursor = pageReply.cursor;
-                    expect((_a = pageReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.be.lte(limit);
+                    expect((_a = pageReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBeLessThanOrEqual(limit);
                     results.push(...pageReply.entries);
                     if (cursor === undefined) {
                         break;
                     }
                 }
-                expect(results.length).to.equal(messages.length);
+                expect(results.length).toBe(messages.length);
                 expect(messages.every(({ message }) => results.map(e => e.recordId).includes(message.recordId)));
             }));
             it('should paginate all records in descending order', () => __awaiter(this, void 0, void 0, function* () {
@@ -1366,7 +1470,7 @@ export function testRecordsQueryHandler() {
                 })));
                 for (const message of messages) {
                     const result = yield dwn.processMessage(alice.did, message.message, { dataStream: message.dataStream });
-                    expect(result.status.code).to.equal(202);
+                    expect(result.status.code).toBe(202);
                 }
                 const limit = 5;
                 const results = [];
@@ -1384,15 +1488,15 @@ export function testRecordsQueryHandler() {
                         dateSort: DateSort.CreatedDescending,
                     });
                     const pageReply = yield dwn.processMessage(alice.did, pageQuery.message);
-                    expect(pageReply.status.code).to.equal(200);
+                    expect(pageReply.status.code).toBe(200);
                     cursor = pageReply.cursor;
-                    expect((_a = pageReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.be.lte(limit);
+                    expect((_a = pageReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBeLessThanOrEqual(limit);
                     results.push(...pageReply.entries);
                     if (cursor === undefined) {
                         break;
                     }
                 }
-                expect(results.length).to.equal(messages.length);
+                expect(results.length).toBe(messages.length);
                 expect(messages.every(({ message }) => results.map(e => e.recordId).includes(message.recordId)));
             }));
             it('should allow an anonymous unauthenticated query to return published records', () => __awaiter(this, void 0, void 0, function* () {
@@ -1404,32 +1508,32 @@ export function testRecordsQueryHandler() {
                 const record1Data = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'https://schema1', published: false });
                 const record2Data = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'https://schema2', published: true });
                 const recordsWrite1Reply = yield dwn.processMessage(alice.did, record1Data.message, { dataStream: record1Data.dataStream });
-                expect(recordsWrite1Reply.status.code).to.equal(202);
+                expect(recordsWrite1Reply.status.code).toBe(202);
                 const recordsWrite2Reply = yield dwn.processMessage(alice.did, record2Data.message, { dataStream: record2Data.dataStream });
-                expect(recordsWrite2Reply.status.code).to.equal(202);
+                expect(recordsWrite2Reply.status.code).toBe(202);
                 // test correctness for anonymous query
                 const anonymousQueryMessageData = yield TestDataGenerator.generateRecordsQuery({
                     anonymous: true,
                     filter: { dateCreated: { from: '2000-01-01T10:20:30.123456Z' } }
                 });
                 // sanity check
-                expect(anonymousQueryMessageData.message.authorization).to.not.exist;
+                expect(anonymousQueryMessageData.message.authorization).toBeUndefined();
                 const replyToQuery = yield dwn.processMessage(alice.did, anonymousQueryMessageData.message);
-                expect(replyToQuery.status.code).to.equal(200);
-                expect((_a = replyToQuery.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(replyToQuery.entries[0].descriptor.schema).to.equal('https://schema2');
+                expect(replyToQuery.status.code).toBe(200);
+                expect((_a = replyToQuery.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(replyToQuery.entries[0].descriptor.schema).toBe('https://schema2');
                 // explicitly for published records
                 const anonymousQueryPublished = yield TestDataGenerator.generateRecordsQuery({
                     anonymous: true,
                     filter: { dateCreated: { from: '2000-01-01T10:20:30.123456Z' }, published: true }
                 });
                 // sanity check
-                expect(anonymousQueryPublished.message.authorization).to.not.exist;
+                expect(anonymousQueryPublished.message.authorization).toBeUndefined();
                 // should return the published records
                 const publishedReply = yield dwn.processMessage(alice.did, anonymousQueryPublished.message);
-                expect(publishedReply.status.code).to.equal(200);
-                expect((_b = publishedReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-                expect(publishedReply.entries[0].descriptor.schema).to.equal('https://schema2');
+                expect(publishedReply.status.code).toBe(200);
+                expect((_b = publishedReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(publishedReply.entries[0].descriptor.schema).toBe('https://schema2');
             }));
             it('should only return published records and unpublished records that are meant for specific recipient(s)', () => __awaiter(this, void 0, void 0, function* () {
                 // scenario: Alice installs a free-for-all protocol on her DWN
@@ -1446,7 +1550,7 @@ export function testRecordsQueryHandler() {
                     protocolDefinition: freeForAll
                 });
                 const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                expect(protocolConfigureReply.status.code).to.equal(202);
+                expect(protocolConfigureReply.status.code).toBe(202);
                 // write private records for bob and carol
                 const alicePrivateToBob = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -1457,7 +1561,7 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
                 const alicePrivateToBobReply = yield dwn.processMessage(alice.did, alicePrivateToBob.message, { dataStream: alicePrivateToBob.dataStream });
-                expect(alicePrivateToBobReply.status.code).to.equal(202);
+                expect(alicePrivateToBobReply.status.code).toBe(202);
                 const alicePrivateToCarol = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: carol.did,
@@ -1469,7 +1573,7 @@ export function testRecordsQueryHandler() {
                 const alicePrivateToCarolReply = yield dwn.processMessage(alice.did, alicePrivateToCarol.message, {
                     dataStream: alicePrivateToCarol.dataStream
                 });
-                expect(alicePrivateToCarolReply.status.code).to.equal(202);
+                expect(alicePrivateToCarolReply.status.code).toBe(202);
                 // write private records from carol to alice and bob
                 const carolPrivateToAlice = yield TestDataGenerator.generateRecordsWrite({
                     author: carol,
@@ -1482,7 +1586,7 @@ export function testRecordsQueryHandler() {
                 const carolPrivateToAliceReply = yield dwn.processMessage(alice.did, carolPrivateToAlice.message, {
                     dataStream: carolPrivateToAlice.dataStream
                 });
-                expect(carolPrivateToAliceReply.status.code).to.equal(202);
+                expect(carolPrivateToAliceReply.status.code).toBe(202);
                 const carolPrivateToBob = yield TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     recipient: bob.did,
@@ -1494,7 +1598,7 @@ export function testRecordsQueryHandler() {
                 const carolPrivateToBobReply = yield dwn.processMessage(alice.did, carolPrivateToBob.message, {
                     dataStream: carolPrivateToBob.dataStream
                 });
-                expect(carolPrivateToBobReply.status.code).to.equal(202);
+                expect(carolPrivateToBobReply.status.code).toBe(202);
                 // write private records from bob to alice and carol
                 const bobPrivateToAlice = yield TestDataGenerator.generateRecordsWrite({
                     author: bob,
@@ -1507,7 +1611,7 @@ export function testRecordsQueryHandler() {
                 const bobPrivateToAliceReply = yield dwn.processMessage(alice.did, bobPrivateToAlice.message, {
                     dataStream: bobPrivateToAlice.dataStream
                 });
-                expect(bobPrivateToAliceReply.status.code).to.equal(202);
+                expect(bobPrivateToAliceReply.status.code).toBe(202);
                 const bobPrivateToCarol = yield TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     recipient: carol.did,
@@ -1519,7 +1623,7 @@ export function testRecordsQueryHandler() {
                 const bobPrivateToCarolReply = yield dwn.processMessage(alice.did, bobPrivateToCarol.message, {
                     dataStream: bobPrivateToCarol.dataStream
                 });
-                expect(bobPrivateToCarolReply.status.code).to.equal(202);
+                expect(bobPrivateToCarolReply.status.code).toBe(202);
                 // write public records from alice to bob and carol
                 const alicePublicToBob = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -1533,7 +1637,7 @@ export function testRecordsQueryHandler() {
                 const alicePublicToBobReply = yield dwn.processMessage(alice.did, alicePublicToBob.message, {
                     dataStream: alicePublicToBob.dataStream
                 });
-                expect(alicePublicToBobReply.status.code).to.equal(202);
+                expect(alicePublicToBobReply.status.code).toBe(202);
                 const alicePublicToCarol = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: carol.did,
@@ -1546,7 +1650,7 @@ export function testRecordsQueryHandler() {
                 const alicePublicToCarolReply = yield dwn.processMessage(alice.did, alicePublicToCarol.message, {
                     dataStream: alicePublicToCarol.dataStream
                 });
-                expect(alicePublicToCarolReply.status.code).to.equal(202);
+                expect(alicePublicToCarolReply.status.code).toBe(202);
                 // write public records from bob to alice and carol
                 const bobPublicToAlice = yield TestDataGenerator.generateRecordsWrite({
                     author: bob,
@@ -1560,7 +1664,7 @@ export function testRecordsQueryHandler() {
                 const bobPublicToAliceReply = yield dwn.processMessage(alice.did, bobPublicToAlice.message, {
                     dataStream: bobPublicToAlice.dataStream
                 });
-                expect(bobPublicToAliceReply.status.code).to.equal(202);
+                expect(bobPublicToAliceReply.status.code).toBe(202);
                 const bobPublicToCarol = yield TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     recipient: carol.did,
@@ -1573,7 +1677,7 @@ export function testRecordsQueryHandler() {
                 const bobPublicToCarolReply = yield dwn.processMessage(alice.did, bobPublicToCarol.message, {
                     dataStream: bobPublicToCarol.dataStream
                 });
-                expect(bobPublicToCarolReply.status.code).to.equal(202);
+                expect(bobPublicToCarolReply.status.code).toBe(202);
                 // write public records from carol to alice and bob
                 const carolPublicToAlice = yield TestDataGenerator.generateRecordsWrite({
                     author: carol,
@@ -1587,7 +1691,7 @@ export function testRecordsQueryHandler() {
                 const carolPublicToAliceReply = yield dwn.processMessage(alice.did, carolPublicToAlice.message, {
                     dataStream: carolPublicToAlice.dataStream
                 });
-                expect(carolPublicToAliceReply.status.code).to.equal(202);
+                expect(carolPublicToAliceReply.status.code).toBe(202);
                 const carolPublicToBob = yield TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     recipient: bob.did,
@@ -1600,21 +1704,21 @@ export function testRecordsQueryHandler() {
                 const carolPublicToBobReply = yield dwn.processMessage(alice.did, carolPublicToBob.message, {
                     dataStream: carolPublicToBob.dataStream
                 });
-                expect(carolPublicToBobReply.status.code).to.equal(202);
+                expect(carolPublicToBobReply.status.code).toBe(202);
                 // bob queries for records with himself and alice as recipients
                 const bobQueryMessagesForBobAlice = yield TestDataGenerator.generateRecordsQuery({
                     author: bob,
                     filter: { protocol: freeForAll.protocol, protocolPath: 'post', recipient: [bob.did, alice.did] }
                 });
                 const bobQueryMessagesForBobAliceReply = yield dwn.processMessage(alice.did, bobQueryMessagesForBobAlice.message);
-                expect(bobQueryMessagesForBobAliceReply.status.code).to.equal(200);
-                expect((_a = bobQueryMessagesForBobAliceReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(7);
+                expect(bobQueryMessagesForBobAliceReply.status.code).toBe(200);
+                expect((_a = bobQueryMessagesForBobAliceReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(7);
                 // Since Bob is the author if the query, we expect for him to be able to see:
                 // Private Messages THAT ANYONE sent to Bob
                 // Private Messages THAT ONLY HE sent to Alice
                 // Public Messages THAT ANYONE sent to Alice
                 // Public Messages THAT ANYONE sent to Bob
-                expect(bobQueryMessagesForBobAliceReply.entries.map(e => e.recordId)).to.have.members([
+                expect(bobQueryMessagesForBobAliceReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     alicePrivateToBob.message.recordId,
                     carolPrivateToBob.message.recordId,
                     bobPrivateToAlice.message.recordId,
@@ -1622,54 +1726,54 @@ export function testRecordsQueryHandler() {
                     bobPublicToAlice.message.recordId,
                     carolPublicToAlice.message.recordId,
                     carolPublicToBob.message.recordId,
-                ]);
+                ]));
                 // carol queries for records with herself as the recipient
                 const carolQueryMessagesForCarolAlice = yield TestDataGenerator.generateRecordsQuery({
                     author: carol,
                     filter: { protocol: freeForAll.protocol, protocolPath: 'post', recipient: carol.did }
                 });
                 const carolQueryMessagesForCarolAliceReply = yield dwn.processMessage(alice.did, carolQueryMessagesForCarolAlice.message);
-                expect(carolQueryMessagesForCarolAliceReply.status.code).to.equal(200);
-                expect((_b = carolQueryMessagesForCarolAliceReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(4);
+                expect(carolQueryMessagesForCarolAliceReply.status.code).toBe(200);
+                expect((_b = carolQueryMessagesForCarolAliceReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(4);
                 // Since Carol is the author if the query, we expect for her to be able to see:
                 // Private Messages THAT ANYONE sent to Carol
                 // Private Messages THAT ONLY SHE sent to Alice
                 // Public Messages THAT ANYONE sent to Alice
                 // Public Messages THAT ANYONE sent to Carol
-                expect(carolQueryMessagesForCarolAliceReply.entries.map(e => e.recordId)).to.have.members([
+                expect(carolQueryMessagesForCarolAliceReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     alicePrivateToCarol.message.recordId,
                     bobPrivateToCarol.message.recordId,
                     alicePublicToCarol.message.recordId,
                     bobPublicToCarol.message.recordId,
-                ]);
+                ]));
                 // alice queries for ONLY published records with herself and bob as recipients
                 const aliceQueryPublished = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { protocol: freeForAll.protocol, protocolPath: 'post', recipient: [alice.did, bob.did], published: true }
                 });
                 const aliceQueryPublishedReply = yield dwn.processMessage(alice.did, aliceQueryPublished.message);
-                expect(aliceQueryPublishedReply.status.code).to.equal(200);
-                expect((_c = aliceQueryPublishedReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(4);
-                expect(aliceQueryPublishedReply.entries.map(e => e.recordId)).to.have.members([
+                expect(aliceQueryPublishedReply.status.code).toBe(200);
+                expect((_c = aliceQueryPublishedReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(4);
+                expect(aliceQueryPublishedReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     alicePublicToBob.message.recordId,
                     carolPublicToBob.message.recordId,
                     bobPublicToAlice.message.recordId,
                     carolPublicToAlice.message.recordId,
-                ]);
+                ]));
                 // carol queries for ONLY private records with herself and alice as the recipients
                 const carolQueryPrivate = yield TestDataGenerator.generateRecordsQuery({
                     author: carol,
                     filter: { protocol: freeForAll.protocol, protocolPath: 'post', recipient: [carol.did, alice.did], published: false }
                 });
                 const carolQueryPrivateReply = yield dwn.processMessage(alice.did, carolQueryPrivate.message);
-                expect(carolQueryPrivateReply.status.code).to.equal(200);
-                expect((_d = carolQueryPrivateReply.entries) === null || _d === void 0 ? void 0 : _d.length).to.equal(3);
+                expect(carolQueryPrivateReply.status.code).toBe(200);
+                expect((_d = carolQueryPrivateReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(3);
                 // Carol can query for private messages she authored to alice, and her own private messages with herself as the recipient
-                expect(carolQueryPrivateReply.entries.map(e => e.recordId)).to.have.members([
+                expect(carolQueryPrivateReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     alicePrivateToCarol.message.recordId,
                     bobPrivateToCarol.message.recordId,
                     carolPrivateToAlice.message.recordId,
-                ]);
+                ]));
             }));
             it('should only return published records and unpublished records that are authored by specific author(s)', () => __awaiter(this, void 0, void 0, function* () {
                 // scenario: Alice installs a free-for-all protocol on her DWN
@@ -1686,7 +1790,7 @@ export function testRecordsQueryHandler() {
                     protocolDefinition: freeForAll
                 });
                 const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
-                expect(protocolConfigureReply.status.code).to.equal(202);
+                expect(protocolConfigureReply.status.code).toBe(202);
                 // write private records for bob and carol
                 const alicePrivateToBob = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -1697,7 +1801,7 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
                 const alicePrivateToBobReply = yield dwn.processMessage(alice.did, alicePrivateToBob.message, { dataStream: alicePrivateToBob.dataStream });
-                expect(alicePrivateToBobReply.status.code).to.equal(202);
+                expect(alicePrivateToBobReply.status.code).toBe(202);
                 const alicePrivateToCarol = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: carol.did,
@@ -1709,7 +1813,7 @@ export function testRecordsQueryHandler() {
                 const alicePrivateToCarolReply = yield dwn.processMessage(alice.did, alicePrivateToCarol.message, {
                     dataStream: alicePrivateToCarol.dataStream
                 });
-                expect(alicePrivateToCarolReply.status.code).to.equal(202);
+                expect(alicePrivateToCarolReply.status.code).toBe(202);
                 // write private records from carol to alice and bob
                 const carolPrivateToAlice = yield TestDataGenerator.generateRecordsWrite({
                     author: carol,
@@ -1722,7 +1826,7 @@ export function testRecordsQueryHandler() {
                 const carolPrivateToAliceReply = yield dwn.processMessage(alice.did, carolPrivateToAlice.message, {
                     dataStream: carolPrivateToAlice.dataStream
                 });
-                expect(carolPrivateToAliceReply.status.code).to.equal(202);
+                expect(carolPrivateToAliceReply.status.code).toBe(202);
                 const carolPrivateToBob = yield TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     recipient: bob.did,
@@ -1734,7 +1838,7 @@ export function testRecordsQueryHandler() {
                 const carolPrivateToBobReply = yield dwn.processMessage(alice.did, carolPrivateToBob.message, {
                     dataStream: carolPrivateToBob.dataStream
                 });
-                expect(carolPrivateToBobReply.status.code).to.equal(202);
+                expect(carolPrivateToBobReply.status.code).toBe(202);
                 // write private records from bob to alice and carol
                 const bobPrivateToAlice = yield TestDataGenerator.generateRecordsWrite({
                     author: bob,
@@ -1747,7 +1851,7 @@ export function testRecordsQueryHandler() {
                 const bobPrivateToAliceReply = yield dwn.processMessage(alice.did, bobPrivateToAlice.message, {
                     dataStream: bobPrivateToAlice.dataStream
                 });
-                expect(bobPrivateToAliceReply.status.code).to.equal(202);
+                expect(bobPrivateToAliceReply.status.code).toBe(202);
                 const bobPrivateToCarol = yield TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     recipient: carol.did,
@@ -1759,7 +1863,7 @@ export function testRecordsQueryHandler() {
                 const bobPrivateToCarolReply = yield dwn.processMessage(alice.did, bobPrivateToCarol.message, {
                     dataStream: bobPrivateToCarol.dataStream
                 });
-                expect(bobPrivateToCarolReply.status.code).to.equal(202);
+                expect(bobPrivateToCarolReply.status.code).toBe(202);
                 // write public records from alice to bob and carol
                 const alicePublicToBob = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -1773,7 +1877,7 @@ export function testRecordsQueryHandler() {
                 const alicePublicToBobReply = yield dwn.processMessage(alice.did, alicePublicToBob.message, {
                     dataStream: alicePublicToBob.dataStream
                 });
-                expect(alicePublicToBobReply.status.code).to.equal(202);
+                expect(alicePublicToBobReply.status.code).toBe(202);
                 const alicePublicToCarol = yield TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: carol.did,
@@ -1786,7 +1890,7 @@ export function testRecordsQueryHandler() {
                 const alicePublicToCarolReply = yield dwn.processMessage(alice.did, alicePublicToCarol.message, {
                     dataStream: alicePublicToCarol.dataStream
                 });
-                expect(alicePublicToCarolReply.status.code).to.equal(202);
+                expect(alicePublicToCarolReply.status.code).toBe(202);
                 // write public records from bob to alice and carol
                 const bobPublicToAlice = yield TestDataGenerator.generateRecordsWrite({
                     author: bob,
@@ -1800,7 +1904,7 @@ export function testRecordsQueryHandler() {
                 const bobPublicToAliceReply = yield dwn.processMessage(alice.did, bobPublicToAlice.message, {
                     dataStream: bobPublicToAlice.dataStream
                 });
-                expect(bobPublicToAliceReply.status.code).to.equal(202);
+                expect(bobPublicToAliceReply.status.code).toBe(202);
                 const bobPublicToCarol = yield TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     recipient: carol.did,
@@ -1813,7 +1917,7 @@ export function testRecordsQueryHandler() {
                 const bobPublicToCarolReply = yield dwn.processMessage(alice.did, bobPublicToCarol.message, {
                     dataStream: bobPublicToCarol.dataStream
                 });
-                expect(bobPublicToCarolReply.status.code).to.equal(202);
+                expect(bobPublicToCarolReply.status.code).toBe(202);
                 // write public records from carol to alice and bob
                 const carolPublicToAlice = yield TestDataGenerator.generateRecordsWrite({
                     author: carol,
@@ -1827,7 +1931,7 @@ export function testRecordsQueryHandler() {
                 const carolPublicToAliceReply = yield dwn.processMessage(alice.did, carolPublicToAlice.message, {
                     dataStream: carolPublicToAlice.dataStream
                 });
-                expect(carolPublicToAliceReply.status.code).to.equal(202);
+                expect(carolPublicToAliceReply.status.code).toBe(202);
                 const carolPublicToBob = yield TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     recipient: bob.did,
@@ -1840,21 +1944,21 @@ export function testRecordsQueryHandler() {
                 const carolPublicToBobReply = yield dwn.processMessage(alice.did, carolPublicToBob.message, {
                     dataStream: carolPublicToBob.dataStream
                 });
-                expect(carolPublicToBobReply.status.code).to.equal(202);
+                expect(carolPublicToBobReply.status.code).toBe(202);
                 // bob queries for records with himself and alice as authors
                 const bobQueryMessagesForBobAlice = yield TestDataGenerator.generateRecordsQuery({
                     author: bob,
                     filter: { protocol: freeForAll.protocol, protocolPath: 'post', author: [bob.did, alice.did] }
                 });
                 const bobQueryMessagesForBobAliceReply = yield dwn.processMessage(alice.did, bobQueryMessagesForBobAlice.message);
-                expect(bobQueryMessagesForBobAliceReply.status.code).to.equal(200);
-                expect((_a = bobQueryMessagesForBobAliceReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(7);
+                expect(bobQueryMessagesForBobAliceReply.status.code).toBe(200);
+                expect((_a = bobQueryMessagesForBobAliceReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(7);
                 // Since Bob is the author if the query, we expect for him to be able to see:
                 // Private Messages Bob authored TO ANYONE
                 // Private Messages Alice authored To Bob
                 // Public Messages Alice authored
                 // Public Messages Bob authored
-                expect(bobQueryMessagesForBobAliceReply.entries.map(e => e.recordId)).to.have.members([
+                expect(bobQueryMessagesForBobAliceReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     alicePrivateToBob.message.recordId,
                     bobPrivateToAlice.message.recordId,
                     bobPrivateToCarol.message.recordId,
@@ -1862,50 +1966,50 @@ export function testRecordsQueryHandler() {
                     alicePublicToCarol.message.recordId,
                     bobPublicToAlice.message.recordId,
                     bobPublicToCarol.message.recordId
-                ]);
+                ]));
                 // carol queries for records with herself as the author
                 const carolQueryMessagesForCarolAlice = yield TestDataGenerator.generateRecordsQuery({
                     author: carol,
                     filter: { protocol: freeForAll.protocol, protocolPath: 'post', author: carol.did }
                 });
                 const carolQueryMessagesForCarolAliceReply = yield dwn.processMessage(alice.did, carolQueryMessagesForCarolAlice.message);
-                expect(carolQueryMessagesForCarolAliceReply.status.code).to.equal(200);
-                expect((_b = carolQueryMessagesForCarolAliceReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(4);
+                expect(carolQueryMessagesForCarolAliceReply.status.code).toBe(200);
+                expect((_b = carolQueryMessagesForCarolAliceReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(4);
                 // Since Carol is the author if the query, we expect for her to be able to see:
                 // All messages that Carol sent to anyone, private or public
-                expect(carolQueryMessagesForCarolAliceReply.entries.map(e => e.recordId)).to.have.members([
+                expect(carolQueryMessagesForCarolAliceReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     carolPrivateToAlice.message.recordId,
                     carolPrivateToBob.message.recordId,
                     carolPublicToAlice.message.recordId,
                     carolPublicToBob.message.recordId
-                ]);
+                ]));
                 // alice queries for ONLY published records with herself and bob as authors
                 const aliceQueryPublished = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { protocol: freeForAll.protocol, protocolPath: 'post', author: [alice.did, bob.did], published: true }
                 });
                 const aliceQueryPublishedReply = yield dwn.processMessage(alice.did, aliceQueryPublished.message);
-                expect(aliceQueryPublishedReply.status.code).to.equal(200);
-                expect((_c = aliceQueryPublishedReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(4);
-                expect(aliceQueryPublishedReply.entries.map(e => e.recordId)).to.have.members([
+                expect(aliceQueryPublishedReply.status.code).toBe(200);
+                expect((_c = aliceQueryPublishedReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(4);
+                expect(aliceQueryPublishedReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     alicePublicToBob.message.recordId,
                     alicePublicToCarol.message.recordId,
                     bobPublicToAlice.message.recordId,
                     bobPublicToCarol.message.recordId
-                ]);
+                ]));
                 // carol queries for ONLY private records with herself and alice as the authors
                 const carolQueryPrivate = yield TestDataGenerator.generateRecordsQuery({
                     author: carol,
                     filter: { protocol: freeForAll.protocol, protocolPath: 'post', author: [carol.did, alice.did], published: false }
                 });
                 const carolQueryPrivateReply = yield dwn.processMessage(alice.did, carolQueryPrivate.message);
-                expect(carolQueryPrivateReply.status.code).to.equal(200);
-                expect((_d = carolQueryPrivateReply.entries) === null || _d === void 0 ? void 0 : _d.length).to.equal(3);
-                expect(carolQueryPrivateReply.entries.map(e => e.recordId)).to.have.members([
+                expect(carolQueryPrivateReply.status.code).toBe(200);
+                expect((_d = carolQueryPrivateReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(3);
+                expect(carolQueryPrivateReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     alicePrivateToCarol.message.recordId,
                     carolPrivateToAlice.message.recordId,
                     carolPrivateToBob.message.recordId
-                ]);
+                ]));
             }));
             it('should paginate correctly for fetchRecordsAsNonOwner()', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, e_1, _b, _c;
@@ -1940,7 +2044,7 @@ export function testRecordsQueryHandler() {
                     ...alicePublishedPromise,
                     ...aliceMessagesForBobPromise,
                 ];
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, eventLog, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, stateIndex, eventStream);
                 const messages = [];
                 try {
                     for (var _j = true, messagePromises_1 = __asyncValues(messagePromises), messagePromises_1_1; messagePromises_1_1 = yield messagePromises_1.next(), _a = messagePromises_1_1.done, !_a; _j = true) {
@@ -1950,7 +2054,7 @@ export function testRecordsQueryHandler() {
                         const indexes = yield recordsWrite.constructIndexes(true);
                         const processedMessage = yield recordsWriteHandler.cloneAndAddEncodedData(message, dataBytes);
                         yield messageStore.put(alice.did, processedMessage, indexes);
-                        yield eventLog.append(alice.did, yield Message.getCid(processedMessage), indexes);
+                        yield stateIndex.insert(alice.did, yield Message.getCid(processedMessage), indexes);
                         messages.push(processedMessage);
                     }
                 }
@@ -1972,9 +2076,9 @@ export function testRecordsQueryHandler() {
                     pagination: { limit: 10 },
                 });
                 let results = yield dwn.processMessage(alice.did, aliceQueryMessageDataPage1.message);
-                expect(results.status.code).to.equal(200);
-                expect((_d = results.entries) === null || _d === void 0 ? void 0 : _d.length).to.equal(10, 'alice page 1');
-                expect(results.cursor, 'alice page 1 cursor').to.not.be.undefined;
+                expect(results.status.code).toBe(200);
+                expect((_d = results.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(10, 'alice page 1');
+                expect(results.cursor, 'alice page 1 cursor').toBeDefined();
                 aliceRetrieved.push(...results.entries);
                 // page2 alice
                 const aliceQueryMessageDataPage2 = yield TestDataGenerator.generateRecordsQuery({
@@ -1984,9 +2088,9 @@ export function testRecordsQueryHandler() {
                     pagination: { limit: 10, cursor: results.cursor },
                 });
                 results = yield dwn.processMessage(alice.did, aliceQueryMessageDataPage2.message);
-                expect(results.status.code).to.equal(200);
-                expect((_e = results.entries) === null || _e === void 0 ? void 0 : _e.length).to.equal(10, 'alice page 2');
-                expect(results.cursor, 'alice page 2 cursor').to.not.be.undefined;
+                expect(results.status.code).toBe(200);
+                expect((_e = results.entries) === null || _e === void 0 ? void 0 : _e.length).toBe(10, 'alice page 2');
+                expect(results.cursor, 'alice page 2 cursor').toBeDefined();
                 aliceRetrieved.push(...results.entries);
                 // page3 alice
                 const aliceQueryMessageDataPage3 = yield TestDataGenerator.generateRecordsQuery({
@@ -1996,9 +2100,9 @@ export function testRecordsQueryHandler() {
                     pagination: { limit: 10, cursor: results.cursor },
                 });
                 results = yield dwn.processMessage(alice.did, aliceQueryMessageDataPage3.message);
-                expect(results.status.code).to.equal(200);
-                expect((_f = results.entries) === null || _f === void 0 ? void 0 : _f.length).to.equal(5, 'alice page 3');
-                expect(results.cursor, 'alice page 3 cursor').to.not.exist;
+                expect(results.status.code).toBe(200);
+                expect((_f = results.entries) === null || _f === void 0 ? void 0 : _f.length).toBe(5, 'alice page 3');
+                expect(results.cursor, 'alice page 3 cursor').toBeUndefined();
                 aliceRetrieved.push(...results.entries);
                 const compareRecordId = (a, b) => {
                     return a.recordId === b.recordId;
@@ -2018,9 +2122,9 @@ export function testRecordsQueryHandler() {
                     pagination: { limit: 10 },
                 });
                 results = yield dwn.processMessage(alice.did, bobQueryMessagePage1.message);
-                expect(results.status.code).to.equal(200);
-                expect((_g = results.entries) === null || _g === void 0 ? void 0 : _g.length).to.equal(10, 'bob page 1');
-                expect(results.cursor, 'bob page 1 cursor').to.not.be.undefined;
+                expect(results.status.code).toBe(200);
+                expect((_g = results.entries) === null || _g === void 0 ? void 0 : _g.length).toBe(10, 'bob page 1');
+                expect(results.cursor, 'bob page 1 cursor').toBeDefined();
                 bobRetrieved.push(...results.entries);
                 const bobQueryMessagePage2 = yield TestDataGenerator.generateRecordsQuery({
                     author: bob,
@@ -2029,13 +2133,13 @@ export function testRecordsQueryHandler() {
                     pagination: { limit: 10, cursor: results.cursor },
                 });
                 results = yield dwn.processMessage(alice.did, bobQueryMessagePage2.message);
-                expect(results.status.code).to.equal(200);
-                expect((_h = results.entries) === null || _h === void 0 ? void 0 : _h.length).to.equal(10, 'bob page 2');
-                expect(results.cursor, 'bob page 2 cursor').to.not.exist;
+                expect(results.status.code).toBe(200);
+                expect((_h = results.entries) === null || _h === void 0 ? void 0 : _h.length).toBe(10, 'bob page 2');
+                expect(results.cursor, 'bob page 2 cursor').toBeUndefined();
                 bobRetrieved.push(...results.entries);
                 expect(bobSorted.every((m, i) => compareRecordId(bobRetrieved.at(i), m)));
             }));
-            // https://github.com/TBD54566975/dwn-sdk-js/issues/170
+            // https://github.com/enboxorg/enbox/issues/170
             it('#170 - should treat records with `published` explicitly set to `false` as unpublished', () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -2044,23 +2148,23 @@ export function testRecordsQueryHandler() {
                 const unpublishedRecordsWrite = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema, data: Encoder.stringToBytes('1'), published: false } // explicitly setting `published` to `false`
                 );
                 const result1 = yield dwn.processMessage(alice.did, unpublishedRecordsWrite.message, { dataStream: unpublishedRecordsWrite.dataStream });
-                expect(result1.status.code).to.equal(202);
+                expect(result1.status.code).toBe(202);
                 // alice should be able to see the unpublished record
                 const queryByAlice = yield TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema }
                 });
                 const replyToAliceQuery = yield dwn.processMessage(alice.did, queryByAlice.message);
-                expect(replyToAliceQuery.status.code).to.equal(200);
-                expect((_a = replyToAliceQuery.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+                expect(replyToAliceQuery.status.code).toBe(200);
+                expect((_a = replyToAliceQuery.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
                 // actual test: bob should not be able to see unpublished record
                 const queryByBob = yield TestDataGenerator.generateRecordsQuery({
                     author: bob,
                     filter: { schema }
                 });
                 const replyToBobQuery = yield dwn.processMessage(alice.did, queryByBob.message);
-                expect(replyToBobQuery.status.code).to.equal(200);
-                expect((_b = replyToBobQuery.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(0);
+                expect(replyToBobQuery.status.code).toBe(200);
+                expect((_b = replyToBobQuery.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
             }));
             it('should allow DWN owner to use `recipient` as a filter in queries', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -2070,7 +2174,7 @@ export function testRecordsQueryHandler() {
                     filter: { recipient: bob.did } // alice as the DWN owner querying bob's records
                 });
                 const replyToBobQuery = yield dwn.processMessage(alice.did, bobQueryMessageData.message);
-                expect(replyToBobQuery.status.code).to.equal(200);
+                expect(replyToBobQuery.status.code).toBe(200);
             }));
             it('should not fetch entries across tenants', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -2088,8 +2192,8 @@ export function testRecordsQueryHandler() {
                 yield dwn.processMessage(alice.did, recordsWriteMessage1Data.message, { dataStream: recordsWriteMessage1Data.dataStream });
                 yield dwn.processMessage(bob.did, recordsWriteMessage2Data.message, { dataStream: recordsWriteMessage2Data.dataStream });
                 const reply = yield dwn.processMessage(alice.did, aliceQueryMessageData.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);
             }));
             it('should return 400 if protocol is not normalized', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -2107,8 +2211,8 @@ export function testRecordsQueryHandler() {
                 });
                 // Send records write message
                 const reply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain(DwnErrorCode.UrlProtocolNotNormalized);
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain(DwnErrorCode.UrlProtocolNotNormalized);
             }));
             it('should return 400 if schema is not normalized', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -2126,8 +2230,8 @@ export function testRecordsQueryHandler() {
                 });
                 // Send records write message
                 const reply = yield dwn.processMessage(alice.did, recordsQuery.message);
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain(DwnErrorCode.UrlSchemaNotNormalized);
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain(DwnErrorCode.UrlSchemaNotNormalized);
             }));
             it('should return 400 if published is set to false and a datePublished range is provided', () => __awaiter(this, void 0, void 0, function* () {
                 const fromDatePublished = Time.getCurrentTimestamp();
@@ -2140,8 +2244,8 @@ export function testRecordsQueryHandler() {
                 // set to false
                 recordQuery.message.descriptor.filter.published = false;
                 const queryResponse = yield dwn.processMessage(alice.did, recordQuery.message);
-                expect(queryResponse.status.code).to.equal(400);
-                expect(queryResponse.status.detail).to.contain('descriptor/filter/published: must be equal to one of the allowed values');
+                expect(queryResponse.status.code).toBe(400);
+                expect(queryResponse.status.detail).toContain('descriptor/filter/published: must be equal to one of the allowed values');
             }));
             it('should return 401 for anonymous queries that filter explicitly for unpublished records', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
@@ -2149,18 +2253,18 @@ export function testRecordsQueryHandler() {
                 // create an unpublished record
                 const draftWrite = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'post' });
                 const draftWriteReply = yield dwn.processMessage(alice.did, draftWrite.message, { dataStream: draftWrite.dataStream });
-                expect(draftWriteReply.status.code).to.equal(202);
+                expect(draftWriteReply.status.code).toBe(202);
                 // validate that alice can query
                 const unpublishedPostQuery = yield TestDataGenerator.generateRecordsQuery({ author: alice, filter: { schema: 'post', published: false } });
                 const unpublishedPostReply = yield dwn.processMessage(alice.did, unpublishedPostQuery.message);
-                expect(unpublishedPostReply.status.code).to.equal(200);
-                expect((_a = unpublishedPostReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                expect(unpublishedPostReply.entries[0].recordId).to.equal(draftWrite.message.recordId);
+                expect(unpublishedPostReply.status.code).toBe(200);
+                expect((_a = unpublishedPostReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(unpublishedPostReply.entries[0].recordId).toBe(draftWrite.message.recordId);
                 // anonymous query for unpublished records
                 const unpublishedAnonymous = yield RecordsQuery.create({ filter: { schema: 'post', published: false } });
                 const anonymousPostReply = yield dwn.processMessage(alice.did, unpublishedAnonymous.message);
-                expect(anonymousPostReply.status.code).to.equal(401);
-                expect(anonymousPostReply.status.detail).contains('Missing JWS');
+                expect(anonymousPostReply.status.code).toBe(401);
+                expect(anonymousPostReply.status.detail).toContain('Missing JWS');
             }));
             describe('protocol based queries', () => {
                 it('should return message scoped to the given `contextId`', () => __awaiter(this, void 0, void 0, function* () {
@@ -2179,7 +2283,7 @@ export function testRecordsQueryHandler() {
                         protocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // 1. Alice writes 2 foos, 2 bars under foo1, and 2 bazes under bar1
                     // write 2 foos
                     const fooOptions = {
@@ -2191,10 +2295,10 @@ export function testRecordsQueryHandler() {
                     };
                     const foo1 = yield TestDataGenerator.generateRecordsWrite(fooOptions);
                     const foo1WriteResponse = yield dwn.processMessage(alice.did, foo1.message, { dataStream: foo1.dataStream });
-                    expect(foo1WriteResponse.status.code).equals(202);
+                    expect(foo1WriteResponse.status.code).toBe(202);
                     const foo2 = yield TestDataGenerator.generateRecordsWrite(fooOptions);
                     const foo2WriteResponse = yield dwn.processMessage(alice.did, foo2.message, { dataStream: foo2.dataStream });
-                    expect(foo2WriteResponse.status.code).equals(202);
+                    expect(foo2WriteResponse.status.code).toBe(202);
                     // write 2 bars under foo1
                     const barOptions = {
                         author: alice,
@@ -2206,10 +2310,10 @@ export function testRecordsQueryHandler() {
                     };
                     const bar1 = yield TestDataGenerator.generateRecordsWrite(barOptions);
                     const bar1WriteResponse = yield dwn.processMessage(alice.did, bar1.message, { dataStream: bar1.dataStream });
-                    expect(bar1WriteResponse.status.code).equals(202);
+                    expect(bar1WriteResponse.status.code).toBe(202);
                     const bar2 = yield TestDataGenerator.generateRecordsWrite(barOptions);
                     const bar2WriteResponse = yield dwn.processMessage(alice.did, bar2.message, { dataStream: bar2.dataStream });
-                    expect(bar2WriteResponse.status.code).equals(202);
+                    expect(bar2WriteResponse.status.code).toBe(202);
                     // write 2 bazes under bar1
                     const bazOptions = {
                         author: alice,
@@ -2221,47 +2325,47 @@ export function testRecordsQueryHandler() {
                     };
                     const baz1 = yield TestDataGenerator.generateRecordsWrite(bazOptions);
                     const baz1WriteResponse = yield dwn.processMessage(alice.did, baz1.message, { dataStream: baz1.dataStream });
-                    expect(baz1WriteResponse.status.code).equals(202);
+                    expect(baz1WriteResponse.status.code).toBe(202);
                     const baz2 = yield TestDataGenerator.generateRecordsWrite(bazOptions);
                     const baz2WriteResponse = yield dwn.processMessage(alice.did, baz2.message, { dataStream: baz2.dataStream });
-                    expect(baz2WriteResponse.status.code).equals(202);
+                    expect(baz2WriteResponse.status.code).toBe(202);
                     // 2. Alice should be able to query for all messages under foo1
                     const foo1ContextIdQuery = yield TestDataGenerator.generateRecordsQuery({
                         author: alice,
                         filter: { contextId: foo1.message.contextId }
                     });
                     const foo1ContextIdQueryReply = yield dwn.processMessage(alice.did, foo1ContextIdQuery.message);
-                    expect(foo1ContextIdQueryReply.status.code).to.equal(200);
-                    expect((_a = foo1ContextIdQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(5);
-                    expect(foo1ContextIdQueryReply.entries.map((entry) => entry.recordId)).to.include.members([
+                    expect(foo1ContextIdQueryReply.status.code).toBe(200);
+                    expect((_a = foo1ContextIdQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(5);
+                    expect(foo1ContextIdQueryReply.entries.map((entry) => entry.recordId)).toEqual(expect.arrayContaining([
                         foo1.message.recordId,
                         bar1.message.recordId,
                         bar2.message.recordId,
                         baz1.message.recordId,
                         baz2.message.recordId
-                    ]);
+                    ]));
                     // 3. Alice should be able to query for all messages under bar1
                     const bar1ContextIdQuery = yield TestDataGenerator.generateRecordsQuery({
                         author: alice,
                         filter: { contextId: bar1.message.contextId }
                     });
                     const bar1ContextIdQueryReply = yield dwn.processMessage(alice.did, bar1ContextIdQuery.message);
-                    expect(bar1ContextIdQueryReply.status.code).to.equal(200);
-                    expect((_b = bar1ContextIdQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(3);
-                    expect(bar1ContextIdQueryReply.entries.map((entry) => entry.recordId)).to.include.members([
+                    expect(bar1ContextIdQueryReply.status.code).toBe(200);
+                    expect((_b = bar1ContextIdQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(3);
+                    expect(bar1ContextIdQueryReply.entries.map((entry) => entry.recordId)).toEqual(expect.arrayContaining([
                         bar1.message.recordId,
                         baz1.message.recordId,
                         baz2.message.recordId
-                    ]);
+                    ]));
                     // 4. Alice should be able to query for all messages under baz1
                     const baz1ContextIdQuery = yield TestDataGenerator.generateRecordsQuery({
                         author: alice,
                         filter: { contextId: baz1.message.contextId }
                     });
                     const baz1ContextIdQueryReply = yield dwn.processMessage(alice.did, baz1ContextIdQuery.message);
-                    expect(baz1ContextIdQueryReply.status.code).to.equal(200);
-                    expect((_c = baz1ContextIdQueryReply.entries) === null || _c === void 0 ? void 0 : _c.length).to.equal(1);
-                    expect(baz1ContextIdQueryReply.entries.map((entry) => entry.recordId)).to.include.members([baz1.message.recordId]);
+                    expect(baz1ContextIdQueryReply.status.code).toBe(200);
+                    expect((_c = baz1ContextIdQueryReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
+                    expect(baz1ContextIdQueryReply.entries.map((entry) => entry.recordId)).toEqual(expect.arrayContaining([baz1.message.recordId]));
                 }));
                 it('does not try protocol authorization if protocolRole is not invoked', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Alice creates a thread and writes some chat messages. Alice addresses
@@ -2276,7 +2380,7 @@ export function testRecordsQueryHandler() {
                         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 'thread' record
                     const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2284,7 +2388,7 @@ export function testRecordsQueryHandler() {
                         protocolPath: 'thread',
                     });
                     const threadRoleReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                    expect(threadRoleReply.status.code).to.equal(202);
+                    expect(threadRoleReply.status.code).toBe(202);
                     // Alice writes one 'chat' record addressed to Bob
                     const chatRecordForBob = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2296,7 +2400,7 @@ export function testRecordsQueryHandler() {
                         data: new TextEncoder().encode('Bob can read this cuz he is my friend'),
                     });
                     const chatRecordForBobReply = yield dwn.processMessage(alice.did, chatRecordForBob.message, { dataStream: chatRecordForBob.dataStream });
-                    expect(chatRecordForBobReply.status.code).to.equal(202);
+                    expect(chatRecordForBobReply.status.code).toBe(202);
                     // Alice writes two 'chat' records NOT addressed to Bob
                     for (let i = 0; i < 2; i++) {
                         const chatRecord = yield TestDataGenerator.generateRecordsWrite({
@@ -2309,7 +2413,7 @@ export function testRecordsQueryHandler() {
                             data: new TextEncoder().encode('Bob cannot read this'),
                         });
                         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 queries without invoking any protocolRole
                     const chatQuery = yield TestDataGenerator.generateRecordsQuery({
@@ -2319,9 +2423,9 @@ export function testRecordsQueryHandler() {
                         },
                     });
                     const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
-                    expect(chatQueryReply.status.code).to.equal(200);
-                    expect((_a = chatQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
-                    expect(chatQueryReply.entries[0].recordId).to.eq(chatRecordForBob.message.recordId);
+                    expect(chatQueryReply.status.code).toBe(200);
+                    expect((_a = chatQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                    expect(chatQueryReply.entries[0].recordId).toBe(chatRecordForBob.message.recordId);
                     // bob queries without invoking any protocolRole and filters for unpublished records
                     const unpublishedChatQuery = yield TestDataGenerator.generateRecordsQuery({
                         author: bob,
@@ -2331,9 +2435,9 @@ export function testRecordsQueryHandler() {
                         },
                     });
                     const unpublishedChatReply = yield dwn.processMessage(alice.did, unpublishedChatQuery.message);
-                    expect(unpublishedChatReply.status.code).to.equal(200);
-                    expect((_b = unpublishedChatReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-                    expect(unpublishedChatReply.entries[0].recordId).to.equal(chatRecordForBob.message.recordId);
+                    expect(unpublishedChatReply.status.code).toBe(200);
+                    expect((_b = unpublishedChatReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                    expect(unpublishedChatReply.entries[0].recordId).toBe(chatRecordForBob.message.recordId);
                 }));
                 it('allows root-level role authorized queries', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Alice creates a thread and writes some chat messages writes a chat message. Bob invokes his
@@ -2347,7 +2451,7 @@ export function testRecordsQueryHandler() {
                         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,
@@ -2357,7 +2461,7 @@ export function testRecordsQueryHandler() {
                         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 three 'chat' records
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
@@ -2370,7 +2474,7 @@ export function testRecordsQueryHandler() {
                             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);
                         chatRecordIds.push(chatRecord.message.recordId);
                     }
                     // Bob invokes his friendRole to query that records
@@ -2383,9 +2487,9 @@ export function testRecordsQueryHandler() {
                         protocolRole: 'friend',
                     });
                     const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
-                    expect(chatQueryReply.status.code).to.equal(200);
-                    expect((_a = chatQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(3);
-                    expect(chatQueryReply.entries.map((record) => record.recordId)).to.have.all.members(chatRecordIds);
+                    expect(chatQueryReply.status.code).toBe(200);
+                    expect((_a = chatQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(3);
+                    expect(chatQueryReply.entries.map((record) => record.recordId)).toEqual(expect.arrayContaining(chatRecordIds));
                     // Bob invokes his friendRole along with an explicit filter for unpublished records
                     const unpublishedChatQuery = yield TestDataGenerator.generateRecordsQuery({
                         author: bob,
@@ -2397,9 +2501,9 @@ export function testRecordsQueryHandler() {
                         protocolRole: 'friend',
                     });
                     const unpublishedChatReply = yield dwn.processMessage(alice.did, unpublishedChatQuery.message);
-                    expect(unpublishedChatReply.status.code).to.equal(200);
-                    expect((_b = unpublishedChatReply.entries) === null || _b === void 0 ? void 0 : _b.length).to.equal(3);
-                    expect(unpublishedChatReply.entries.map((record) => record.recordId)).to.have.all.members(chatRecordIds);
+                    expect(unpublishedChatReply.status.code).toBe(200);
+                    expect((_b = unpublishedChatReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(3);
+                    expect(unpublishedChatReply.entries.map((record) => record.recordId)).toEqual(expect.arrayContaining(chatRecordIds));
                 }));
                 it('can authorize queries using a context role.', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Alice writes some chat messages. Bob invokes his friend role in order to query the chat messages.
@@ -2412,7 +2516,7 @@ export function testRecordsQueryHandler() {
                         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 'thread' record
                     const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2420,7 +2524,7 @@ export function testRecordsQueryHandler() {
                         protocolPath: 'thread',
                     });
                     const threadRoleReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                    expect(threadRoleReply.status.code).to.equal(202);
+                    expect(threadRoleReply.status.code).toBe(202);
                     // Alice writes a 'participant' role record with Bob as recipient
                     const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2431,7 +2535,7 @@ export function testRecordsQueryHandler() {
                         data: new TextEncoder().encode('Bob is my friend'),
                     });
                     const participantRoleReply = yield dwn.processMessage(alice.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
-                    expect(participantRoleReply.status.code).to.equal(202);
+                    expect(participantRoleReply.status.code).toBe(202);
                     // Alice writes three 'chat' records
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
@@ -2445,7 +2549,7 @@ export function testRecordsQueryHandler() {
                             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);
                         chatRecordIds.push(chatRecord.message.recordId);
                     }
                     // Bob invokes his friendRole to query that records
@@ -2459,9 +2563,9 @@ export function testRecordsQueryHandler() {
                         protocolRole: 'thread/participant',
                     });
                     const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
-                    expect(chatQueryReply.status.code).to.equal(200);
-                    expect((_a = chatQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(3);
-                    expect(chatQueryReply.entries.map((record) => record.recordId)).to.have.all.members(chatRecordIds);
+                    expect(chatQueryReply.status.code).toBe(200);
+                    expect((_a = chatQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(3);
+                    expect(chatQueryReply.entries.map((record) => record.recordId)).toEqual(expect.arrayContaining(chatRecordIds));
                 }));
                 it('does not execute protocol queries where protocolPath is missing from the filter', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Alice gives Bob a root-level role and writes some chat messages. Bob invokes his root-level role to query those messages,
@@ -2474,7 +2578,7 @@ export function testRecordsQueryHandler() {
                         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,
@@ -2484,7 +2588,7 @@ export function testRecordsQueryHandler() {
                         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 three 'chat' records
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
@@ -2497,7 +2601,7 @@ export function testRecordsQueryHandler() {
                             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);
                         chatRecordIds.push(chatRecord.message.recordId);
                     }
                     // Bob invokes his friendRole to query but does not have `protocolPath` in the filter
@@ -2510,8 +2614,8 @@ export function testRecordsQueryHandler() {
                         protocolRole: 'friend',
                     });
                     const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
-                    expect(chatQueryReply.status.code).to.equal(400);
-                    expect(chatQueryReply.status.detail).to.contain(DwnErrorCode.RecordsQueryFilterMissingRequiredProperties);
+                    expect(chatQueryReply.status.code).toBe(400);
+                    expect(chatQueryReply.status.detail).toContain(DwnErrorCode.RecordsQueryFilterMissingRequiredProperties);
                 }));
                 it('does not execute context role authorized queries where contextId is missing from the filter', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Alice writes some chat messages and gives Bob a role allowing him to access them. But Bob's filter
@@ -2524,7 +2628,7 @@ export function testRecordsQueryHandler() {
                         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 'thread' record
                     const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2532,7 +2636,7 @@ export function testRecordsQueryHandler() {
                         protocolPath: 'thread',
                     });
                     const threadRoleReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                    expect(threadRoleReply.status.code).to.equal(202);
+                    expect(threadRoleReply.status.code).toBe(202);
                     // Alice writes a 'friend' root-level role record with Bob as recipient
                     const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2543,7 +2647,7 @@ export function testRecordsQueryHandler() {
                         data: new TextEncoder().encode('Bob is my friend'),
                     });
                     const participantRoleReply = yield dwn.processMessage(alice.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
-                    expect(participantRoleReply.status.code).to.equal(202);
+                    expect(participantRoleReply.status.code).toBe(202);
                     // Alice writes three 'chat' records
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
@@ -2557,7 +2661,7 @@ export function testRecordsQueryHandler() {
                             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);
                         chatRecordIds.push(chatRecord.message.recordId);
                     }
                     // Bob invokes his thread participant role to query
@@ -2571,8 +2675,8 @@ export function testRecordsQueryHandler() {
                         protocolRole: 'thread/participant',
                     });
                     const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
-                    expect(chatQueryReply.status.code).to.eq(401);
-                    expect(chatQueryReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMissingContextId);
+                    expect(chatQueryReply.status.code).toBe(401);
+                    expect(chatQueryReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMissingContextId);
                 }));
                 it('should reject root-level role authorized queries if a matching root-level role record is not found for the message author', () => __awaiter(this, void 0, void 0, function* () {
                     // scenario: Alice creates a thread and writes some chat messages writes a chat message.
@@ -2585,7 +2689,7 @@ export function testRecordsQueryHandler() {
                         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 three 'chat' records
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
@@ -2598,7 +2702,7 @@ export function testRecordsQueryHandler() {
                             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);
                         chatRecordIds.push(chatRecord.message.recordId);
                     }
                     // Bob invokes his friendRole to query that records
@@ -2611,8 +2715,8 @@ export function testRecordsQueryHandler() {
                         protocolRole: 'friend',
                     });
                     const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
-                    expect(chatQueryReply.status.code).to.eq(401);
-                    expect(chatQueryReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
+                    expect(chatQueryReply.status.code).toBe(401);
+                    expect(chatQueryReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
                 }));
                 it('should reject context role authorized queries if a matching context role record is not found for the message author', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -2623,7 +2727,7 @@ export function testRecordsQueryHandler() {
                         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 'thread' record
                     const threadRecord = yield TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -2631,7 +2735,7 @@ export function testRecordsQueryHandler() {
                         protocolPath: 'thread',
                     });
                     const threadRoleReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
-                    expect(threadRoleReply.status.code).to.equal(202);
+                    expect(threadRoleReply.status.code).toBe(202);
                     // Alice writes three 'chat' records
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
@@ -2645,7 +2749,7 @@ export function testRecordsQueryHandler() {
                             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);
                         chatRecordIds.push(chatRecord.message.recordId);
                     }
                     // Bob invokes his friendRole to query that records
@@ -2659,9 +2763,305 @@ export function testRecordsQueryHandler() {
                         protocolRole: 'thread/participant',
                     });
                     const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
-                    expect(chatQueryReply.status.code).to.eq(401);
-                    expect(chatQueryReply.status.detail).to.contain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
+                    expect(chatQueryReply.status.code).toBe(401);
+                    expect(chatQueryReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
                 }));
+                describe('who-based query/subscribe action rules', () => {
+                    // Protocol with who-based read/query/subscribe rules for both recipient and author
+                    const whoQueryProtocol = {
+                        published: true,
+                        protocol: 'http://who-query-test.xyz',
+                        types: {
+                            message: {
+                                dataFormats: ['text/plain'],
+                            },
+                        },
+                        structure: {
+                            message: {
+                                $actions: [
+                                    { who: 'anyone', can: ['create'] },
+                                    { who: 'author', of: 'message', can: ['read'] },
+                                    { who: 'recipient', of: 'message', can: ['read'] },
+                                ],
+                            },
+                        },
+                    };
+                    it('recipient can query records addressed to them via who-based rule', () => __awaiter(this, void 0, void 0, function* () {
+                        var _a, _b;
+                        // scenario: Alice writes messages to Bob and Carol on her DWN.
+                        //           Bob queries — sees only his messages. Carol queries — sees only hers.
+                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        const bob = yield TestDataGenerator.generateDidKeyPersona();
+                        const carol = yield TestDataGenerator.generateDidKeyPersona();
+                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                            author: alice,
+                            protocolDefinition: whoQueryProtocol,
+                        });
+                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
+                        // Alice writes 2 messages for Bob
+                        const bobRecordIds = [];
+                        for (let i = 0; i < 2; i++) {
+                            const msg = yield TestDataGenerator.generateRecordsWrite({
+                                author: alice,
+                                recipient: bob.did,
+                                protocol: whoQueryProtocol.protocol,
+                                protocolPath: 'message',
+                                published: false,
+                                dataFormat: 'text/plain',
+                                data: new TextEncoder().encode(`message for bob ${i}`),
+                            });
+                            const reply = yield dwn.processMessage(alice.did, msg.message, { dataStream: msg.dataStream });
+                            expect(reply.status.code).toBe(202);
+                            bobRecordIds.push(msg.message.recordId);
+                        }
+                        // Alice writes 1 message for Carol
+                        const carolMsg = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            recipient: carol.did,
+                            protocol: whoQueryProtocol.protocol,
+                            protocolPath: 'message',
+                            published: false,
+                            dataFormat: 'text/plain',
+                            data: new TextEncoder().encode('message for carol'),
+                        });
+                        const carolWriteReply = yield dwn.processMessage(alice.did, carolMsg.message, { dataStream: carolMsg.dataStream });
+                        expect(carolWriteReply.status.code).toBe(202);
+                        // Bob queries — should see exactly his 2 messages
+                        const bobQuery = yield TestDataGenerator.generateRecordsQuery({
+                            author: bob,
+                            filter: {
+                                protocol: whoQueryProtocol.protocol,
+                                protocolPath: 'message',
+                            },
+                        });
+                        const bobQueryReply = yield dwn.processMessage(alice.did, bobQuery.message);
+                        expect(bobQueryReply.status.code).toBe(200);
+                        expect((_a = bobQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
+                        expect(bobQueryReply.entries.map((e) => e.recordId)).toEqual(expect.arrayContaining(bobRecordIds));
+                        // Carol queries — should see exactly her 1 message
+                        const carolQuery = yield TestDataGenerator.generateRecordsQuery({
+                            author: carol,
+                            filter: {
+                                protocol: whoQueryProtocol.protocol,
+                                protocolPath: 'message',
+                            },
+                        });
+                        const carolQueryReply = yield dwn.processMessage(alice.did, carolQuery.message);
+                        expect(carolQueryReply.status.code).toBe(200);
+                        expect((_b = carolQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                        expect(carolQueryReply.entries[0].recordId).toBe(carolMsg.message.recordId);
+                    }));
+                    it('author can query their own records via who-based rule', () => __awaiter(this, void 0, void 0, function* () {
+                        var _a, _b;
+                        // scenario: Bob writes a message to Alice's DWN. Bob queries Alice's DWN
+                        //           and sees the message he authored. Carol does not see it.
+                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        const bob = yield TestDataGenerator.generateDidKeyPersona();
+                        const carol = yield TestDataGenerator.generateDidKeyPersona();
+                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                            author: alice,
+                            protocolDefinition: whoQueryProtocol,
+                        });
+                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
+                        // Bob writes a message to Alice's DWN (anyone can create)
+                        const bobMsg = yield TestDataGenerator.generateRecordsWrite({
+                            author: bob,
+                            recipient: alice.did,
+                            protocol: whoQueryProtocol.protocol,
+                            protocolPath: 'message',
+                            published: false,
+                            dataFormat: 'text/plain',
+                            data: new TextEncoder().encode('message from bob'),
+                        });
+                        const bobWriteReply = yield dwn.processMessage(alice.did, bobMsg.message, { dataStream: bobMsg.dataStream });
+                        expect(bobWriteReply.status.code).toBe(202);
+                        // Bob queries — should see the message he authored
+                        const bobQuery = yield TestDataGenerator.generateRecordsQuery({
+                            author: bob,
+                            filter: {
+                                protocol: whoQueryProtocol.protocol,
+                                protocolPath: 'message',
+                            },
+                        });
+                        const bobQueryReply = yield dwn.processMessage(alice.did, bobQuery.message);
+                        expect(bobQueryReply.status.code).toBe(200);
+                        expect((_a = bobQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                        expect(bobQueryReply.entries[0].recordId).toBe(bobMsg.message.recordId);
+                        // Carol queries — should see nothing (she is neither author nor recipient)
+                        const carolQuery = yield TestDataGenerator.generateRecordsQuery({
+                            author: carol,
+                            filter: {
+                                protocol: whoQueryProtocol.protocol,
+                                protocolPath: 'message',
+                            },
+                        });
+                        const carolQueryReply = yield dwn.processMessage(alice.did, carolQuery.message);
+                        expect(carolQueryReply.status.code).toBe(200);
+                        expect((_b = carolQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
+                    }));
+                    it('unauthorized party cannot see any unpublished records via query', () => __awaiter(this, void 0, void 0, function* () {
+                        var _a, _b;
+                        // scenario: Alice writes unpublished messages. Dave (not author, not recipient)
+                        //           queries and gets an empty result — no records leak.
+                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        const bob = yield TestDataGenerator.generateDidKeyPersona();
+                        const dave = yield TestDataGenerator.generateDidKeyPersona();
+                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                            author: alice,
+                            protocolDefinition: whoQueryProtocol,
+                        });
+                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
+                        // Alice writes messages to Bob
+                        for (let i = 0; i < 3; i++) {
+                            const msg = yield TestDataGenerator.generateRecordsWrite({
+                                author: alice,
+                                recipient: bob.did,
+                                protocol: whoQueryProtocol.protocol,
+                                protocolPath: 'message',
+                                published: false,
+                                dataFormat: 'text/plain',
+                                data: new TextEncoder().encode(`secret message ${i}`),
+                            });
+                            const reply = yield dwn.processMessage(alice.did, msg.message, { dataStream: msg.dataStream });
+                            expect(reply.status.code).toBe(202);
+                        }
+                        // Dave queries — he is neither author nor recipient of any record
+                        const daveQuery = yield TestDataGenerator.generateRecordsQuery({
+                            author: dave,
+                            filter: {
+                                protocol: whoQueryProtocol.protocol,
+                                protocolPath: 'message',
+                            },
+                        });
+                        const daveQueryReply = yield dwn.processMessage(alice.did, daveQuery.message);
+                        expect(daveQueryReply.status.code).toBe(200);
+                        expect((_a = daveQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
+                        // Dave queries with explicit unpublished filter — still sees nothing
+                        const daveUnpubQuery = yield TestDataGenerator.generateRecordsQuery({
+                            author: dave,
+                            filter: {
+                                protocol: whoQueryProtocol.protocol,
+                                protocolPath: 'message',
+                                published: false,
+                            },
+                        });
+                        const daveUnpubReply = yield dwn.processMessage(alice.did, daveUnpubQuery.message);
+                        expect(daveUnpubReply.status.code).toBe(200);
+                        expect((_b = daveUnpubReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
+                    }));
+                    it('who-based query rules do not grant role-like broad access', () => __awaiter(this, void 0, void 0, function* () {
+                        var _a, _b;
+                        // scenario: Protocol has who-based query rules. A non-participant tries to invoke
+                        //           a protocolRole to get broader access. This should be rejected with 401
+                        //           because no matching role record exists.
+                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        const bob = yield TestDataGenerator.generateDidKeyPersona();
+                        const dave = yield TestDataGenerator.generateDidKeyPersona();
+                        // Protocol with both a role AND who-based rules
+                        const mixedProtocol = {
+                            published: true,
+                            protocol: 'http://mixed-role-who.xyz',
+                            types: {
+                                thread: {},
+                                participant: {},
+                                chat: { dataFormats: ['text/plain'] },
+                            },
+                            structure: {
+                                thread: {
+                                    participant: {
+                                        $role: true,
+                                    },
+                                    chat: {
+                                        $actions: [
+                                            { who: 'anyone', can: ['create'] },
+                                            { who: 'recipient', of: 'thread/chat', can: ['read'] },
+                                            { role: 'thread/participant', can: ['read'] },
+                                        ],
+                                    },
+                                },
+                            },
+                        };
+                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                            author: alice,
+                            protocolDefinition: mixedProtocol,
+                        });
+                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        expect(protocolsConfigureReply.status.code).toBe(202);
+                        // Alice creates a thread
+                        const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            protocol: mixedProtocol.protocol,
+                            protocolPath: 'thread',
+                        });
+                        const threadReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+                        expect(threadReply.status.code).toBe(202);
+                        // Alice adds Bob as participant (role)
+                        const participantRecord = yield TestDataGenerator.generateRecordsWrite({
+                            author: alice,
+                            recipient: bob.did,
+                            protocol: mixedProtocol.protocol,
+                            protocolPath: 'thread/participant',
+                            parentContextId: threadRecord.message.contextId,
+                        });
+                        const participantReply = yield dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
+                        expect(participantReply.status.code).toBe(202);
+                        // Alice writes chat messages
+                        for (let i = 0; i < 3; i++) {
+                            const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                                author: alice,
+                                recipient: alice.did,
+                                protocol: mixedProtocol.protocol,
+                                protocolPath: 'thread/chat',
+                                parentContextId: threadRecord.message.contextId,
+                                published: false,
+                                dataFormat: 'text/plain',
+                                data: new TextEncoder().encode(`chat message ${i}`),
+                            });
+                            const chatReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+                            expect(chatReply.status.code).toBe(202);
+                        }
+                        // Bob (who IS a participant) can query with his role — should succeed
+                        const bobRoleQuery = yield TestDataGenerator.generateRecordsQuery({
+                            author: bob,
+                            filter: {
+                                protocol: mixedProtocol.protocol,
+                                protocolPath: 'thread/chat',
+                                contextId: threadRecord.message.contextId,
+                            },
+                            protocolRole: 'thread/participant',
+                        });
+                        const bobRoleQueryReply = yield dwn.processMessage(alice.did, bobRoleQuery.message);
+                        expect(bobRoleQueryReply.status.code).toBe(200);
+                        expect((_a = bobRoleQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(3);
+                        // Dave (who is NOT a participant) tries to invoke the role — should be rejected
+                        const daveRoleQuery = yield TestDataGenerator.generateRecordsQuery({
+                            author: dave,
+                            filter: {
+                                protocol: mixedProtocol.protocol,
+                                protocolPath: 'thread/chat',
+                                contextId: threadRecord.message.contextId,
+                            },
+                            protocolRole: 'thread/participant',
+                        });
+                        const daveRoleQueryReply = yield dwn.processMessage(alice.did, daveRoleQuery.message);
+                        expect(daveRoleQueryReply.status.code).toBe(401);
+                        expect(daveRoleQueryReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
+                        // Dave without a role — should get 200 but zero results (no records addressed to him)
+                        const daveNoRoleQuery = yield TestDataGenerator.generateRecordsQuery({
+                            author: dave,
+                            filter: {
+                                protocol: mixedProtocol.protocol,
+                                protocolPath: 'thread/chat',
+                            },
+                        });
+                        const daveNoRoleQueryReply = yield dwn.processMessage(alice.did, daveNoRoleQuery.message);
+                        expect(daveNoRoleQueryReply.status.code).toBe(200);
+                        expect((_b = daveNoRoleQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
+                    }));
+                });
             });
         });
         it('should return 401 if signature check fails', () => __awaiter(this, void 0, void 0, function* () {
@@ -2675,7 +3075,7 @@ export function testRecordsQueryHandler() {
             const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
             const recordsQueryHandler = new RecordsQueryHandler(didResolver, messageStoreStub, dataStoreStub);
             const reply = yield recordsQueryHandler.handle({ tenant, 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 { author, message } = yield TestDataGenerator.generateRecordsQuery();
@@ -2688,7 +3088,7 @@ export function testRecordsQueryHandler() {
             // stub the `parse()` function to throw an error
             sinon.stub(RecordsQuery, 'parse').throws('anyError');
             const reply = yield recordsQueryHandler.handle({ tenant, message });
-            expect(reply.status.code).to.equal(400);
+            expect(reply.status.code).toBe(400);
         }));
     });
 }