@enbox/dwn-sdk-js 0.0.6 → 0.0.8

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

@@ -1,19 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    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 sinon from 'sinon';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import freeForAll from '../vectors/protocol-definitions/free-for-all.json' with { type: 'json' };
@@ -30,11 +14,11 @@ import { Message } from '../../src/core/message.js';
 import { RecordsQuery } from '../../src/interfaces/records-query.js';
 import { RecordsQueryHandler } from '../../src/handlers/records-query.js';
 import { RecordsWriteHandler } from '../../src/handlers/records-write.js';
-import { TestDataGenerator } from '../utils/test-data-generator.js';
-import { TestEventStream } from '../test-event-stream.js';
+import { TestEventLog } from '../test-event-stream.js';
 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 { CoreProtocolRegistry, DataStoreLevel, Dwn, MessageStoreLevel, ProtocolsConfigure, RecordsWrite, Time } from '../../src/index.js';
+import { defaultTestProtocolDefinition, TestDataGenerator } from '../utils/test-data-generator.js';
 import { DidKey, UniversalResolver } from '@enbox/dids';
 export function testRecordsQueryHandler() {
     describe('RecordsQueryHandler.handle()', () => {
@@ -47,212 +31,212 @@ export function testRecordsQueryHandler() {
             let dataStore;
             let resumableTaskStore;
             let stateIndex;
-            let eventStream;
+            let eventLog;
             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
-            beforeAll(() => __awaiter(this, void 0, void 0, function* () {
+            beforeAll(async () => {
                 didResolver = new UniversalResolver({ didResolvers: [DidKey] });
                 const stores = TestStores.get();
                 messageStore = stores.messageStore;
                 dataStore = stores.dataStore;
                 resumableTaskStore = stores.resumableTaskStore;
                 stateIndex = stores.stateIndex;
-                eventStream = TestEventStream.get();
-                dwn = yield Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
-            }));
-            beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+                eventLog = TestEventLog.get();
+                eventLog = TestEventLog.get();
+                dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventLog, resumableTaskStore });
+            });
+            beforeEach(async () => {
                 // 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 stateIndex.clear();
-            }));
-            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* () {
-                const alice = yield TestDataGenerator.generatePersona();
+                await messageStore.clear();
+                await dataStore.clear();
+                await resumableTaskStore.clear();
+                await stateIndex.clear();
+            });
+            afterAll(async () => {
+                await dwn.close();
+            });
+            it('should reject when published is set to false with a dateSort set to sorting by `PublishedAscending` or `PublishedDescending`', async () => {
+                const alice = await TestDataGenerator.generatePersona();
                 TestStubGenerator.stubDidResolver(didResolver, [alice]);
-                const query = yield TestDataGenerator.generateRecordsQuery({ author: alice, filter: { published: false } });
+                const query = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { published: false } });
                 //control
-                let reply = yield dwn.processMessage(alice.did, query.message);
+                let reply = await dwn.processMessage(alice.did, query.message);
                 expect(reply.status.code).toBe(200);
                 // modify dateSort to publishedAscending
                 query.message.descriptor.dateSort = DateSort.PublishedAscending;
-                reply = yield dwn.processMessage(alice.did, query.message);
+                reply = await dwn.processMessage(alice.did, query.message);
                 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);
+                reply = await dwn.processMessage(alice.did, query.message);
                 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;
-                const alice = yield TestDataGenerator.generatePersona();
-                const bob = yield TestDataGenerator.generatePersona();
+            });
+            it('should return recordId, descriptor, authorization and attestation', async () => {
+                const alice = await TestDataGenerator.generatePersona();
+                const bob = await TestDataGenerator.generatePersona();
                 TestStubGenerator.stubDidResolver(didResolver, [alice, bob]);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 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 });
+                const write = await TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [bob], dataFormat });
+                const writeReply = await dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
                 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).toBe(1);
+                const query = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { dataFormat } });
+                const reply = await dwn.processMessage(alice.did, query.message);
+                expect(reply.entries?.length).toBe(1);
                 const entry = reply.entries[0];
                 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;
+            });
+            it('should return records matching the query', async () => {
                 // insert three messages into DB, two with matching protocol
-                const alice = yield TestDataGenerator.generatePersona();
+                const alice = await TestDataGenerator.generatePersona();
                 const dataFormat = 'myAwesomeDataFormat';
-                const write1 = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                const write2 = yield TestDataGenerator.generateRecordsWrite({ author: alice, dataFormat, schema: 'schema1' });
-                const write3 = yield TestDataGenerator.generateRecordsWrite({ author: alice, dataFormat, schema: 'schema2' });
+                const write1 = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                const write2 = await TestDataGenerator.generateRecordsWrite({ author: alice, dataFormat, schema: 'schema1' });
+                const write3 = await TestDataGenerator.generateRecordsWrite({ author: alice, dataFormat, schema: 'schema2' });
                 // setting up a stub resolver
                 const mockResolution = TestDataGenerator.createDidResolutionResult(alice);
                 ;
                 sinon.stub(didResolver, 'resolve').resolves(mockResolution);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // insert data
-                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 });
+                const writeReply1 = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                const writeReply2 = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                const writeReply3 = await 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);
                 // testing singular conditional query
-                const messageData = yield TestDataGenerator.generateRecordsQuery({ author: alice, filter: { dataFormat } });
-                const reply = yield dwn.processMessage(alice.did, messageData.message);
+                const messageData = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { dataFormat } });
+                const reply = await dwn.processMessage(alice.did, messageData.message);
                 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
+                expect(reply.entries?.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({
+                const messageData2 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         dataFormat,
                         schema: 'schema1'
                     }
                 });
-                const reply2 = yield dwn.processMessage(alice.did, messageData2.message);
+                const reply2 = await dwn.processMessage(alice.did, messageData2.message);
                 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;
+                expect(reply2.entries?.length).toBe(1); // only 1 entry should match the query
+            });
+            it('should return `encodedData` if data size is within the spec threshold', async () => {
                 const data = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded); // within/on threshold
-                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 });
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const write = await TestDataGenerator.generateRecordsWrite({ author: alice, data });
+                const writeReply = await dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
                 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);
+                const messageData = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { recordId: write.message.recordId } });
+                const reply = await dwn.processMessage(alice.did, messageData.message);
                 expect(reply.status.code).toBe(200);
-                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(reply.entries?.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;
+            });
+            it('should not return `encodedData` if data size is greater then spec threshold', async () => {
                 const data = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1); // exceeding threshold
-                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 });
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const write = await TestDataGenerator.generateRecordsWrite({ author: alice, data });
+                const writeReply = await dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
                 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);
+                const messageData = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { recordId: write.message.recordId } });
+                const reply = await dwn.processMessage(alice.did, messageData.message);
                 expect(reply.status.code).toBe(200);
-                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(reply.entries?.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 });
+            });
+            it('should include `initialWrite` property if RecordsWrite is not initial write', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const write = await TestDataGenerator.generateRecordsWrite({ author: alice, published: false });
+                const writeReply = await dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
                 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);
+                const write2 = await RecordsWrite.createFrom({ recordsWriteMessage: write.message, published: true, signer: Jws.createSigner(alice) });
+                const write2Reply = await dwn.processMessage(alice.did, write2.message);
                 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);
+                const messageData = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { recordId: write.message.recordId } });
+                const reply = await dwn.processMessage(alice.did, messageData.message);
                 expect(reply.status.code).toBe(200);
-                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(reply.entries?.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;
+                expect(reply.entries[0].initialWrite?.recordId).toBe(write.message.recordId);
+            });
+            it('should be able to query by attester', async () => {
                 // scenario: 2 records authored by alice, 1st attested by alice, 2nd attested by bob
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                const recordsWrite1 = yield TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [alice] });
-                const recordsWrite2 = yield TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [bob] });
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const recordsWrite1 = await TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [alice] });
+                const recordsWrite2 = await TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [bob] });
                 // 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 });
+                const writeReply1 = await dwn.processMessage(alice.did, recordsWrite1.message, { dataStream: recordsWrite1.dataStream });
+                const writeReply2 = await dwn.processMessage(alice.did, recordsWrite2.message, { dataStream: recordsWrite2.dataStream });
                 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).toBe(1);
+                const recordsQuery1 = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { attester: alice.did } });
+                const reply1 = await dwn.processMessage(alice.did, recordsQuery1.message);
+                expect(reply1.entries?.length).toBe(1);
                 const reply1Attester = Jws.getSignerDid(reply1.entries[0].attestation.signatures[0]);
                 expect(reply1Attester).toBe(alice.did);
                 // testing attester + another filter
-                const recordsQuery2 = yield TestDataGenerator.generateRecordsQuery({
+                const recordsQuery2 = await 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).toBe(1);
+                const reply2 = await dwn.processMessage(alice.did, recordsQuery2.message);
+                expect(reply2.entries?.length).toBe(1);
                 const reply2Attester = Jws.getSignerDid(reply2.entries[0].attestation.signatures[0]);
                 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).toBe(0);
-            }));
-            it('should be able to query by author', () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c, _d;
+                const carol = await TestDataGenerator.generateDidKeyPersona();
+                const recordsQuery3 = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { attester: carol.did } });
+                const reply3 = await dwn.processMessage(alice.did, recordsQuery3.message);
+                expect(reply3.entries?.length).toBe(0);
+            });
+            it('should be able to query by author', async () => {
                 // scenario alice and bob both author records into alice's DWN.
                 // alice is able to filter for records authored by bob.
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 const protocolDefinition = freeForAll;
-                const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition
                 });
-                const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                 expect(protocolsConfigureReply.status.code).toBe(202);
-                const aliceAuthorWrite = yield TestDataGenerator.generateRecordsWrite({
+                const aliceAuthorWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: protocolDefinition.protocol,
                     schema: protocolDefinition.types.post.schema,
                     dataFormat: protocolDefinition.types.post.dataFormats[0],
                     protocolPath: 'post'
                 });
-                const aliceAuthorReply = yield dwn.processMessage(alice.did, aliceAuthorWrite.message, { dataStream: aliceAuthorWrite.dataStream });
+                const aliceAuthorReply = await dwn.processMessage(alice.did, aliceAuthorWrite.message, { dataStream: aliceAuthorWrite.dataStream });
                 expect(aliceAuthorReply.status.code).toBe(202);
-                const bobAuthorWrite = yield TestDataGenerator.generateRecordsWrite({
+                const bobAuthorWrite = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     protocol: protocolDefinition.protocol,
                     schema: protocolDefinition.types.post.schema,
                     dataFormat: protocolDefinition.types.post.dataFormats[0],
                     protocolPath: 'post'
                 });
-                const bobAuthorReply = yield dwn.processMessage(alice.did, bobAuthorWrite.message, { dataStream: bobAuthorWrite.dataStream });
+                const bobAuthorReply = await dwn.processMessage(alice.did, bobAuthorWrite.message, { dataStream: bobAuthorWrite.dataStream });
                 expect(bobAuthorReply.status.code).toBe(202);
                 // alice queries with an empty filter, gets both
-                let recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+                let recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         protocol: protocolDefinition.protocol,
@@ -261,11 +245,11 @@ export function testRecordsQueryHandler() {
                         protocolPath: 'post'
                     }
                 });
-                let queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+                let queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
+                expect(queryReply.entries?.length).toBe(2);
                 // filter for bob as author
-                recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+                recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         author: bob.did,
@@ -275,12 +259,12 @@ export function testRecordsQueryHandler() {
                         protocolPath: 'post'
                     }
                 });
-                queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+                queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect((_b = queryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(queryReply.entries?.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({
+                recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         author: [],
@@ -290,11 +274,11 @@ export function testRecordsQueryHandler() {
                         protocolPath: 'post'
                     }
                 });
-                queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+                queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect((_c = queryReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(2);
+                expect(queryReply.entries?.length).toBe(2);
                 // query for both authors explicitly
-                recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+                recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         author: [alice.did, bob.did],
@@ -304,25 +288,24 @@ export function testRecordsQueryHandler() {
                         protocolPath: 'post'
                     }
                 });
-                queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+                queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 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;
+                expect(queryReply.entries?.length).toBe(2);
+            });
+            it('should be able to query by recipient', async () => {
                 // scenario alice authors records for bob and carol into alice's DWN.
                 // bob and carol are able to filter for records for them.
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                const carol = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const carol = await TestDataGenerator.generateDidKeyPersona();
                 const protocolDefinition = freeForAll;
-                const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition
                 });
-                const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                 expect(protocolsConfigureReply.status.code).toBe(202);
-                const aliceToBob = yield TestDataGenerator.generateRecordsWrite({
+                const aliceToBob = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: bob.did,
                     protocol: protocolDefinition.protocol,
@@ -330,9 +313,9 @@ export function testRecordsQueryHandler() {
                     dataFormat: protocolDefinition.types.post.dataFormats[0],
                     protocolPath: 'post'
                 });
-                const aliceToBobReply = yield dwn.processMessage(alice.did, aliceToBob.message, { dataStream: aliceToBob.dataStream });
+                const aliceToBobReply = await dwn.processMessage(alice.did, aliceToBob.message, { dataStream: aliceToBob.dataStream });
                 expect(aliceToBobReply.status.code).toBe(202);
-                const aliceToCarol = yield TestDataGenerator.generateRecordsWrite({
+                const aliceToCarol = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: carol.did,
                     protocol: protocolDefinition.protocol,
@@ -340,10 +323,10 @@ export function testRecordsQueryHandler() {
                     dataFormat: protocolDefinition.types.post.dataFormats[0],
                     protocolPath: 'post'
                 });
-                const aliceToCarolReply = yield dwn.processMessage(alice.did, aliceToCarol.message, { dataStream: aliceToCarol.dataStream });
+                const aliceToCarolReply = await dwn.processMessage(alice.did, aliceToCarol.message, { dataStream: aliceToCarol.dataStream });
                 expect(aliceToCarolReply.status.code).toBe(202);
                 // alice queries with an empty filter, gets both
-                let recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+                let recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         protocol: protocolDefinition.protocol,
@@ -352,11 +335,11 @@ export function testRecordsQueryHandler() {
                         protocolPath: 'post'
                     }
                 });
-                let queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+                let queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
+                expect(queryReply.entries?.length).toBe(2);
                 // filter for bob as recipient
-                recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+                recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         recipient: bob.did,
@@ -366,12 +349,12 @@ export function testRecordsQueryHandler() {
                         protocolPath: 'post'
                     }
                 });
-                queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+                queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect((_b = queryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(queryReply.entries?.length).toBe(1);
                 expect(queryReply.entries[0].recordId).toBe(aliceToBob.message.recordId);
                 // filter for carol as recipient
-                recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+                recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         recipient: carol.did,
@@ -381,12 +364,12 @@ export function testRecordsQueryHandler() {
                         protocolPath: 'post'
                     }
                 });
-                queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+                queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect((_c = queryReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
+                expect(queryReply.entries?.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({
+                recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         recipient: [],
@@ -396,11 +379,11 @@ export function testRecordsQueryHandler() {
                         protocolPath: 'post'
                     }
                 });
-                queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+                queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 expect(queryReply.status.code).toBe(200);
-                expect((_d = queryReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(2);
+                expect(queryReply.entries?.length).toBe(2);
                 // query for both recipients explicitly
-                recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+                recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         recipient: [bob.did, carol.did],
@@ -410,641 +393,655 @@ export function testRecordsQueryHandler() {
                         protocolPath: 'post'
                     }
                 });
-                queryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+                queryReply = await dwn.processMessage(alice.did, recordsQuery.message);
                 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;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+                expect(queryReply.entries?.length).toBe(2);
+            });
+            it('should be able to query for published records', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // 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 });
+                const publishedWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, published: true, schema: 'post' });
+                const publishedWriteReply = await dwn.processMessage(alice.did, publishedWrite.message, { dataStream: publishedWrite.dataStream });
                 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 });
+                const draftWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'post' });
+                const draftWriteReply = await dwn.processMessage(alice.did, draftWrite.message, { dataStream: draftWrite.dataStream });
                 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);
+                const publishedPostQuery = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { schema: 'post', published: true } });
+                let publishedPostReply = await dwn.processMessage(alice.did, publishedPostQuery.message);
                 expect(publishedPostReply.status.code).toBe(200);
-                expect((_a = publishedPostReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(publishedPostReply.entries?.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);
+                const notOwnerPostQuery = await TestDataGenerator.generateRecordsQuery({ author: bob, filter: { schema: 'post', published: true } });
+                let notOwnerPublishedPostReply = await dwn.processMessage(alice.did, notOwnerPostQuery.message);
                 expect(notOwnerPublishedPostReply.status.code).toBe(200);
-                expect((_b = notOwnerPublishedPostReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(notOwnerPublishedPostReply.entries?.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);
+                const anonymousPostQuery = await RecordsQuery.create({ filter: { schema: 'post', published: true } });
+                let anonymousPublishedPostReply = await dwn.processMessage(alice.did, anonymousPostQuery.message);
                 expect(anonymousPublishedPostReply.status.code).toBe(200);
-                expect((_c = anonymousPublishedPostReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
+                expect(anonymousPublishedPostReply.entries?.length).toBe(1);
                 expect(anonymousPublishedPostReply.entries[0].recordId).toBe(publishedWrite.message.recordId);
                 // publish the unpublished record
-                const publishedDraftWrite = yield RecordsWrite.createFrom({
+                const publishedDraftWrite = await RecordsWrite.createFrom({
                     recordsWriteMessage: draftWrite.message,
                     published: true,
                     signer: Jws.createSigner(alice)
                 });
-                const publishedDraftReply = yield dwn.processMessage(alice.did, publishedDraftWrite.message);
+                const publishedDraftReply = await dwn.processMessage(alice.did, publishedDraftWrite.message);
                 expect(publishedDraftReply.status.code).toBe(202);
                 // issue the same query for published records
-                publishedPostReply = yield dwn.processMessage(alice.did, publishedPostQuery.message);
+                publishedPostReply = await dwn.processMessage(alice.did, publishedPostQuery.message);
                 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);
+                expect(publishedPostReply.entries?.length).toBe(2);
+                const returnedRecordIds = publishedPostReply.entries?.map(e => e.recordId);
                 // ensure that both records now exist in results
                 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);
+                notOwnerPublishedPostReply = await dwn.processMessage(alice.did, anonymousPostQuery.message);
                 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(notOwnerPublishedPostReply.entries?.length).toBe(2);
+                const nonOwnerReturnedRecordIds = notOwnerPublishedPostReply.entries?.map(e => e.recordId);
                 expect(nonOwnerReturnedRecordIds).toEqual(expect.arrayContaining([publishedWrite.message.recordId, draftWrite.message.recordId]));
                 // anonymous query after publishing
-                anonymousPublishedPostReply = yield dwn.processMessage(alice.did, anonymousPostQuery.message);
+                anonymousPublishedPostReply = await dwn.processMessage(alice.did, anonymousPostQuery.message);
                 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(anonymousPublishedPostReply.entries?.length).toBe(2);
+                const anonymousReturnedRecordIds = anonymousPublishedPostReply.entries?.map(e => e.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;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should be able to query for unpublished records', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // 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 });
+                const publishedWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, published: true, schema: 'post' });
+                const publishedWriteReply = await dwn.processMessage(alice.did, publishedWrite.message, { dataStream: publishedWrite.dataStream });
                 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 });
+                const draftWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'post' });
+                const draftWriteReply = await dwn.processMessage(alice.did, draftWrite.message, { dataStream: draftWrite.dataStream });
                 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);
+                const unpublishedPostQuery = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { schema: 'post', published: false } });
+                let unpublishedPostReply = await dwn.processMessage(alice.did, unpublishedPostQuery.message);
                 expect(unpublishedPostReply.status.code).toBe(200);
-                expect((_a = unpublishedPostReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(unpublishedPostReply.entries?.length).toBe(1);
                 expect(unpublishedPostReply.entries[0].recordId).toBe(draftWrite.message.recordId);
                 // publish the unpublished record
-                const publishedDraftWrite = yield RecordsWrite.createFrom({
+                const publishedDraftWrite = await RecordsWrite.createFrom({
                     recordsWriteMessage: draftWrite.message,
                     published: true,
                     signer: Jws.createSigner(alice)
                 });
-                const publishedDraftReply = yield dwn.processMessage(alice.did, publishedDraftWrite.message);
+                const publishedDraftReply = await dwn.processMessage(alice.did, publishedDraftWrite.message);
                 expect(publishedDraftReply.status.code).toBe(202);
                 // issue the same query for unpublished records
-                unpublishedPostReply = yield dwn.processMessage(alice.did, unpublishedPostQuery.message);
+                unpublishedPostReply = await dwn.processMessage(alice.did, unpublishedPostQuery.message);
                 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;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+                expect(unpublishedPostReply.entries?.length).toBe(0);
+            });
+            it('should not be able to query for unpublished records if unauthorized', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // 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 });
+                const publishedWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, published: true, schema: 'post' });
+                const publishedWriteReply = await dwn.processMessage(alice.did, publishedWrite.message, { dataStream: publishedWrite.dataStream });
                 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 });
+                const draftWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'post' });
+                const draftWriteReply = await dwn.processMessage(alice.did, draftWrite.message, { dataStream: draftWrite.dataStream });
                 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);
+                const unpublishedNotOwner = await TestDataGenerator.generateRecordsQuery({ author: bob, filter: { schema: 'post', published: false } });
+                let notOwnerPostReply = await dwn.processMessage(alice.did, unpublishedNotOwner.message);
                 expect(notOwnerPostReply.status.code).toBe(200);
-                expect((_a = notOwnerPostReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
+                expect(notOwnerPostReply.entries?.length).toBe(0);
                 // publish the unpublished record
-                const publishedDraftWrite = yield RecordsWrite.createFrom({
+                const publishedDraftWrite = await RecordsWrite.createFrom({
                     recordsWriteMessage: draftWrite.message,
                     published: true,
                     signer: Jws.createSigner(alice)
                 });
-                const publishedDraftReply = yield dwn.processMessage(alice.did, publishedDraftWrite.message);
+                const publishedDraftReply = await dwn.processMessage(alice.did, publishedDraftWrite.message);
                 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);
+                let publishedNotOwner = await TestDataGenerator.generateRecordsQuery({ author: bob, filter: { schema: 'post' } });
+                let publishedNotOwnerReply = await dwn.processMessage(alice.did, publishedNotOwner.message);
                 expect(publishedNotOwnerReply.status.code).toBe(200);
-                expect((_b = publishedNotOwnerReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(2);
+                expect(publishedNotOwnerReply.entries?.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);
+                publishedNotOwner = await TestDataGenerator.generateRecordsQuery({ author: bob, filter: { schema: 'post', published: true } });
+                publishedNotOwnerReply = await dwn.processMessage(alice.did, publishedNotOwner.message);
                 expect(publishedNotOwnerReply.status.code).toBe(200);
-                expect((_c = publishedNotOwnerReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(2);
+                expect(publishedNotOwnerReply.entries?.length).toBe(2);
                 // with explicit published false after publishing should still return nothing
-                notOwnerPostReply = yield dwn.processMessage(alice.did, unpublishedNotOwner.message);
+                notOwnerPostReply = await dwn.processMessage(alice.did, unpublishedNotOwner.message);
                 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;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                expect(notOwnerPostReply.entries?.length).toBe(0);
+            });
+            it('should be able to query for a record by a dataCid', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // create a record
-                const writeRecord = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                const writeRecordReply = yield dwn.processMessage(alice.did, writeRecord.message, { dataStream: writeRecord.dataStream });
+                const writeRecord = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                const writeRecordReply = await dwn.processMessage(alice.did, writeRecord.message, { dataStream: writeRecord.dataStream });
                 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);
+                const dataCidQuery = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { dataCid: recordDataCid } });
+                const dataCidQueryReply = await dwn.processMessage(alice.did, dataCidQuery.message);
                 expect(dataCidQueryReply.status.code).toBe(200);
-                expect((_a = dataCidQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(dataCidQueryReply.entries?.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;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const write1 = yield TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(10) });
-                const write2 = yield TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(50) });
-                const write3 = yield TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(100) });
+            });
+            it('should be able to query with `dataSize` filter (half-open range)', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const write1 = await TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(10) });
+                const write2 = await TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(50) });
+                const write3 = await TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(100) });
                 // insert data
-                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 });
+                const writeReply1 = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                const writeReply2 = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                const writeReply3 = await 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);
                 // testing gt
-                const recordsQuery1 = yield TestDataGenerator.generateRecordsQuery({
+                const recordsQuery1 = await 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).toBe(2);
-                expect((_b = reply1.entries) === null || _b === void 0 ? void 0 : _b.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
+                const reply1 = await dwn.processMessage(alice.did, recordsQuery1.message);
+                expect(reply1.entries?.length).toBe(2);
+                expect(reply1.entries?.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
                     Encoder.bytesToBase64Url(write2.dataBytes),
                     Encoder.bytesToBase64Url(write3.dataBytes)
                 ]));
                 // testing lt
-                const recordsQuery2 = yield TestDataGenerator.generateRecordsQuery({
+                const recordsQuery2 = await 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).toBe(2);
-                expect((_d = reply2.entries) === null || _d === void 0 ? void 0 : _d.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
+                const reply2 = await dwn.processMessage(alice.did, recordsQuery2.message);
+                expect(reply2.entries?.length).toBe(2);
+                expect(reply2.entries?.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
                     Encoder.bytesToBase64Url(write1.dataBytes),
                     Encoder.bytesToBase64Url(write2.dataBytes)
                 ]));
                 // testing gte
-                const recordsQuery3 = yield TestDataGenerator.generateRecordsQuery({
+                const recordsQuery3 = await 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).toBe(3);
-                expect((_f = reply3.entries) === null || _f === void 0 ? void 0 : _f.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
+                const reply3 = await dwn.processMessage(alice.did, recordsQuery3.message);
+                expect(reply3.entries?.length).toBe(3);
+                expect(reply3.entries?.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({
+                const recordsQuery4 = await 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).toBe(3);
-                expect((_h = reply4.entries) === null || _h === void 0 ? void 0 : _h.map((entry) => entry.encodedData)).toEqual(expect.arrayContaining([
+                const reply4 = await dwn.processMessage(alice.did, recordsQuery4.message);
+                expect(reply4.entries?.length).toBe(3);
+                expect(reply4.entries?.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;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const write1 = yield TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(10) });
-                const write2 = yield TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(50) });
-                const write3 = yield TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(100) });
+            });
+            it('should be able to range query with `dataSize` filter (open & closed range)', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const write1 = await TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(10) });
+                const write2 = await TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(50) });
+                const write3 = await TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(100) });
                 // insert data
-                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 });
+                const writeReply1 = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                const writeReply2 = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                const writeReply3 = await 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);
                 // testing range using gt & lt
-                const recordsQuery1 = yield TestDataGenerator.generateRecordsQuery({
+                const recordsQuery1 = await 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).toBe(1);
+                const reply1 = await dwn.processMessage(alice.did, recordsQuery1.message);
+                expect(reply1.entries?.length).toBe(1);
                 expect(reply1.entries[0].recordId).toBe(write2.message.recordId);
                 // testing range using gte & lt
-                const recordsQuery2 = yield TestDataGenerator.generateRecordsQuery({
+                const recordsQuery2 = await 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).toBe(2);
-                const reply2RecordIds = (_c = reply2.entries) === null || _c === void 0 ? void 0 : _c.map(e => e.recordId);
+                const reply2 = await dwn.processMessage(alice.did, recordsQuery2.message);
+                expect(reply2.entries?.length).toBe(2);
+                const reply2RecordIds = reply2.entries?.map(e => e.recordId);
                 expect(reply2RecordIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId]));
                 // testing range using gt & lte
-                const recordsQuery3 = yield TestDataGenerator.generateRecordsQuery({
+                const recordsQuery3 = await 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).toBe(1);
+                const reply3 = await dwn.processMessage(alice.did, recordsQuery3.message);
+                expect(reply3.entries?.length).toBe(1);
                 expect(reply3.entries[0].recordId).toBe(write3.message.recordId);
                 // testing range using gte & lte
-                const recordsQuery4 = yield TestDataGenerator.generateRecordsQuery({
+                const recordsQuery4 = await 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).toBe(3);
-                const reply4RecordIds = (_f = reply4.entries) === null || _f === void 0 ? void 0 : _f.map(e => e.recordId);
+                const reply4 = await dwn.processMessage(alice.did, recordsQuery4.message);
+                expect(reply4.entries?.length).toBe(3);
+                const reply4RecordIds = reply4.entries?.map(e => e.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;
+            });
+            it('should be able to range query by `dateCreated`', async () => {
                 // scenario: 3 records authored by alice, created on first of 2021, 2022, and 2023 respectively
                 // only the first 2 records share the same schema
                 const firstDayOf2021 = Time.createTimestamp({ year: 2021, month: 1, day: 1 });
                 const firstDayOf2022 = Time.createTimestamp({ year: 2022, month: 1, day: 1 });
                 const firstDayOf2023 = Time.createTimestamp({ year: 2023, month: 1, day: 1 });
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const write1 = yield TestDataGenerator.generateRecordsWrite({ author: alice, dateCreated: firstDayOf2021, messageTimestamp: firstDayOf2021 });
-                const write2 = yield TestDataGenerator.generateRecordsWrite({ author: alice, dateCreated: firstDayOf2022, messageTimestamp: firstDayOf2022 });
-                const write3 = yield TestDataGenerator.generateRecordsWrite({ author: alice, dateCreated: firstDayOf2023, messageTimestamp: firstDayOf2023 });
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const write1 = await TestDataGenerator.generateRecordsWrite({ author: alice, dateCreated: firstDayOf2021, messageTimestamp: firstDayOf2021 });
+                const write2 = await TestDataGenerator.generateRecordsWrite({ author: alice, dateCreated: firstDayOf2022, messageTimestamp: firstDayOf2022 });
+                const write3 = await TestDataGenerator.generateRecordsWrite({ author: alice, dateCreated: firstDayOf2023, messageTimestamp: firstDayOf2023 });
                 // insert data
-                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 });
+                const writeReply1 = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                const writeReply2 = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                const writeReply3 = await 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);
                 // testing `from` range
                 const lastDayOf2021 = Time.createTimestamp({ year: 2021, month: 12, day: 31 });
-                const recordsQuery1 = yield TestDataGenerator.generateRecordsQuery({
+                const recordsQuery1 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dateCreated: { from: lastDayOf2021 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const reply1 = yield dwn.processMessage(alice.did, recordsQuery1.message);
-                expect((_a = reply1.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
+                const reply1 = await dwn.processMessage(alice.did, recordsQuery1.message);
+                expect(reply1.entries?.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({
+                const recordsQuery2 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dateCreated: { to: lastDayOf2022 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const reply2 = yield dwn.processMessage(alice.did, recordsQuery2.message);
-                expect((_b = reply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(2);
+                const reply2 = await dwn.processMessage(alice.did, recordsQuery2.message);
+                expect(reply2.entries?.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({
+                const recordsQuery3 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dateCreated: { from: lastDayOf2022, to: lastDayOf2023 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const reply3 = yield dwn.processMessage(alice.did, recordsQuery3.message);
-                expect((_c = reply3.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
+                const reply3 = await dwn.processMessage(alice.did, recordsQuery3.message);
+                expect(reply3.entries?.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({
+                const recordsQuery4 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dateCreated: { from: firstDayOf2022, to: firstDayOf2023 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const reply4 = yield dwn.processMessage(alice.did, recordsQuery4.message);
-                expect((_d = reply4.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(1);
+                const reply4 = await dwn.processMessage(alice.did, recordsQuery4.message);
+                expect(reply4.entries?.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* () {
+            });
+            it('should not return records that were published and then unpublished ', async () => {
                 // scenario: 3 records authored by alice, published on first of 2021, 2022, and 2023 respectively
                 // then the records are unpublished and tested to not return when filtering for published records
-                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
                 const firstDayOf2020 = Time.createTimestamp({ year: 2020, month: 1, day: 1 });
                 const firstDayOf2021 = Time.createTimestamp({ year: 2021, month: 1, day: 1 });
                 const firstDayOf2022 = Time.createTimestamp({ year: 2022, month: 1, day: 1 });
                 const firstDayOf2023 = Time.createTimestamp({ year: 2023, month: 1, day: 1 });
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const write1 = yield TestDataGenerator.generateRecordsWrite({
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                // install protocol at a timestamp before the record timestamps so temporal lookup works for updates
+                const protocolsConfigure = await ProtocolsConfigure.create({
+                    definition: defaultTestProtocolDefinition,
+                    signer: Jws.createSigner(alice),
+                    messageTimestamp: Time.createTimestamp({ year: 2019, month: 1, day: 1 }),
+                });
+                const protoReply = await dwn.processMessage(alice.did, protocolsConfigure.message);
+                expect(protoReply.status.code).toBe(202);
+                const write1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, published: true, dateCreated: firstDayOf2020, datePublished: firstDayOf2021, messageTimestamp: firstDayOf2020
                 });
-                const write2 = yield TestDataGenerator.generateRecordsWrite({
+                const write2 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, published: true, dateCreated: firstDayOf2020, datePublished: firstDayOf2022, messageTimestamp: firstDayOf2020
                 });
-                const write3 = yield TestDataGenerator.generateRecordsWrite({
+                const write3 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, published: true, dateCreated: firstDayOf2020, datePublished: firstDayOf2023, messageTimestamp: firstDayOf2020
                 });
                 // insert data
-                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 });
+                const writeReply1 = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                const writeReply2 = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                const writeReply3 = await 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);
                 // confirm range before un-publishing.
                 const lastDayOf2021 = Time.createTimestamp({ year: 2021, month: 12, day: 31 });
-                const ownerRangeQuery = yield TestDataGenerator.generateRecordsQuery({
+                const ownerRangeQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { datePublished: { from: lastDayOf2021 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const reply1 = yield dwn.processMessage(alice.did, ownerRangeQuery.message);
-                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);
+                const reply1 = await dwn.processMessage(alice.did, ownerRangeQuery.message);
+                expect(reply1.entries?.length).toBe(2);
+                const reply1RecordIds = reply1.entries?.map(e => e.recordId);
                 expect(reply1RecordIds).toEqual(expect.arrayContaining([write2.message.recordId, write3.message.recordId]));
                 // confirm published true filter before un-publishing
-                const ownerPublishedQuery = yield TestDataGenerator.generateRecordsQuery({
+                const ownerPublishedQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { published: true },
                     dateSort: DateSort.CreatedAscending
                 });
-                let ownerPublishedReply = yield dwn.processMessage(alice.did, ownerPublishedQuery.message);
+                let ownerPublishedReply = await dwn.processMessage(alice.did, ownerPublishedQuery.message);
                 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(ownerPublishedReply.entries?.length).toBe(3);
+                const ownerPublishedIds = ownerPublishedReply.entries?.map(e => e.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({
+                const anonymousRangeQuery = await RecordsQuery.create({
                     filter: { datePublished: { from: lastDayOf2021 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                let anonymousRangeReply = yield dwn.processMessage(alice.did, anonymousRangeQuery.message);
+                let anonymousRangeReply = await dwn.processMessage(alice.did, anonymousRangeQuery.message);
                 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(anonymousRangeReply.entries?.length).toBe(2);
+                const anonymousReplyIds = anonymousRangeReply.entries?.map(e => e.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({
+                const anonymousPublishedQuery = await RecordsQuery.create({
                     filter: { published: true },
                     dateSort: DateSort.CreatedAscending
                 });
-                let anonymousPublishedReply = yield dwn.processMessage(alice.did, anonymousPublishedQuery.message);
+                let anonymousPublishedReply = await dwn.processMessage(alice.did, anonymousPublishedQuery.message);
                 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(anonymousPublishedReply.entries?.length).toBe(3);
+                const anonymousPublishedIds = anonymousPublishedReply.entries?.map(e => e.recordId);
                 expect(anonymousPublishedIds).toEqual(expect.arrayContaining([write1.message.recordId, write2.message.recordId, write3.message.recordId]));
                 //unpublish records
-                const write1Unpublish = yield RecordsWrite.createFrom({
+                const write1Unpublish = await RecordsWrite.createFrom({
                     signer: Jws.createSigner(alice),
                     recordsWriteMessage: write1.message,
                     published: false
                 });
-                const write2Unpublish = yield RecordsWrite.createFrom({
+                const write2Unpublish = await RecordsWrite.createFrom({
                     signer: Jws.createSigner(alice),
                     recordsWriteMessage: write2.message,
                     published: false
                 });
-                const write3Unpublish = yield RecordsWrite.createFrom({
+                const write3Unpublish = await RecordsWrite.createFrom({
                     signer: Jws.createSigner(alice),
                     recordsWriteMessage: write3.message,
                     published: false
                 });
-                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);
+                const unpublished1Response = await dwn.processMessage(alice.did, write1Unpublish.message);
+                const unpublished2Response = await dwn.processMessage(alice.did, write2Unpublish.message);
+                const unpublished3Response = await dwn.processMessage(alice.did, write3Unpublish.message);
                 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);
+                anonymousRangeReply = await dwn.processMessage(alice.did, anonymousRangeQuery.message);
                 expect(anonymousRangeReply.status.code).toBe(200);
-                expect((_j = anonymousRangeReply.entries) === null || _j === void 0 ? void 0 : _j.length).toBe(0);
+                expect(anonymousRangeReply.entries?.length).toBe(0);
                 // try published:true filter as an anonymous user after unpublish
-                anonymousPublishedReply = yield dwn.processMessage(alice.did, anonymousPublishedQuery.message);
+                anonymousPublishedReply = await dwn.processMessage(alice.did, anonymousPublishedQuery.message);
                 expect(anonymousPublishedReply.status.code).toBe(200);
-                expect((_k = anonymousPublishedReply.entries) === null || _k === void 0 ? void 0 : _k.length).toBe(0);
+                expect(anonymousPublishedReply.entries?.length).toBe(0);
                 // try datePublished range query as owner after unpublish
-                const ownerRangeReply = yield dwn.processMessage(alice.did, ownerRangeQuery.message);
+                const ownerRangeReply = await dwn.processMessage(alice.did, ownerRangeQuery.message);
                 expect(ownerRangeReply.status.code).toBe(200);
-                expect((_l = ownerRangeReply.entries) === null || _l === void 0 ? void 0 : _l.length).toBe(0);
+                expect(ownerRangeReply.entries?.length).toBe(0);
                 // try published:true filter as owner after unpublish
-                ownerPublishedReply = yield dwn.processMessage(alice.did, ownerPublishedQuery.message);
+                ownerPublishedReply = await dwn.processMessage(alice.did, ownerPublishedQuery.message);
                 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* () {
+                expect(ownerPublishedReply.entries?.length).toBe(0);
+            });
+            it('should be able to range query by `datePublished`', async () => {
                 // scenario: 3 records authored by alice, published on first of 2021, 2022, and 2023 respectively
                 // all 3 records are created on first of 2020
-                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
                 const firstDayOf2020 = Time.createTimestamp({ year: 2020, month: 1, day: 1 });
                 const firstDayOf2021 = Time.createTimestamp({ year: 2021, month: 1, day: 1 });
                 const firstDayOf2022 = Time.createTimestamp({ year: 2022, month: 1, day: 1 });
                 const firstDayOf2023 = Time.createTimestamp({ year: 2023, month: 1, day: 1 });
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const write1 = yield TestDataGenerator.generateRecordsWrite({
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const write1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, published: true, dateCreated: firstDayOf2020, datePublished: firstDayOf2021, messageTimestamp: firstDayOf2020
                 });
-                const write2 = yield TestDataGenerator.generateRecordsWrite({
+                const write2 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, published: true, dateCreated: firstDayOf2020, datePublished: firstDayOf2022, messageTimestamp: firstDayOf2020
                 });
-                const write3 = yield TestDataGenerator.generateRecordsWrite({
+                const write3 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, published: true, dateCreated: firstDayOf2020, datePublished: firstDayOf2023, messageTimestamp: firstDayOf2020
                 });
                 // insert data
-                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 });
+                const writeReply1 = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                const writeReply2 = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                const writeReply3 = await 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);
                 // testing `from` range
                 const lastDayOf2021 = Time.createTimestamp({ year: 2021, month: 12, day: 31 });
-                const recordsQuery1 = yield TestDataGenerator.generateRecordsQuery({
+                const recordsQuery1 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { datePublished: { from: lastDayOf2021 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const reply1 = yield dwn.processMessage(alice.did, recordsQuery1.message);
-                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);
+                const reply1 = await dwn.processMessage(alice.did, recordsQuery1.message);
+                expect(reply1.entries?.length).toBe(2);
+                const reply1RecordIds = reply1.entries?.map(e => e.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({
+                const recordsQuery2 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { datePublished: { to: lastDayOf2022 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const reply2 = yield dwn.processMessage(alice.did, recordsQuery2.message);
-                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);
+                const reply2 = await dwn.processMessage(alice.did, recordsQuery2.message);
+                expect(reply2.entries?.length).toBe(2);
+                const reply2RecordIds = reply2.entries?.map(e => e.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({
+                const recordsQuery3 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { datePublished: { from: lastDayOf2022, to: lastDayOf2023 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const reply3 = yield dwn.processMessage(alice.did, recordsQuery3.message);
-                expect((_e = reply3.entries) === null || _e === void 0 ? void 0 : _e.length).toBe(1);
+                const reply3 = await dwn.processMessage(alice.did, recordsQuery3.message);
+                expect(reply3.entries?.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({
+                const recordsQuery4 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { datePublished: { from: firstDayOf2022, to: firstDayOf2023 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const reply4 = yield dwn.processMessage(alice.did, recordsQuery4.message);
-                expect((_f = reply4.entries) === null || _f === void 0 ? void 0 : _f.length).toBe(1);
+                const reply4 = await dwn.processMessage(alice.did, recordsQuery4.message);
+                expect(reply4.entries?.length).toBe(1);
                 expect(reply4.entries[0].recordId).toBe(write2.message.recordId);
                 // check for anonymous range query
-                const anonymousRecordQuery = yield RecordsQuery.create({
+                const anonymousRecordQuery = await RecordsQuery.create({
                     filter: { datePublished: { from: lastDayOf2021 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const anonymousReply = yield dwn.processMessage(alice.did, anonymousRecordQuery.message);
+                const anonymousReply = await dwn.processMessage(alice.did, anonymousRecordQuery.message);
                 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(anonymousReply.entries?.length).toBe(2);
+                const anonymousReplyIds = anonymousReply.entries?.map(e => e.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({
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const nonOwnerRange = await TestDataGenerator.generateRecordsQuery({
                     author: bob,
                     filter: { datePublished: { from: lastDayOf2021 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const nonOwnerReply = yield dwn.processMessage(alice.did, nonOwnerRange.message);
+                const nonOwnerReply = await dwn.processMessage(alice.did, nonOwnerRange.message);
                 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(nonOwnerReply.entries?.length).toBe(2);
+                const nonOwnerReplyIds = nonOwnerReply.entries?.map(e => e.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* () {
+            });
+            it('should be able to range query by `dateUpdated`', async () => {
                 // scenario: alice creates 3 records on the first day of 2020.
                 // alice then updates these records to published on first of 2021, 2022, and 2023 respectively
                 // this should update the messageTimestamp on the respective messages
-                var _a, _b, _c, _d, _e, _f;
                 const firstDayOf2020 = Time.createTimestamp({ year: 2020, month: 1, day: 1 });
                 const firstDayOf2021 = Time.createTimestamp({ year: 2021, month: 1, day: 1 });
                 const firstDayOf2022 = Time.createTimestamp({ year: 2022, month: 1, day: 1 });
                 const firstDayOf2023 = Time.createTimestamp({ year: 2023, month: 1, day: 1 });
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const write1 = yield TestDataGenerator.generateRecordsWrite({
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                // install protocol at a timestamp before the record timestamps so temporal lookup works for updates
+                const protocolsConfigure = await ProtocolsConfigure.create({
+                    definition: defaultTestProtocolDefinition,
+                    signer: Jws.createSigner(alice),
+                    messageTimestamp: Time.createTimestamp({ year: 2019, month: 1, day: 1 }),
+                });
+                const protoReply = await dwn.processMessage(alice.did, protocolsConfigure.message);
+                expect(protoReply.status.code).toBe(202);
+                const write1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, dateCreated: firstDayOf2020, messageTimestamp: firstDayOf2020
                 });
-                const write2 = yield TestDataGenerator.generateRecordsWrite({
+                const write2 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, dateCreated: firstDayOf2020, messageTimestamp: firstDayOf2020
                 });
-                const write3 = yield TestDataGenerator.generateRecordsWrite({
+                const write3 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, dateCreated: firstDayOf2020, messageTimestamp: firstDayOf2020
                 });
                 // insert data
-                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 });
+                const writeReply1 = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                const writeReply2 = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                const writeReply3 = await 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 to published
-                const write1Update = yield RecordsWrite.createFrom({
+                const write1Update = await RecordsWrite.createFrom({
                     recordsWriteMessage: write1.message,
                     published: true,
                     messageTimestamp: firstDayOf2021,
                     datePublished: firstDayOf2021,
                     signer: Jws.createSigner(alice)
                 });
-                const write2Update = yield RecordsWrite.createFrom({
+                const write2Update = await RecordsWrite.createFrom({
                     recordsWriteMessage: write2.message,
                     published: true,
                     messageTimestamp: firstDayOf2022,
                     datePublished: firstDayOf2022,
                     signer: Jws.createSigner(alice)
                 });
-                const write3Update = yield RecordsWrite.createFrom({
+                const write3Update = await RecordsWrite.createFrom({
                     recordsWriteMessage: write3.message,
                     published: true,
                     messageTimestamp: firstDayOf2023,
                     datePublished: firstDayOf2023,
                     signer: Jws.createSigner(alice)
                 });
-                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);
+                const writeReplyUpdate1 = await dwn.processMessage(alice.did, write1Update.message);
+                const writeReplyUpdate2 = await dwn.processMessage(alice.did, write2Update.message);
+                const writeReplyUpdate3 = await dwn.processMessage(alice.did, write3Update.message);
                 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({
+                const recordsQuery1 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dateUpdated: { from: lastDayOf2021 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const reply1 = yield dwn.processMessage(alice.did, recordsQuery1.message);
-                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);
+                const reply1 = await dwn.processMessage(alice.did, recordsQuery1.message);
+                expect(reply1.entries?.length).toBe(2);
+                const reply1RecordIds = reply1.entries?.map(e => e.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({
+                const recordsQuery2 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dateUpdated: { to: lastDayOf2022 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const reply2 = yield dwn.processMessage(alice.did, recordsQuery2.message);
-                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);
+                const reply2 = await dwn.processMessage(alice.did, recordsQuery2.message);
+                expect(reply2.entries?.length).toBe(2);
+                const reply2RecordIds = reply2.entries?.map(e => e.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({
+                const recordsQuery3 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dateUpdated: { from: lastDayOf2022, to: lastDayOf2023 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const reply3 = yield dwn.processMessage(alice.did, recordsQuery3.message);
-                expect((_e = reply3.entries) === null || _e === void 0 ? void 0 : _e.length).toBe(1);
+                const reply3 = await dwn.processMessage(alice.did, recordsQuery3.message);
+                expect(reply3.entries?.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({
+                const recordsQuery4 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { dateUpdated: { from: firstDayOf2022, to: firstDayOf2023 } },
                     dateSort: DateSort.CreatedAscending
                 });
-                const reply4 = yield dwn.processMessage(alice.did, recordsQuery4.message);
-                expect((_f = reply4.entries) === null || _f === void 0 ? void 0 : _f.length).toBe(1);
+                const reply4 = await dwn.processMessage(alice.did, recordsQuery4.message);
+                expect(reply4.entries?.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;
+            });
+            it('should be able use range and exact match queries at the same time', async () => {
                 // scenario: 3 records authored by alice, created on first of 2021, 2022, and 2023 respectively
                 // only the first 2 records share the same schema
                 const firstDayOf2021 = Time.createTimestamp({ year: 2021, month: 1, day: 1 });
                 const firstDayOf2022 = Time.createTimestamp({ year: 2022, month: 1, day: 1 });
                 const firstDayOf2023 = Time.createTimestamp({ year: 2023, month: 1, day: 1 });
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const schema = '2021And2022Schema';
-                const write1 = yield TestDataGenerator.generateRecordsWrite({
+                const write1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, dateCreated: firstDayOf2021, messageTimestamp: firstDayOf2021, schema
                 });
-                const write2 = yield TestDataGenerator.generateRecordsWrite({
+                const write2 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, dateCreated: firstDayOf2022, messageTimestamp: firstDayOf2022, schema
                 });
-                const write3 = yield TestDataGenerator.generateRecordsWrite({
+                const write3 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, dateCreated: firstDayOf2023, messageTimestamp: firstDayOf2023
                 });
                 // insert data
-                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 });
+                const writeReply1 = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                const writeReply2 = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                const writeReply3 = await 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);
                 // 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 });
-                const recordsQuery5 = yield TestDataGenerator.generateRecordsQuery({
+                const recordsQuery5 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         schema, // by itself selects the first 2 records
@@ -1052,393 +1049,401 @@ 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).toBe(1);
+                const reply = await dwn.processMessage(alice.did, recordsQuery5.message);
+                expect(reply.entries?.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;
-                const alice = yield TestDataGenerator.generatePersona();
-                const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
+            });
+            it('should include `authorization` in returned records', async () => {
+                const alice = await TestDataGenerator.generatePersona();
+                const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
                 // setting up a stub method resolver
                 const mockResolution = TestDataGenerator.createDidResolutionResult(alice);
                 sinon.stub(didResolver, 'resolve').resolves(mockResolution);
-                const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
-                const queryData = yield TestDataGenerator.generateRecordsQuery({
+                const queryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema: message.descriptor.schema }
                 });
-                const queryReply = yield dwn.processMessage(alice.did, queryData.message);
+                const queryReply = await dwn.processMessage(alice.did, queryData.message);
                 expect(queryReply.status.code).toBe(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(queryReply.entries?.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* () {
+            });
+            it('should include `attestation` in returned records', async () => {
                 // scenario: alice and bob attest to a message alice authored
-                var _a, _b, _c;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [alice] });
-                const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [alice] });
+                const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
-                const queryData = yield TestDataGenerator.generateRecordsQuery({
+                const queryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema: message.descriptor.schema }
                 });
-                const queryReply = yield dwn.processMessage(alice.did, queryData.message);
+                const queryReply = await dwn.processMessage(alice.did, queryData.message);
                 expect(queryReply.status.code).toBe(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(queryReply.entries?.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).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;
+                expect(recordsWriteMessage.attestation?.signatures?.length).toBe(1);
+            });
+            it('should omit records that are not published if `dateSort` sorts on `datePublished`', async () => {
                 // setup: 2 records in DWN: 1 published and 1 unpublished
-                const alice = yield TestDataGenerator.generatePersona();
+                const alice = await TestDataGenerator.generatePersona();
                 const schema = 'aSchema';
-                const publishedWriteData = yield TestDataGenerator.generateRecordsWrite({
+                const publishedWriteData = await TestDataGenerator.generateRecordsWrite({
                     author: alice, schema, published: true
                 });
-                const unpublishedWriteData = yield TestDataGenerator.generateRecordsWrite({
+                const unpublishedWriteData = await TestDataGenerator.generateRecordsWrite({
                     author: alice, schema
                 });
                 // setting up a stub method resolver
                 const mockResolution = TestDataGenerator.createDidResolutionResult(alice);
                 ;
                 sinon.stub(didResolver, 'resolve').resolves(mockResolution);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // 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 });
+                const publishedWriteReply = await dwn.processMessage(alice.did, publishedWriteData.message, { dataStream: publishedWriteData.dataStream });
+                const unpublishedWriteReply = await dwn.processMessage(alice.did, unpublishedWriteData.message, { dataStream: unpublishedWriteData.dataStream });
                 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({
+                const publishedAscendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.PublishedAscending,
                     filter: { schema }
                 });
-                const publishedAscendingQueryReply = yield dwn.processMessage(alice.did, publishedAscendingQueryData.message);
-                expect((_a = publishedAscendingQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                const publishedAscendingQueryReply = await dwn.processMessage(alice.did, publishedAscendingQueryData.message);
+                expect(publishedAscendingQueryReply.entries?.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({
+                const publishedDescendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.PublishedDescending,
                     filter: { schema }
                 });
-                const publishedDescendingQueryReply = yield dwn.processMessage(alice.did, publishedDescendingQueryData.message);
-                expect((_b = publishedDescendingQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                const publishedDescendingQueryReply = await dwn.processMessage(alice.did, publishedDescendingQueryData.message);
+                expect(publishedDescendingQueryReply.entries?.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;
+            });
+            it('should sort records if `dateSort` is specified with and without a cursor', async () => {
                 // insert three messages into DB
-                const alice = yield TestDataGenerator.generatePersona();
+                const alice = await TestDataGenerator.generatePersona();
                 const schema = 'aSchema';
                 const published = true;
-                const write1Data = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema, published });
-                yield Time.minimalSleep();
-                const write2Data = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema, published });
-                yield Time.minimalSleep();
-                const write3Data = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema, published });
+                const write1Data = await TestDataGenerator.generateRecordsWrite({ author: alice, schema, published });
+                await Time.minimalSleep();
+                const write2Data = await TestDataGenerator.generateRecordsWrite({ author: alice, schema, published });
+                await Time.minimalSleep();
+                const write3Data = await TestDataGenerator.generateRecordsWrite({ author: alice, schema, published });
                 // setting up a stub method resolver
                 const mockResolution = TestDataGenerator.createDidResolutionResult(alice);
                 ;
                 sinon.stub(didResolver, 'resolve').resolves(mockResolution);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // 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 });
+                const writeReply2 = await dwn.processMessage(alice.did, write2Data.message, { dataStream: write2Data.dataStream });
+                const writeReply1 = await dwn.processMessage(alice.did, write1Data.message, { dataStream: write1Data.dataStream });
+                const writeReply3 = await 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);
                 // createdAscending test
-                let createdAscendingQueryData = yield TestDataGenerator.generateRecordsQuery({
+                let createdAscendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.CreatedAscending,
                     filter: { schema }
                 });
-                let createdAscendingQueryReply = yield dwn.processMessage(alice.did, createdAscendingQueryData.message);
+                let createdAscendingQueryReply = await dwn.processMessage(alice.did, createdAscendingQueryData.message);
                 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);
+                expect(createdAscendingQueryReply.entries?.[0].recordId).toBe(write1Data.message.recordId);
+                expect(createdAscendingQueryReply.entries?.[1].recordId).toBe(write2Data.message.recordId);
+                expect(createdAscendingQueryReply.entries?.[2].recordId).toBe(write3Data.message.recordId);
                 // to test with a cursor we first get a single record
-                createdAscendingQueryData = yield TestDataGenerator.generateRecordsQuery({
+                createdAscendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.CreatedAscending,
                     filter: { schema },
                     pagination: { limit: 1 }
                 });
-                createdAscendingQueryReply = yield dwn.processMessage(alice.did, createdAscendingQueryData.message);
+                createdAscendingQueryReply = await dwn.processMessage(alice.did, createdAscendingQueryData.message);
                 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({
+                createdAscendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.CreatedAscending,
                     filter: { schema },
                     pagination: { cursor: createdAscendingQueryReply.cursor }
                 });
-                createdAscendingQueryReply = yield dwn.processMessage(alice.did, createdAscendingQueryData.message);
+                createdAscendingQueryReply = await dwn.processMessage(alice.did, createdAscendingQueryData.message);
                 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({
+                let createdDescendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.CreatedDescending,
                     filter: { schema }
                 });
-                let createdDescendingQueryReply = yield dwn.processMessage(alice.did, createdDescendingQueryData.message);
+                let createdDescendingQueryReply = await dwn.processMessage(alice.did, createdDescendingQueryData.message);
                 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);
+                expect(createdDescendingQueryReply.entries?.[0].recordId).toBe(write3Data.message.recordId);
+                expect(createdDescendingQueryReply.entries?.[1].recordId).toBe(write2Data.message.recordId);
+                expect(createdDescendingQueryReply.entries?.[2].recordId).toBe(write1Data.message.recordId);
                 // to test with a cursor we first get a single record
-                createdDescendingQueryData = yield TestDataGenerator.generateRecordsQuery({
+                createdDescendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.CreatedDescending,
                     filter: { schema },
                     pagination: { limit: 1 }
                 });
-                createdDescendingQueryReply = yield dwn.processMessage(alice.did, createdDescendingQueryData.message);
+                createdDescendingQueryReply = await dwn.processMessage(alice.did, createdDescendingQueryData.message);
                 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({
+                createdDescendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.CreatedDescending,
                     filter: { schema },
                     pagination: { cursor: createdDescendingQueryReply.cursor }
                 });
-                createdDescendingQueryReply = yield dwn.processMessage(alice.did, createdDescendingQueryData.message);
+                createdDescendingQueryReply = await dwn.processMessage(alice.did, createdDescendingQueryData.message);
                 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({
+                let publishedAscendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.PublishedAscending,
                     filter: { schema }
                 });
-                let publishedAscendingQueryReply = yield dwn.processMessage(alice.did, publishedAscendingQueryData.message);
+                let publishedAscendingQueryReply = await dwn.processMessage(alice.did, publishedAscendingQueryData.message);
                 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);
+                expect(publishedAscendingQueryReply.entries?.[0].recordId).toBe(write1Data.message.recordId);
+                expect(publishedAscendingQueryReply.entries?.[1].recordId).toBe(write2Data.message.recordId);
+                expect(publishedAscendingQueryReply.entries?.[2].recordId).toBe(write3Data.message.recordId);
                 // to test with a cursor we first get a single record
-                publishedAscendingQueryData = yield TestDataGenerator.generateRecordsQuery({
+                publishedAscendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.PublishedAscending,
                     filter: { schema },
                     pagination: { limit: 1 }
                 });
-                publishedAscendingQueryReply = yield dwn.processMessage(alice.did, publishedAscendingQueryData.message);
+                publishedAscendingQueryReply = await dwn.processMessage(alice.did, publishedAscendingQueryData.message);
                 expect(publishedAscendingQueryReply.entries.length).toBe(1);
-                publishedAscendingQueryData = yield TestDataGenerator.generateRecordsQuery({
+                publishedAscendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.PublishedAscending,
                     filter: { schema },
                     pagination: { cursor: publishedAscendingQueryReply.cursor }
                 });
-                publishedAscendingQueryReply = yield dwn.processMessage(alice.did, publishedAscendingQueryData.message);
+                publishedAscendingQueryReply = await dwn.processMessage(alice.did, publishedAscendingQueryData.message);
                 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({
+                let publishedDescendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.PublishedDescending,
                     filter: { schema }
                 });
-                let publishedDescendingQueryReply = yield dwn.processMessage(alice.did, publishedDescendingQueryData.message);
+                let publishedDescendingQueryReply = await dwn.processMessage(alice.did, publishedDescendingQueryData.message);
                 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({
+                expect(publishedDescendingQueryReply.entries?.[0].recordId).toBe(write3Data.message.recordId);
+                expect(publishedDescendingQueryReply.entries?.[1].recordId).toBe(write2Data.message.recordId);
+                expect(publishedDescendingQueryReply.entries?.[2].recordId).toBe(write1Data.message.recordId);
+                publishedDescendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.PublishedDescending,
                     filter: { schema },
                     pagination: { limit: 1 }
                 });
-                publishedDescendingQueryReply = yield dwn.processMessage(alice.did, publishedDescendingQueryData.message);
+                publishedDescendingQueryReply = await dwn.processMessage(alice.did, publishedDescendingQueryData.message);
                 expect(publishedDescendingQueryReply.entries.length).toBe(1);
-                publishedDescendingQueryData = yield TestDataGenerator.generateRecordsQuery({
+                publishedDescendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.PublishedDescending,
                     filter: { schema },
                     pagination: { cursor: publishedDescendingQueryReply.cursor }
                 });
-                publishedDescendingQueryReply = yield dwn.processMessage(alice.did, publishedDescendingQueryData.message);
+                publishedDescendingQueryReply = await dwn.processMessage(alice.did, publishedDescendingQueryData.message);
                 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;
+            });
+            it('should sort records by `updatedAscending` and `updatedDescending`', async () => {
                 // insert three messages into DB
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 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 });
+                const write1Data = await TestDataGenerator.generateRecordsWrite({ author: alice, schema });
+                await Time.minimalSleep();
+                const write2Data = await TestDataGenerator.generateRecordsWrite({ author: alice, schema });
+                await Time.minimalSleep();
+                const write3Data = await 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 });
+                const writeReply2 = await dwn.processMessage(alice.did, write2Data.message, { dataStream: write2Data.dataStream });
+                const writeReply1 = await dwn.processMessage(alice.did, write1Data.message, { dataStream: write1Data.dataStream });
+                const writeReply3 = await 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({
+                const updatedAscendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.UpdatedAscending,
                     filter: { schema }
                 });
-                const updatedAscendingQueryReply = yield dwn.processMessage(alice.did, updatedAscendingQueryData.message);
+                const updatedAscendingQueryReply = await 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);
+                expect(updatedAscendingQueryReply.entries?.[0].recordId).toBe(write1Data.message.recordId);
+                expect(updatedAscendingQueryReply.entries?.[1].recordId).toBe(write2Data.message.recordId);
+                expect(updatedAscendingQueryReply.entries?.[2].recordId).toBe(write3Data.message.recordId);
                 // updatedDescending test
-                const updatedDescendingQueryData = yield TestDataGenerator.generateRecordsQuery({
+                const updatedDescendingQueryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.UpdatedDescending,
                     filter: { schema }
                 });
-                const updatedDescendingQueryReply = yield dwn.processMessage(alice.did, updatedDescendingQueryData.message);
+                const updatedDescendingQueryReply = await 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* () {
+                expect(updatedDescendingQueryReply.entries?.[0].recordId).toBe(write3Data.message.recordId);
+                expect(updatedDescendingQueryReply.entries?.[1].recordId).toBe(write2Data.message.recordId);
+                expect(updatedDescendingQueryReply.entries?.[2].recordId).toBe(write1Data.message.recordId);
+            });
+            it('should sort by `messageTimestamp` (not `dateCreated`) when using updated sort with genuinely updated records', async () => {
                 // 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 alice = await TestDataGenerator.generateDidKeyPersona();
+                // install protocol at a timestamp before the record timestamps so temporal lookup works for updates
+                const protocolsConfigure = await ProtocolsConfigure.create({
+                    definition: defaultTestProtocolDefinition,
+                    signer: Jws.createSigner(alice),
+                    messageTimestamp: Time.createTimestamp({ year: 2019, month: 1, day: 1 }),
+                });
+                const protoReply = await dwn.processMessage(alice.did, protocolsConfigure.message);
+                expect(protoReply.status.code).toBe(202);
                 const schema = 'aSchema';
-                const write1 = yield TestDataGenerator.generateRecordsWrite({
+                const write1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, schema, dateCreated: createdTimestamp, messageTimestamp: createdTimestamp,
                 });
-                const write2 = yield TestDataGenerator.generateRecordsWrite({
+                const write2 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, schema, dateCreated: createdTimestamp, messageTimestamp: createdTimestamp,
                 });
-                const write3 = yield TestDataGenerator.generateRecordsWrite({
+                const write3 = await 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 });
+                const writeReply1 = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                const writeReply2 = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                const writeReply3 = await 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({
+                const update3 = await RecordsWrite.createFrom({
                     recordsWriteMessage: write3.message,
                     messageTimestamp: Time.createTimestamp({ year: 2021, month: 1, day: 1 }),
                     signer: Jws.createSigner(alice),
                 });
-                const update2 = yield RecordsWrite.createFrom({
+                const update2 = await RecordsWrite.createFrom({
                     recordsWriteMessage: write2.message,
                     messageTimestamp: Time.createTimestamp({ year: 2022, month: 1, day: 1 }),
                     signer: Jws.createSigner(alice),
                 });
-                const update1 = yield RecordsWrite.createFrom({
+                const update1 = await 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);
+                const updateReply3 = await dwn.processMessage(alice.did, update3.message);
+                const updateReply2 = await dwn.processMessage(alice.did, update2.message);
+                const updateReply1 = await 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({
+                const updatedAscQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.UpdatedAscending,
                     filter: { schema }
                 });
-                const updatedAscReply = yield dwn.processMessage(alice.did, updatedAscQuery.message);
+                const updatedAscReply = await 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({
+                const updatedDescQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     dateSort: DateSort.UpdatedDescending,
                     filter: { schema }
                 });
-                const updatedDescReply = yield dwn.processMessage(alice.did, updatedDescQuery.message);
+                const updatedDescReply = await 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;
+            });
+            it('should tiebreak using `messageCid` when sorting encounters identical values', async () => {
                 // setup: 3 messages with the same `dateCreated` value
                 const dateCreated = Time.getCurrentTimestamp();
                 const messageTimestamp = dateCreated;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const schema = 'aSchema';
                 const published = true;
-                const write1Data = yield TestDataGenerator.generateRecordsWrite({ messageTimestamp, dateCreated, author: alice, schema, published });
-                const write2Data = yield TestDataGenerator.generateRecordsWrite({ messageTimestamp, dateCreated, author: alice, schema, published });
-                const write3Data = yield TestDataGenerator.generateRecordsWrite({ messageTimestamp, dateCreated, author: alice, schema, published });
+                const write1Data = await TestDataGenerator.generateRecordsWrite({ messageTimestamp, dateCreated, author: alice, schema, published });
+                const write2Data = await TestDataGenerator.generateRecordsWrite({ messageTimestamp, dateCreated, author: alice, schema, published });
+                const write3Data = await TestDataGenerator.generateRecordsWrite({ messageTimestamp, dateCreated, author: alice, schema, published });
                 // sort the messages in lexicographical order against `messageCid`
-                const [oldestWrite, middleWrite, newestWrite] = yield ArrayUtility.asyncSort([write1Data, write2Data, write3Data], (messageDataA, messageDataB) => { return Message.compareCid(messageDataA.message, messageDataB.message); });
+                const [oldestWrite, middleWrite, newestWrite] = await 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 });
+                const reply2 = await dwn.processMessage(alice.did, middleWrite.message, { dataStream: middleWrite.dataStream });
                 expect(reply2.status.code).toBe(202);
-                const reply3 = yield dwn.processMessage(alice.did, newestWrite.message, { dataStream: newestWrite.dataStream });
+                const reply3 = await dwn.processMessage(alice.did, newestWrite.message, { dataStream: newestWrite.dataStream });
                 expect(reply3.status.code).toBe(202);
-                const reply1 = yield dwn.processMessage(alice.did, oldestWrite.message, { dataStream: oldestWrite.dataStream });
+                const reply1 = await dwn.processMessage(alice.did, oldestWrite.message, { dataStream: oldestWrite.dataStream });
                 expect(reply1.status.code).toBe(202);
-                const queryMessageData = yield TestDataGenerator.generateRecordsQuery({
+                const queryMessageData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema },
                     dateSort: DateSort.CreatedAscending
                 });
-                const queryReply = yield dwn.processMessage(alice.did, queryMessageData.message);
+                const queryReply = await dwn.processMessage(alice.did, queryMessageData.message);
                 // verify that messages returned are sorted/tiebreak by `messageCid`
                 expect(queryReply.status.code).toBe(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(3);
+                expect(queryReply.entries?.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({
+                const queryMessageDescending = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema },
                     dateSort: DateSort.CreatedDescending
                 });
-                const descendingReply = yield dwn.processMessage(alice.did, queryMessageDescending.message);
+                const descendingReply = await dwn.processMessage(alice.did, queryMessageDescending.message);
                 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;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const messages = yield Promise.all(Array(12).fill({}).map(_ => TestDataGenerator.generateRecordsWrite({
+            });
+            it('should paginate all records in ascending order', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const messages = await Promise.all(Array(12).fill({}).map(_ => TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     schema: 'https://schema'
                 })));
                 for (const message of messages) {
-                    const result = yield dwn.processMessage(alice.did, message.message, { dataStream: message.dataStream });
+                    const result = await dwn.processMessage(alice.did, message.message, { dataStream: message.dataStream });
                     expect(result.status.code).toBe(202);
                 }
                 const limit = 5;
                 const results = [];
                 let cursor;
                 while (true) {
-                    const pageQuery = yield TestDataGenerator.generateRecordsQuery({
+                    const pageQuery = await TestDataGenerator.generateRecordsQuery({
                         author: alice,
                         filter: {
                             schema: 'https://schema'
@@ -1449,10 +1454,10 @@ export function testRecordsQueryHandler() {
                         },
                         dateSort: DateSort.CreatedAscending
                     });
-                    const pageReply = yield dwn.processMessage(alice.did, pageQuery.message);
+                    const pageReply = await dwn.processMessage(alice.did, pageQuery.message);
                     expect(pageReply.status.code).toBe(200);
                     cursor = pageReply.cursor;
-                    expect((_a = pageReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBeLessThanOrEqual(limit);
+                    expect(pageReply.entries?.length).toBeLessThanOrEqual(limit);
                     results.push(...pageReply.entries);
                     if (cursor === undefined) {
                         break;
@@ -1460,23 +1465,23 @@ export function testRecordsQueryHandler() {
                 }
                 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* () {
-                var _a;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const messages = yield Promise.all(Array(12).fill({}).map(_ => TestDataGenerator.generateRecordsWrite({
+            });
+            it('should paginate all records in descending order', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const messages = await Promise.all(Array(12).fill({}).map(_ => TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     schema: 'https://schema'
                 })));
                 for (const message of messages) {
-                    const result = yield dwn.processMessage(alice.did, message.message, { dataStream: message.dataStream });
+                    const result = await dwn.processMessage(alice.did, message.message, { dataStream: message.dataStream });
                     expect(result.status.code).toBe(202);
                 }
                 const limit = 5;
                 const results = [];
                 let cursor;
                 while (true) {
-                    const pageQuery = yield TestDataGenerator.generateRecordsQuery({
+                    const pageQuery = await TestDataGenerator.generateRecordsQuery({
                         author: alice,
                         filter: {
                             schema: 'https://schema'
@@ -1487,10 +1492,10 @@ export function testRecordsQueryHandler() {
                         },
                         dateSort: DateSort.CreatedDescending,
                     });
-                    const pageReply = yield dwn.processMessage(alice.did, pageQuery.message);
+                    const pageReply = await dwn.processMessage(alice.did, pageQuery.message);
                     expect(pageReply.status.code).toBe(200);
                     cursor = pageReply.cursor;
-                    expect((_a = pageReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBeLessThanOrEqual(limit);
+                    expect(pageReply.entries?.length).toBeLessThanOrEqual(limit);
                     results.push(...pageReply.entries);
                     if (cursor === undefined) {
                         break;
@@ -1498,61 +1503,60 @@ export function testRecordsQueryHandler() {
                 }
                 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* () {
-                var _a, _b;
+            });
+            it('should allow an anonymous unauthenticated query to return published records', async () => {
                 // write 2 records into Alice's DB:
                 // 1st is unpublished
                 // 2nd is published
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                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 });
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const record1Data = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'https://schema1', published: false });
+                const record2Data = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'https://schema2', published: true });
+                const recordsWrite1Reply = await dwn.processMessage(alice.did, record1Data.message, { dataStream: record1Data.dataStream });
                 expect(recordsWrite1Reply.status.code).toBe(202);
-                const recordsWrite2Reply = yield dwn.processMessage(alice.did, record2Data.message, { dataStream: record2Data.dataStream });
+                const recordsWrite2Reply = await dwn.processMessage(alice.did, record2Data.message, { dataStream: record2Data.dataStream });
                 expect(recordsWrite2Reply.status.code).toBe(202);
                 // test correctness for anonymous query
-                const anonymousQueryMessageData = yield TestDataGenerator.generateRecordsQuery({
+                const anonymousQueryMessageData = await TestDataGenerator.generateRecordsQuery({
                     anonymous: true,
                     filter: { dateCreated: { from: '2000-01-01T10:20:30.123456Z' } }
                 });
                 // sanity check
                 expect(anonymousQueryMessageData.message.authorization).toBeUndefined();
-                const replyToQuery = yield dwn.processMessage(alice.did, anonymousQueryMessageData.message);
+                const replyToQuery = await dwn.processMessage(alice.did, anonymousQueryMessageData.message);
                 expect(replyToQuery.status.code).toBe(200);
-                expect((_a = replyToQuery.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(replyToQuery.entries?.length).toBe(1);
                 expect(replyToQuery.entries[0].descriptor.schema).toBe('https://schema2');
                 // explicitly for published records
-                const anonymousQueryPublished = yield TestDataGenerator.generateRecordsQuery({
+                const anonymousQueryPublished = await TestDataGenerator.generateRecordsQuery({
                     anonymous: true,
                     filter: { dateCreated: { from: '2000-01-01T10:20:30.123456Z' }, published: true }
                 });
                 // sanity check
                 expect(anonymousQueryPublished.message.authorization).toBeUndefined();
                 // should return the published records
-                const publishedReply = yield dwn.processMessage(alice.did, anonymousQueryPublished.message);
+                const publishedReply = await dwn.processMessage(alice.did, anonymousQueryPublished.message);
                 expect(publishedReply.status.code).toBe(200);
-                expect((_b = publishedReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(publishedReply.entries?.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* () {
+            });
+            it('should only return published records and unpublished records that are meant for specific recipient(s)', async () => {
                 // scenario: Alice installs a free-for-all protocol on her DWN
                 // She writes both private and public messages for bob and carol, carol and bob also write public and privet messages for alice and each other
                 // Bob, Alice and Carol should only be able to see private messages pertaining to themselves, and any public messages filtered by a recipient
                 // Bob, Alice and Carol should be able to filter for ONLY public messages or ONLY private messages
-                var _a, _b, _c, _d;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                const carol = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const carol = await TestDataGenerator.generateDidKeyPersona();
                 // install the free-for-all protocol on Alice's DWN
-                const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition: freeForAll
                 });
-                const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                const protocolConfigureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                 expect(protocolConfigureReply.status.code).toBe(202);
                 // write private records for bob and carol
-                const alicePrivateToBob = yield TestDataGenerator.generateRecordsWrite({
+                const alicePrivateToBob = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: bob.did,
                     protocol: freeForAll.protocol,
@@ -1560,9 +1564,9 @@ export function testRecordsQueryHandler() {
                     schema: freeForAll.types.post.schema,
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
-                const alicePrivateToBobReply = yield dwn.processMessage(alice.did, alicePrivateToBob.message, { dataStream: alicePrivateToBob.dataStream });
+                const alicePrivateToBobReply = await dwn.processMessage(alice.did, alicePrivateToBob.message, { dataStream: alicePrivateToBob.dataStream });
                 expect(alicePrivateToBobReply.status.code).toBe(202);
-                const alicePrivateToCarol = yield TestDataGenerator.generateRecordsWrite({
+                const alicePrivateToCarol = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: carol.did,
                     protocol: freeForAll.protocol,
@@ -1570,12 +1574,12 @@ export function testRecordsQueryHandler() {
                     schema: freeForAll.types.post.schema,
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
-                const alicePrivateToCarolReply = yield dwn.processMessage(alice.did, alicePrivateToCarol.message, {
+                const alicePrivateToCarolReply = await dwn.processMessage(alice.did, alicePrivateToCarol.message, {
                     dataStream: alicePrivateToCarol.dataStream
                 });
                 expect(alicePrivateToCarolReply.status.code).toBe(202);
                 // write private records from carol to alice and bob
-                const carolPrivateToAlice = yield TestDataGenerator.generateRecordsWrite({
+                const carolPrivateToAlice = await TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     recipient: alice.did,
                     protocol: freeForAll.protocol,
@@ -1583,11 +1587,11 @@ export function testRecordsQueryHandler() {
                     schema: freeForAll.types.post.schema,
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
-                const carolPrivateToAliceReply = yield dwn.processMessage(alice.did, carolPrivateToAlice.message, {
+                const carolPrivateToAliceReply = await dwn.processMessage(alice.did, carolPrivateToAlice.message, {
                     dataStream: carolPrivateToAlice.dataStream
                 });
                 expect(carolPrivateToAliceReply.status.code).toBe(202);
-                const carolPrivateToBob = yield TestDataGenerator.generateRecordsWrite({
+                const carolPrivateToBob = await TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     recipient: bob.did,
                     protocol: freeForAll.protocol,
@@ -1595,12 +1599,12 @@ export function testRecordsQueryHandler() {
                     schema: freeForAll.types.post.schema,
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
-                const carolPrivateToBobReply = yield dwn.processMessage(alice.did, carolPrivateToBob.message, {
+                const carolPrivateToBobReply = await dwn.processMessage(alice.did, carolPrivateToBob.message, {
                     dataStream: carolPrivateToBob.dataStream
                 });
                 expect(carolPrivateToBobReply.status.code).toBe(202);
                 // write private records from bob to alice and carol
-                const bobPrivateToAlice = yield TestDataGenerator.generateRecordsWrite({
+                const bobPrivateToAlice = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     recipient: alice.did,
                     protocol: freeForAll.protocol,
@@ -1608,11 +1612,11 @@ export function testRecordsQueryHandler() {
                     schema: freeForAll.types.post.schema,
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
-                const bobPrivateToAliceReply = yield dwn.processMessage(alice.did, bobPrivateToAlice.message, {
+                const bobPrivateToAliceReply = await dwn.processMessage(alice.did, bobPrivateToAlice.message, {
                     dataStream: bobPrivateToAlice.dataStream
                 });
                 expect(bobPrivateToAliceReply.status.code).toBe(202);
-                const bobPrivateToCarol = yield TestDataGenerator.generateRecordsWrite({
+                const bobPrivateToCarol = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     recipient: carol.did,
                     protocol: freeForAll.protocol,
@@ -1620,12 +1624,12 @@ export function testRecordsQueryHandler() {
                     schema: freeForAll.types.post.schema,
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
-                const bobPrivateToCarolReply = yield dwn.processMessage(alice.did, bobPrivateToCarol.message, {
+                const bobPrivateToCarolReply = await dwn.processMessage(alice.did, bobPrivateToCarol.message, {
                     dataStream: bobPrivateToCarol.dataStream
                 });
                 expect(bobPrivateToCarolReply.status.code).toBe(202);
                 // write public records from alice to bob and carol
-                const alicePublicToBob = yield TestDataGenerator.generateRecordsWrite({
+                const alicePublicToBob = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: bob.did,
                     protocol: freeForAll.protocol,
@@ -1634,11 +1638,11 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                     published: true
                 });
-                const alicePublicToBobReply = yield dwn.processMessage(alice.did, alicePublicToBob.message, {
+                const alicePublicToBobReply = await dwn.processMessage(alice.did, alicePublicToBob.message, {
                     dataStream: alicePublicToBob.dataStream
                 });
                 expect(alicePublicToBobReply.status.code).toBe(202);
-                const alicePublicToCarol = yield TestDataGenerator.generateRecordsWrite({
+                const alicePublicToCarol = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: carol.did,
                     protocol: freeForAll.protocol,
@@ -1647,12 +1651,12 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                     published: true
                 });
-                const alicePublicToCarolReply = yield dwn.processMessage(alice.did, alicePublicToCarol.message, {
+                const alicePublicToCarolReply = await dwn.processMessage(alice.did, alicePublicToCarol.message, {
                     dataStream: alicePublicToCarol.dataStream
                 });
                 expect(alicePublicToCarolReply.status.code).toBe(202);
                 // write public records from bob to alice and carol
-                const bobPublicToAlice = yield TestDataGenerator.generateRecordsWrite({
+                const bobPublicToAlice = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     recipient: alice.did,
                     protocol: freeForAll.protocol,
@@ -1661,11 +1665,11 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                     published: true
                 });
-                const bobPublicToAliceReply = yield dwn.processMessage(alice.did, bobPublicToAlice.message, {
+                const bobPublicToAliceReply = await dwn.processMessage(alice.did, bobPublicToAlice.message, {
                     dataStream: bobPublicToAlice.dataStream
                 });
                 expect(bobPublicToAliceReply.status.code).toBe(202);
-                const bobPublicToCarol = yield TestDataGenerator.generateRecordsWrite({
+                const bobPublicToCarol = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     recipient: carol.did,
                     protocol: freeForAll.protocol,
@@ -1674,12 +1678,12 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                     published: true
                 });
-                const bobPublicToCarolReply = yield dwn.processMessage(alice.did, bobPublicToCarol.message, {
+                const bobPublicToCarolReply = await dwn.processMessage(alice.did, bobPublicToCarol.message, {
                     dataStream: bobPublicToCarol.dataStream
                 });
                 expect(bobPublicToCarolReply.status.code).toBe(202);
                 // write public records from carol to alice and bob
-                const carolPublicToAlice = yield TestDataGenerator.generateRecordsWrite({
+                const carolPublicToAlice = await TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     recipient: alice.did,
                     protocol: freeForAll.protocol,
@@ -1688,11 +1692,11 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                     published: true
                 });
-                const carolPublicToAliceReply = yield dwn.processMessage(alice.did, carolPublicToAlice.message, {
+                const carolPublicToAliceReply = await dwn.processMessage(alice.did, carolPublicToAlice.message, {
                     dataStream: carolPublicToAlice.dataStream
                 });
                 expect(carolPublicToAliceReply.status.code).toBe(202);
-                const carolPublicToBob = yield TestDataGenerator.generateRecordsWrite({
+                const carolPublicToBob = await TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     recipient: bob.did,
                     protocol: freeForAll.protocol,
@@ -1701,18 +1705,18 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                     published: true
                 });
-                const carolPublicToBobReply = yield dwn.processMessage(alice.did, carolPublicToBob.message, {
+                const carolPublicToBobReply = await dwn.processMessage(alice.did, carolPublicToBob.message, {
                     dataStream: carolPublicToBob.dataStream
                 });
                 expect(carolPublicToBobReply.status.code).toBe(202);
                 // bob queries for records with himself and alice as recipients
-                const bobQueryMessagesForBobAlice = yield TestDataGenerator.generateRecordsQuery({
+                const bobQueryMessagesForBobAlice = await TestDataGenerator.generateRecordsQuery({
                     author: bob,
                     filter: { protocol: freeForAll.protocol, protocolPath: 'post', recipient: [bob.did, alice.did] }
                 });
-                const bobQueryMessagesForBobAliceReply = yield dwn.processMessage(alice.did, bobQueryMessagesForBobAlice.message);
+                const bobQueryMessagesForBobAliceReply = await dwn.processMessage(alice.did, bobQueryMessagesForBobAlice.message);
                 expect(bobQueryMessagesForBobAliceReply.status.code).toBe(200);
-                expect((_a = bobQueryMessagesForBobAliceReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(7);
+                expect(bobQueryMessagesForBobAliceReply.entries?.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
@@ -1728,13 +1732,13 @@ export function testRecordsQueryHandler() {
                     carolPublicToBob.message.recordId,
                 ]));
                 // carol queries for records with herself as the recipient
-                const carolQueryMessagesForCarolAlice = yield TestDataGenerator.generateRecordsQuery({
+                const carolQueryMessagesForCarolAlice = await TestDataGenerator.generateRecordsQuery({
                     author: carol,
                     filter: { protocol: freeForAll.protocol, protocolPath: 'post', recipient: carol.did }
                 });
-                const carolQueryMessagesForCarolAliceReply = yield dwn.processMessage(alice.did, carolQueryMessagesForCarolAlice.message);
+                const carolQueryMessagesForCarolAliceReply = await dwn.processMessage(alice.did, carolQueryMessagesForCarolAlice.message);
                 expect(carolQueryMessagesForCarolAliceReply.status.code).toBe(200);
-                expect((_b = carolQueryMessagesForCarolAliceReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(4);
+                expect(carolQueryMessagesForCarolAliceReply.entries?.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
@@ -1747,13 +1751,13 @@ export function testRecordsQueryHandler() {
                     bobPublicToCarol.message.recordId,
                 ]));
                 // alice queries for ONLY published records with herself and bob as recipients
-                const aliceQueryPublished = yield TestDataGenerator.generateRecordsQuery({
+                const aliceQueryPublished = await 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);
+                const aliceQueryPublishedReply = await dwn.processMessage(alice.did, aliceQueryPublished.message);
                 expect(aliceQueryPublishedReply.status.code).toBe(200);
-                expect((_c = aliceQueryPublishedReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(4);
+                expect(aliceQueryPublishedReply.entries?.length).toBe(4);
                 expect(aliceQueryPublishedReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     alicePublicToBob.message.recordId,
                     carolPublicToBob.message.recordId,
@@ -1761,38 +1765,37 @@ export function testRecordsQueryHandler() {
                     carolPublicToAlice.message.recordId,
                 ]));
                 // carol queries for ONLY private records with herself and alice as the recipients
-                const carolQueryPrivate = yield TestDataGenerator.generateRecordsQuery({
+                const carolQueryPrivate = await 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);
+                const carolQueryPrivateReply = await dwn.processMessage(alice.did, carolQueryPrivate.message);
                 expect(carolQueryPrivateReply.status.code).toBe(200);
-                expect((_d = carolQueryPrivateReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(3);
+                expect(carolQueryPrivateReply.entries?.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)).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* () {
+            });
+            it('should only return published records and unpublished records that are authored by specific author(s)', async () => {
                 // scenario: Alice installs a free-for-all protocol on her DWN
                 // She writes both private and public messages for bob and carol, carol and bob also write public and privet messages for alice and each other
                 // Bob, Alice and Carol should only be able to see private messages pertaining to themselves, and any public messages filtered by an author
                 // Bob, Alice and Carol should be able to filter for ONLY public messages or ONLY private messages
-                var _a, _b, _c, _d;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                const carol = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const carol = await TestDataGenerator.generateDidKeyPersona();
                 // install the free-for-all protocol on Alice's DWN
-                const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition: freeForAll
                 });
-                const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                const protocolConfigureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                 expect(protocolConfigureReply.status.code).toBe(202);
                 // write private records for bob and carol
-                const alicePrivateToBob = yield TestDataGenerator.generateRecordsWrite({
+                const alicePrivateToBob = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: bob.did,
                     protocol: freeForAll.protocol,
@@ -1800,9 +1803,9 @@ export function testRecordsQueryHandler() {
                     schema: freeForAll.types.post.schema,
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
-                const alicePrivateToBobReply = yield dwn.processMessage(alice.did, alicePrivateToBob.message, { dataStream: alicePrivateToBob.dataStream });
+                const alicePrivateToBobReply = await dwn.processMessage(alice.did, alicePrivateToBob.message, { dataStream: alicePrivateToBob.dataStream });
                 expect(alicePrivateToBobReply.status.code).toBe(202);
-                const alicePrivateToCarol = yield TestDataGenerator.generateRecordsWrite({
+                const alicePrivateToCarol = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: carol.did,
                     protocol: freeForAll.protocol,
@@ -1810,12 +1813,12 @@ export function testRecordsQueryHandler() {
                     schema: freeForAll.types.post.schema,
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
-                const alicePrivateToCarolReply = yield dwn.processMessage(alice.did, alicePrivateToCarol.message, {
+                const alicePrivateToCarolReply = await dwn.processMessage(alice.did, alicePrivateToCarol.message, {
                     dataStream: alicePrivateToCarol.dataStream
                 });
                 expect(alicePrivateToCarolReply.status.code).toBe(202);
                 // write private records from carol to alice and bob
-                const carolPrivateToAlice = yield TestDataGenerator.generateRecordsWrite({
+                const carolPrivateToAlice = await TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     recipient: alice.did,
                     protocol: freeForAll.protocol,
@@ -1823,11 +1826,11 @@ export function testRecordsQueryHandler() {
                     schema: freeForAll.types.post.schema,
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
-                const carolPrivateToAliceReply = yield dwn.processMessage(alice.did, carolPrivateToAlice.message, {
+                const carolPrivateToAliceReply = await dwn.processMessage(alice.did, carolPrivateToAlice.message, {
                     dataStream: carolPrivateToAlice.dataStream
                 });
                 expect(carolPrivateToAliceReply.status.code).toBe(202);
-                const carolPrivateToBob = yield TestDataGenerator.generateRecordsWrite({
+                const carolPrivateToBob = await TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     recipient: bob.did,
                     protocol: freeForAll.protocol,
@@ -1835,12 +1838,12 @@ export function testRecordsQueryHandler() {
                     schema: freeForAll.types.post.schema,
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
-                const carolPrivateToBobReply = yield dwn.processMessage(alice.did, carolPrivateToBob.message, {
+                const carolPrivateToBobReply = await dwn.processMessage(alice.did, carolPrivateToBob.message, {
                     dataStream: carolPrivateToBob.dataStream
                 });
                 expect(carolPrivateToBobReply.status.code).toBe(202);
                 // write private records from bob to alice and carol
-                const bobPrivateToAlice = yield TestDataGenerator.generateRecordsWrite({
+                const bobPrivateToAlice = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     recipient: alice.did,
                     protocol: freeForAll.protocol,
@@ -1848,11 +1851,11 @@ export function testRecordsQueryHandler() {
                     schema: freeForAll.types.post.schema,
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
-                const bobPrivateToAliceReply = yield dwn.processMessage(alice.did, bobPrivateToAlice.message, {
+                const bobPrivateToAliceReply = await dwn.processMessage(alice.did, bobPrivateToAlice.message, {
                     dataStream: bobPrivateToAlice.dataStream
                 });
                 expect(bobPrivateToAliceReply.status.code).toBe(202);
-                const bobPrivateToCarol = yield TestDataGenerator.generateRecordsWrite({
+                const bobPrivateToCarol = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     recipient: carol.did,
                     protocol: freeForAll.protocol,
@@ -1860,12 +1863,12 @@ export function testRecordsQueryHandler() {
                     schema: freeForAll.types.post.schema,
                     dataFormat: freeForAll.types.post.dataFormats[0],
                 });
-                const bobPrivateToCarolReply = yield dwn.processMessage(alice.did, bobPrivateToCarol.message, {
+                const bobPrivateToCarolReply = await dwn.processMessage(alice.did, bobPrivateToCarol.message, {
                     dataStream: bobPrivateToCarol.dataStream
                 });
                 expect(bobPrivateToCarolReply.status.code).toBe(202);
                 // write public records from alice to bob and carol
-                const alicePublicToBob = yield TestDataGenerator.generateRecordsWrite({
+                const alicePublicToBob = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: bob.did,
                     protocol: freeForAll.protocol,
@@ -1874,11 +1877,11 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                     published: true
                 });
-                const alicePublicToBobReply = yield dwn.processMessage(alice.did, alicePublicToBob.message, {
+                const alicePublicToBobReply = await dwn.processMessage(alice.did, alicePublicToBob.message, {
                     dataStream: alicePublicToBob.dataStream
                 });
                 expect(alicePublicToBobReply.status.code).toBe(202);
-                const alicePublicToCarol = yield TestDataGenerator.generateRecordsWrite({
+                const alicePublicToCarol = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: carol.did,
                     protocol: freeForAll.protocol,
@@ -1887,12 +1890,12 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                     published: true
                 });
-                const alicePublicToCarolReply = yield dwn.processMessage(alice.did, alicePublicToCarol.message, {
+                const alicePublicToCarolReply = await dwn.processMessage(alice.did, alicePublicToCarol.message, {
                     dataStream: alicePublicToCarol.dataStream
                 });
                 expect(alicePublicToCarolReply.status.code).toBe(202);
                 // write public records from bob to alice and carol
-                const bobPublicToAlice = yield TestDataGenerator.generateRecordsWrite({
+                const bobPublicToAlice = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     recipient: alice.did,
                     protocol: freeForAll.protocol,
@@ -1901,11 +1904,11 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                     published: true
                 });
-                const bobPublicToAliceReply = yield dwn.processMessage(alice.did, bobPublicToAlice.message, {
+                const bobPublicToAliceReply = await dwn.processMessage(alice.did, bobPublicToAlice.message, {
                     dataStream: bobPublicToAlice.dataStream
                 });
                 expect(bobPublicToAliceReply.status.code).toBe(202);
-                const bobPublicToCarol = yield TestDataGenerator.generateRecordsWrite({
+                const bobPublicToCarol = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     recipient: carol.did,
                     protocol: freeForAll.protocol,
@@ -1914,12 +1917,12 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                     published: true
                 });
-                const bobPublicToCarolReply = yield dwn.processMessage(alice.did, bobPublicToCarol.message, {
+                const bobPublicToCarolReply = await dwn.processMessage(alice.did, bobPublicToCarol.message, {
                     dataStream: bobPublicToCarol.dataStream
                 });
                 expect(bobPublicToCarolReply.status.code).toBe(202);
                 // write public records from carol to alice and bob
-                const carolPublicToAlice = yield TestDataGenerator.generateRecordsWrite({
+                const carolPublicToAlice = await TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     recipient: alice.did,
                     protocol: freeForAll.protocol,
@@ -1928,11 +1931,11 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                     published: true
                 });
-                const carolPublicToAliceReply = yield dwn.processMessage(alice.did, carolPublicToAlice.message, {
+                const carolPublicToAliceReply = await dwn.processMessage(alice.did, carolPublicToAlice.message, {
                     dataStream: carolPublicToAlice.dataStream
                 });
                 expect(carolPublicToAliceReply.status.code).toBe(202);
-                const carolPublicToBob = yield TestDataGenerator.generateRecordsWrite({
+                const carolPublicToBob = await TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     recipient: bob.did,
                     protocol: freeForAll.protocol,
@@ -1941,18 +1944,18 @@ export function testRecordsQueryHandler() {
                     dataFormat: freeForAll.types.post.dataFormats[0],
                     published: true
                 });
-                const carolPublicToBobReply = yield dwn.processMessage(alice.did, carolPublicToBob.message, {
+                const carolPublicToBobReply = await dwn.processMessage(alice.did, carolPublicToBob.message, {
                     dataStream: carolPublicToBob.dataStream
                 });
                 expect(carolPublicToBobReply.status.code).toBe(202);
                 // bob queries for records with himself and alice as authors
-                const bobQueryMessagesForBobAlice = yield TestDataGenerator.generateRecordsQuery({
+                const bobQueryMessagesForBobAlice = await TestDataGenerator.generateRecordsQuery({
                     author: bob,
                     filter: { protocol: freeForAll.protocol, protocolPath: 'post', author: [bob.did, alice.did] }
                 });
-                const bobQueryMessagesForBobAliceReply = yield dwn.processMessage(alice.did, bobQueryMessagesForBobAlice.message);
+                const bobQueryMessagesForBobAliceReply = await dwn.processMessage(alice.did, bobQueryMessagesForBobAlice.message);
                 expect(bobQueryMessagesForBobAliceReply.status.code).toBe(200);
-                expect((_a = bobQueryMessagesForBobAliceReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(7);
+                expect(bobQueryMessagesForBobAliceReply.entries?.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
@@ -1968,13 +1971,13 @@ export function testRecordsQueryHandler() {
                     bobPublicToCarol.message.recordId
                 ]));
                 // carol queries for records with herself as the author
-                const carolQueryMessagesForCarolAlice = yield TestDataGenerator.generateRecordsQuery({
+                const carolQueryMessagesForCarolAlice = await TestDataGenerator.generateRecordsQuery({
                     author: carol,
                     filter: { protocol: freeForAll.protocol, protocolPath: 'post', author: carol.did }
                 });
-                const carolQueryMessagesForCarolAliceReply = yield dwn.processMessage(alice.did, carolQueryMessagesForCarolAlice.message);
+                const carolQueryMessagesForCarolAliceReply = await dwn.processMessage(alice.did, carolQueryMessagesForCarolAlice.message);
                 expect(carolQueryMessagesForCarolAliceReply.status.code).toBe(200);
-                expect((_b = carolQueryMessagesForCarolAliceReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(4);
+                expect(carolQueryMessagesForCarolAliceReply.entries?.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)).toEqual(expect.arrayContaining([
@@ -1984,13 +1987,13 @@ export function testRecordsQueryHandler() {
                     carolPublicToBob.message.recordId
                 ]));
                 // alice queries for ONLY published records with herself and bob as authors
-                const aliceQueryPublished = yield TestDataGenerator.generateRecordsQuery({
+                const aliceQueryPublished = await 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);
+                const aliceQueryPublishedReply = await dwn.processMessage(alice.did, aliceQueryPublished.message);
                 expect(aliceQueryPublishedReply.status.code).toBe(200);
-                expect((_c = aliceQueryPublishedReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(4);
+                expect(aliceQueryPublishedReply.entries?.length).toBe(4);
                 expect(aliceQueryPublishedReply.entries.map(e => e.recordId)).toEqual(expect.arrayContaining([
                     alicePublicToBob.message.recordId,
                     alicePublicToCarol.message.recordId,
@@ -1998,24 +2001,22 @@ export function testRecordsQueryHandler() {
                     bobPublicToCarol.message.recordId
                 ]));
                 // carol queries for ONLY private records with herself and alice as the authors
-                const carolQueryPrivate = yield TestDataGenerator.generateRecordsQuery({
+                const carolQueryPrivate = await 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);
+                const carolQueryPrivateReply = await dwn.processMessage(alice.did, carolQueryPrivate.message);
                 expect(carolQueryPrivateReply.status.code).toBe(200);
-                expect((_d = carolQueryPrivateReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(3);
+                expect(carolQueryPrivateReply.entries?.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;
-                var _d, _e, _f, _g, _h;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should paginate correctly for fetchRecordsAsNonOwner()', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 const schema = 'schema1';
                 // published messages bob
                 const bobPublishedPromise = Array(5).fill({}).map(_ => TestDataGenerator.generateRecordsWrite({
@@ -2044,64 +2045,54 @@ export function testRecordsQueryHandler() {
                     ...alicePublishedPromise,
                     ...aliceMessagesForBobPromise,
                 ];
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, stateIndex, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler({
+                    didResolver, messageStore, dataStore, stateIndex, coreProtocols: new CoreProtocolRegistry(), eventLog,
+                });
                 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) {
-                        _c = messagePromises_1_1.value;
-                        _j = false;
-                        const { recordsWrite, message, dataBytes } = _c;
-                        const indexes = yield recordsWrite.constructIndexes(true);
-                        const processedMessage = yield recordsWriteHandler.cloneAndAddEncodedData(message, dataBytes);
-                        yield messageStore.put(alice.did, processedMessage, indexes);
-                        yield stateIndex.insert(alice.did, yield Message.getCid(processedMessage), indexes);
-                        messages.push(processedMessage);
-                    }
+                for await (const { recordsWrite, message, dataBytes } of messagePromises) {
+                    const indexes = await recordsWrite.constructIndexes(true);
+                    const processedMessage = await recordsWriteHandler.cloneAndAddEncodedData(message, dataBytes);
+                    await messageStore.put(alice.did, processedMessage, indexes);
+                    await stateIndex.insert(alice.did, await Message.getCid(processedMessage), indexes);
+                    messages.push(processedMessage);
                 }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (!_j && !_a && (_b = messagePromises_1.return)) yield _b.call(messagePromises_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-                const sortedMessages = yield ArrayUtility.asyncSort(messages, (a, b) => __awaiter(this, void 0, void 0, function* () { return Message.compareMessageTimestamp(a, b); }));
+                const sortedMessages = await ArrayUtility.asyncSort(messages, async (a, b) => Message.compareMessageTimestamp(a, b));
                 const aliceRetrieved = [];
                 // fetch all from alice for sanity, alice should get all of the records
                 // page1 alice
-                const aliceQueryMessageDataPage1 = yield TestDataGenerator.generateRecordsQuery({
+                const aliceQueryMessageDataPage1 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema },
                     dateSort: DateSort.CreatedAscending,
                     pagination: { limit: 10 },
                 });
-                let results = yield dwn.processMessage(alice.did, aliceQueryMessageDataPage1.message);
+                let results = await dwn.processMessage(alice.did, aliceQueryMessageDataPage1.message);
                 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.entries?.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({
+                const aliceQueryMessageDataPage2 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema },
                     dateSort: DateSort.CreatedAscending,
                     pagination: { limit: 10, cursor: results.cursor },
                 });
-                results = yield dwn.processMessage(alice.did, aliceQueryMessageDataPage2.message);
+                results = await dwn.processMessage(alice.did, aliceQueryMessageDataPage2.message);
                 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.entries?.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({
+                const aliceQueryMessageDataPage3 = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema },
                     dateSort: DateSort.CreatedAscending,
                     pagination: { limit: 10, cursor: results.cursor },
                 });
-                results = yield dwn.processMessage(alice.did, aliceQueryMessageDataPage3.message);
+                results = await dwn.processMessage(alice.did, aliceQueryMessageDataPage3.message);
                 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.entries?.length).toBe(5, 'alice page 3');
                 expect(results.cursor, 'alice page 3 cursor').toBeUndefined();
                 aliceRetrieved.push(...results.entries);
                 const compareRecordId = (a, b) => {
@@ -2115,174 +2106,174 @@ export function testRecordsQueryHandler() {
                 // now we prepare to test records that only bob should get
                 const bobSorted = sortedMessages.filter(m => bobs(m));
                 const bobRetrieved = [];
-                const bobQueryMessagePage1 = yield TestDataGenerator.generateRecordsQuery({
+                const bobQueryMessagePage1 = await TestDataGenerator.generateRecordsQuery({
                     author: bob,
                     filter: { schema },
                     dateSort: DateSort.CreatedAscending,
                     pagination: { limit: 10 },
                 });
-                results = yield dwn.processMessage(alice.did, bobQueryMessagePage1.message);
+                results = await dwn.processMessage(alice.did, bobQueryMessagePage1.message);
                 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.entries?.length).toBe(10, 'bob page 1');
                 expect(results.cursor, 'bob page 1 cursor').toBeDefined();
                 bobRetrieved.push(...results.entries);
-                const bobQueryMessagePage2 = yield TestDataGenerator.generateRecordsQuery({
+                const bobQueryMessagePage2 = await TestDataGenerator.generateRecordsQuery({
                     author: bob,
                     filter: { schema },
                     dateSort: DateSort.CreatedAscending,
                     pagination: { limit: 10, cursor: results.cursor },
                 });
-                results = yield dwn.processMessage(alice.did, bobQueryMessagePage2.message);
+                results = await dwn.processMessage(alice.did, bobQueryMessagePage2.message);
                 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.entries?.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/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();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            it('#170 - should treat records with `published` explicitly set to `false` as unpublished', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const schema = 'schema1';
-                const unpublishedRecordsWrite = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema, data: Encoder.stringToBytes('1'), published: false } // explicitly setting `published` to `false`
+                const unpublishedRecordsWrite = await 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 });
+                const result1 = await dwn.processMessage(alice.did, unpublishedRecordsWrite.message, { dataStream: unpublishedRecordsWrite.dataStream });
                 expect(result1.status.code).toBe(202);
                 // alice should be able to see the unpublished record
-                const queryByAlice = yield TestDataGenerator.generateRecordsQuery({
+                const queryByAlice = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema }
                 });
-                const replyToAliceQuery = yield dwn.processMessage(alice.did, queryByAlice.message);
+                const replyToAliceQuery = await dwn.processMessage(alice.did, queryByAlice.message);
                 expect(replyToAliceQuery.status.code).toBe(200);
-                expect((_a = replyToAliceQuery.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(replyToAliceQuery.entries?.length).toBe(1);
                 // actual test: bob should not be able to see unpublished record
-                const queryByBob = yield TestDataGenerator.generateRecordsQuery({
+                const queryByBob = await TestDataGenerator.generateRecordsQuery({
                     author: bob,
                     filter: { schema }
                 });
-                const replyToBobQuery = yield dwn.processMessage(alice.did, queryByBob.message);
+                const replyToBobQuery = await dwn.processMessage(alice.did, queryByBob.message);
                 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();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                const bobQueryMessageData = yield TestDataGenerator.generateRecordsQuery({
+                expect(replyToBobQuery.entries?.length).toBe(0);
+            });
+            it('should allow DWN owner to use `recipient` as a filter in queries', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const bobQueryMessageData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recipient: bob.did } // alice as the DWN owner querying bob's records
                 });
-                const replyToBobQuery = yield dwn.processMessage(alice.did, bobQueryMessageData.message);
+                const replyToBobQuery = await dwn.processMessage(alice.did, bobQueryMessageData.message);
                 expect(replyToBobQuery.status.code).toBe(200);
-            }));
-            it('should not fetch entries across tenants', () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
+            });
+            it('should not fetch entries across tenants', async () => {
                 // insert three messages into DB, two with matching schema
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, bob);
                 const schema = 'myAwesomeSchema';
-                const recordsWriteMessage1Data = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema });
-                const recordsWriteMessage2Data = yield TestDataGenerator.generateRecordsWrite({ author: bob, schema });
-                const aliceQueryMessageData = yield TestDataGenerator.generateRecordsQuery({
+                const recordsWriteMessage1Data = await TestDataGenerator.generateRecordsWrite({ author: alice, schema });
+                const recordsWriteMessage2Data = await TestDataGenerator.generateRecordsWrite({ author: bob, schema });
+                const aliceQueryMessageData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema }
                 });
                 // insert data into 2 different tenants
-                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);
+                await dwn.processMessage(alice.did, recordsWriteMessage1Data.message, { dataStream: recordsWriteMessage1Data.dataStream });
+                await dwn.processMessage(bob.did, recordsWriteMessage2Data.message, { dataStream: recordsWriteMessage2Data.dataStream });
+                const reply = await dwn.processMessage(alice.did, aliceQueryMessageData.message);
                 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();
+                expect(reply.entries?.length).toBe(1);
+            });
+            it('should return 400 if protocol is not normalized', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // query for non-normalized protocol
-                const recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+                const recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { protocol: 'example.com/' },
                 });
                 // overwrite protocol because #create auto-normalizes protocol
                 recordsQuery.message.descriptor.filter.protocol = 'example.com/';
                 // Re-create auth because we altered the descriptor after signing
-                recordsQuery.message.authorization = yield Message.createAuthorization({
+                recordsQuery.message.authorization = await Message.createAuthorization({
                     descriptor: recordsQuery.message.descriptor,
                     signer: Jws.createSigner(alice)
                 });
                 // Send records write message
-                const reply = yield dwn.processMessage(alice.did, recordsQuery.message);
+                const reply = await dwn.processMessage(alice.did, recordsQuery.message);
                 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();
+            });
+            it('should return 400 if schema is not normalized', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // query for non-normalized schema
-                const recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+                const recordsQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { schema: 'example.com/' },
                 });
                 // overwrite schema because #create auto-normalizes schema
                 recordsQuery.message.descriptor.filter.schema = 'example.com/';
                 // Re-create auth because we altered the descriptor after signing
-                recordsQuery.message.authorization = yield Message.createAuthorization({
+                recordsQuery.message.authorization = await Message.createAuthorization({
                     descriptor: recordsQuery.message.descriptor,
                     signer: Jws.createSigner(alice)
                 });
                 // Send records write message
-                const reply = yield dwn.processMessage(alice.did, recordsQuery.message);
+                const reply = await dwn.processMessage(alice.did, recordsQuery.message);
                 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* () {
+            });
+            it('should return 400 if published is set to false and a datePublished range is provided', async () => {
                 const fromDatePublished = Time.getCurrentTimestamp();
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // set to true so create does not fail
-                const recordQuery = yield TestDataGenerator.generateRecordsQuery({
+                const recordQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { datePublished: { from: fromDatePublished }, published: true }
                 });
                 // set to false
                 recordQuery.message.descriptor.filter.published = false;
-                const queryResponse = yield dwn.processMessage(alice.did, recordQuery.message);
+                const queryResponse = await dwn.processMessage(alice.did, recordQuery.message);
                 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;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should return 401 for anonymous queries that filter explicitly for unpublished records', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // 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 });
+                const draftWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'post' });
+                const draftWriteReply = await dwn.processMessage(alice.did, draftWrite.message, { dataStream: draftWrite.dataStream });
                 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);
+                const unpublishedPostQuery = await TestDataGenerator.generateRecordsQuery({ author: alice, filter: { schema: 'post', published: false } });
+                const unpublishedPostReply = await dwn.processMessage(alice.did, unpublishedPostQuery.message);
                 expect(unpublishedPostReply.status.code).toBe(200);
-                expect((_a = unpublishedPostReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(unpublishedPostReply.entries?.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);
+                const unpublishedAnonymous = await RecordsQuery.create({ filter: { schema: 'post', published: false } });
+                const anonymousPostReply = await dwn.processMessage(alice.did, unpublishedAnonymous.message);
                 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* () {
+                it('should return message scoped to the given `contextId`', async () => {
                     // scenario:
                     // 0. Alice installs a nested protocol foo -> bar -> baz
                     // 1. Alice writes 2 foos, 2 bars under foo1, and 2 bazes under bar1
                     // 2. Alice should be able to query for all messages under foo1
                     // 3. Alice should be able to query for all messages under bar1
                     // 4. Alice should be able to query for all messages under baz1
-                    var _a, _b, _c;
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     const protocolDefinition = nestedProtocol;
                     // 0. Alice installs a nested protocol foo -> bar -> baz
-                    const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                    const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                     expect(protocolsConfigureReply.status.code).toBe(202);
                     // 1. Alice writes 2 foos, 2 bars under foo1, and 2 bazes under bar1
                     // write 2 foos
@@ -2293,11 +2284,11 @@ export function testRecordsQueryHandler() {
                         schema: nestedProtocol.types.foo.schema,
                         dataFormat: nestedProtocol.types.foo.dataFormats[0],
                     };
-                    const foo1 = yield TestDataGenerator.generateRecordsWrite(fooOptions);
-                    const foo1WriteResponse = yield dwn.processMessage(alice.did, foo1.message, { dataStream: foo1.dataStream });
+                    const foo1 = await TestDataGenerator.generateRecordsWrite(fooOptions);
+                    const foo1WriteResponse = await dwn.processMessage(alice.did, foo1.message, { dataStream: foo1.dataStream });
                     expect(foo1WriteResponse.status.code).toBe(202);
-                    const foo2 = yield TestDataGenerator.generateRecordsWrite(fooOptions);
-                    const foo2WriteResponse = yield dwn.processMessage(alice.did, foo2.message, { dataStream: foo2.dataStream });
+                    const foo2 = await TestDataGenerator.generateRecordsWrite(fooOptions);
+                    const foo2WriteResponse = await dwn.processMessage(alice.did, foo2.message, { dataStream: foo2.dataStream });
                     expect(foo2WriteResponse.status.code).toBe(202);
                     // write 2 bars under foo1
                     const barOptions = {
@@ -2308,11 +2299,11 @@ export function testRecordsQueryHandler() {
                         dataFormat: nestedProtocol.types.bar.dataFormats[0],
                         parentContextId: foo1.message.contextId
                     };
-                    const bar1 = yield TestDataGenerator.generateRecordsWrite(barOptions);
-                    const bar1WriteResponse = yield dwn.processMessage(alice.did, bar1.message, { dataStream: bar1.dataStream });
+                    const bar1 = await TestDataGenerator.generateRecordsWrite(barOptions);
+                    const bar1WriteResponse = await dwn.processMessage(alice.did, bar1.message, { dataStream: bar1.dataStream });
                     expect(bar1WriteResponse.status.code).toBe(202);
-                    const bar2 = yield TestDataGenerator.generateRecordsWrite(barOptions);
-                    const bar2WriteResponse = yield dwn.processMessage(alice.did, bar2.message, { dataStream: bar2.dataStream });
+                    const bar2 = await TestDataGenerator.generateRecordsWrite(barOptions);
+                    const bar2WriteResponse = await dwn.processMessage(alice.did, bar2.message, { dataStream: bar2.dataStream });
                     expect(bar2WriteResponse.status.code).toBe(202);
                     // write 2 bazes under bar1
                     const bazOptions = {
@@ -2323,20 +2314,20 @@ export function testRecordsQueryHandler() {
                         dataFormat: nestedProtocol.types.baz.dataFormats[0],
                         parentContextId: bar1.message.contextId
                     };
-                    const baz1 = yield TestDataGenerator.generateRecordsWrite(bazOptions);
-                    const baz1WriteResponse = yield dwn.processMessage(alice.did, baz1.message, { dataStream: baz1.dataStream });
+                    const baz1 = await TestDataGenerator.generateRecordsWrite(bazOptions);
+                    const baz1WriteResponse = await dwn.processMessage(alice.did, baz1.message, { dataStream: baz1.dataStream });
                     expect(baz1WriteResponse.status.code).toBe(202);
-                    const baz2 = yield TestDataGenerator.generateRecordsWrite(bazOptions);
-                    const baz2WriteResponse = yield dwn.processMessage(alice.did, baz2.message, { dataStream: baz2.dataStream });
+                    const baz2 = await TestDataGenerator.generateRecordsWrite(bazOptions);
+                    const baz2WriteResponse = await dwn.processMessage(alice.did, baz2.message, { dataStream: baz2.dataStream });
                     expect(baz2WriteResponse.status.code).toBe(202);
                     // 2. Alice should be able to query for all messages under foo1
-                    const foo1ContextIdQuery = yield TestDataGenerator.generateRecordsQuery({
+                    const foo1ContextIdQuery = await TestDataGenerator.generateRecordsQuery({
                         author: alice,
                         filter: { contextId: foo1.message.contextId }
                     });
-                    const foo1ContextIdQueryReply = yield dwn.processMessage(alice.did, foo1ContextIdQuery.message);
+                    const foo1ContextIdQueryReply = await dwn.processMessage(alice.did, foo1ContextIdQuery.message);
                     expect(foo1ContextIdQueryReply.status.code).toBe(200);
-                    expect((_a = foo1ContextIdQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(5);
+                    expect(foo1ContextIdQueryReply.entries?.length).toBe(5);
                     expect(foo1ContextIdQueryReply.entries.map((entry) => entry.recordId)).toEqual(expect.arrayContaining([
                         foo1.message.recordId,
                         bar1.message.recordId,
@@ -2345,52 +2336,51 @@ export function testRecordsQueryHandler() {
                         baz2.message.recordId
                     ]));
                     // 3. Alice should be able to query for all messages under bar1
-                    const bar1ContextIdQuery = yield TestDataGenerator.generateRecordsQuery({
+                    const bar1ContextIdQuery = await TestDataGenerator.generateRecordsQuery({
                         author: alice,
                         filter: { contextId: bar1.message.contextId }
                     });
-                    const bar1ContextIdQueryReply = yield dwn.processMessage(alice.did, bar1ContextIdQuery.message);
+                    const bar1ContextIdQueryReply = await dwn.processMessage(alice.did, bar1ContextIdQuery.message);
                     expect(bar1ContextIdQueryReply.status.code).toBe(200);
-                    expect((_b = bar1ContextIdQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(3);
+                    expect(bar1ContextIdQueryReply.entries?.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({
+                    const baz1ContextIdQuery = await TestDataGenerator.generateRecordsQuery({
                         author: alice,
                         filter: { contextId: baz1.message.contextId }
                     });
-                    const baz1ContextIdQueryReply = yield dwn.processMessage(alice.did, baz1ContextIdQuery.message);
+                    const baz1ContextIdQueryReply = await dwn.processMessage(alice.did, baz1ContextIdQuery.message);
                     expect(baz1ContextIdQueryReply.status.code).toBe(200);
-                    expect((_c = baz1ContextIdQueryReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
+                    expect(baz1ContextIdQueryReply.entries?.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* () {
+                });
+                it('does not try protocol authorization if protocolRole is not invoked', async () => {
                     // scenario: Alice creates a thread and writes some chat messages. Alice addresses
                     //           only one chat message to Bob. Bob queries by protocol URI without invoking a protocolRole,
                     //           and he is able to receive the message addressed to him.
-                    var _a, _b;
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     const protocolDefinition = threadRoleProtocolDefinition;
-                    const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                    const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                     expect(protocolsConfigureReply.status.code).toBe(202);
                     // Alice writes a 'thread' record
-                    const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const threadRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'thread',
                     });
-                    const threadRoleReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+                    const threadRoleReply = await dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
                     expect(threadRoleReply.status.code).toBe(202);
                     // Alice writes one 'chat' record addressed to Bob
-                    const chatRecordForBob = yield TestDataGenerator.generateRecordsWrite({
+                    const chatRecordForBob = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         recipient: bob.did,
                         protocol: protocolDefinition.protocol,
@@ -2399,11 +2389,11 @@ export function testRecordsQueryHandler() {
                         parentContextId: threadRecord.message.contextId,
                         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 });
+                    const chatRecordForBobReply = await dwn.processMessage(alice.did, chatRecordForBob.message, { dataStream: chatRecordForBob.dataStream });
                     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({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: alice.did,
                             protocol: protocolDefinition.protocol,
@@ -2412,60 +2402,59 @@ export function testRecordsQueryHandler() {
                             parentContextId: threadRecord.message.contextId,
                             data: new TextEncoder().encode('Bob cannot read this'),
                         });
-                        const chatReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+                        const chatReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         expect(chatReply.status.code).toBe(202);
                     }
                     // Bob queries without invoking any protocolRole
-                    const chatQuery = yield TestDataGenerator.generateRecordsQuery({
+                    const chatQuery = await TestDataGenerator.generateRecordsQuery({
                         author: bob,
                         filter: {
                             protocol: protocolDefinition.protocol,
                         },
                     });
-                    const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
+                    const chatQueryReply = await dwn.processMessage(alice.did, chatQuery.message);
                     expect(chatQueryReply.status.code).toBe(200);
-                    expect((_a = chatQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                    expect(chatQueryReply.entries?.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({
+                    const unpublishedChatQuery = await TestDataGenerator.generateRecordsQuery({
                         author: bob,
                         filter: {
                             published: false,
                             protocol: protocolDefinition.protocol,
                         },
                     });
-                    const unpublishedChatReply = yield dwn.processMessage(alice.did, unpublishedChatQuery.message);
+                    const unpublishedChatReply = await dwn.processMessage(alice.did, unpublishedChatQuery.message);
                     expect(unpublishedChatReply.status.code).toBe(200);
-                    expect((_b = unpublishedChatReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                    expect(unpublishedChatReply.entries?.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* () {
+                });
+                it('allows root-level role authorized queries', async () => {
                     // scenario: Alice creates a thread and writes some chat messages writes a chat message. Bob invokes his
                     //           thread member role in order to query the chat messages.
-                    var _a, _b;
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     const protocolDefinition = friendRoleProtocolDefinition;
-                    const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                    const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                     expect(protocolsConfigureReply.status.code).toBe(202);
                     // Alice writes a 'friend' root-level role record with Bob as recipient
-                    const friendRoleRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const friendRoleRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         recipient: bob.did,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'friend',
                         data: new TextEncoder().encode('Bob is my friend'),
                     });
-                    const friendRoleReply = yield dwn.processMessage(alice.did, friendRoleRecord.message, { dataStream: friendRoleRecord.dataStream });
+                    const friendRoleReply = await dwn.processMessage(alice.did, friendRoleRecord.message, { dataStream: friendRoleRecord.dataStream });
                     expect(friendRoleReply.status.code).toBe(202);
                     // Alice writes three 'chat' records
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: alice.did,
                             protocol: protocolDefinition.protocol,
@@ -2473,12 +2462,12 @@ export function testRecordsQueryHandler() {
                             published: false,
                             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 });
+                        const chatReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         expect(chatReply.status.code).toBe(202);
                         chatRecordIds.push(chatRecord.message.recordId);
                     }
                     // Bob invokes his friendRole to query that records
-                    const chatQuery = yield TestDataGenerator.generateRecordsQuery({
+                    const chatQuery = await TestDataGenerator.generateRecordsQuery({
                         author: bob,
                         filter: {
                             protocol: protocolDefinition.protocol,
@@ -2486,12 +2475,12 @@ export function testRecordsQueryHandler() {
                         },
                         protocolRole: 'friend',
                     });
-                    const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
+                    const chatQueryReply = await dwn.processMessage(alice.did, chatQuery.message);
                     expect(chatQueryReply.status.code).toBe(200);
-                    expect((_a = chatQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(3);
+                    expect(chatQueryReply.entries?.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({
+                    const unpublishedChatQuery = await TestDataGenerator.generateRecordsQuery({
                         author: bob,
                         filter: {
                             published: false,
@@ -2500,33 +2489,32 @@ export function testRecordsQueryHandler() {
                         },
                         protocolRole: 'friend',
                     });
-                    const unpublishedChatReply = yield dwn.processMessage(alice.did, unpublishedChatQuery.message);
+                    const unpublishedChatReply = await dwn.processMessage(alice.did, unpublishedChatQuery.message);
                     expect(unpublishedChatReply.status.code).toBe(200);
-                    expect((_b = unpublishedChatReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(3);
+                    expect(unpublishedChatReply.entries?.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* () {
+                });
+                it('can authorize queries using a context role.', async () => {
                     // scenario: Alice writes some chat messages. Bob invokes his friend role in order to query the chat messages.
-                    var _a;
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     const protocolDefinition = threadRoleProtocolDefinition;
-                    const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                    const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                     expect(protocolsConfigureReply.status.code).toBe(202);
                     // Alice writes a 'thread' record
-                    const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const threadRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'thread',
                     });
-                    const threadRoleReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+                    const threadRoleReply = await dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
                     expect(threadRoleReply.status.code).toBe(202);
                     // Alice writes a 'participant' role record with Bob as recipient
-                    const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const participantRoleRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         recipient: bob.did,
                         protocol: protocolDefinition.protocol,
@@ -2534,12 +2522,12 @@ export function testRecordsQueryHandler() {
                         parentContextId: threadRecord.message.contextId,
                         data: new TextEncoder().encode('Bob is my friend'),
                     });
-                    const participantRoleReply = yield dwn.processMessage(alice.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
+                    const participantRoleReply = await dwn.processMessage(alice.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
                     expect(participantRoleReply.status.code).toBe(202);
                     // Alice writes three 'chat' records
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: alice.did,
                             protocol: protocolDefinition.protocol,
@@ -2548,12 +2536,12 @@ export function testRecordsQueryHandler() {
                             parentContextId: threadRecord.message.contextId,
                             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 });
+                        const chatReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         expect(chatReply.status.code).toBe(202);
                         chatRecordIds.push(chatRecord.message.recordId);
                     }
                     // Bob invokes his friendRole to query that records
-                    const chatQuery = yield TestDataGenerator.generateRecordsQuery({
+                    const chatQuery = await TestDataGenerator.generateRecordsQuery({
                         author: bob,
                         filter: {
                             protocol: protocolDefinition.protocol,
@@ -2562,37 +2550,37 @@ export function testRecordsQueryHandler() {
                         },
                         protocolRole: 'thread/participant',
                     });
-                    const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
+                    const chatQueryReply = await dwn.processMessage(alice.did, chatQuery.message);
                     expect(chatQueryReply.status.code).toBe(200);
-                    expect((_a = chatQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(3);
+                    expect(chatQueryReply.entries?.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* () {
+                });
+                it('does not execute protocol queries where protocolPath is missing from the filter', async () => {
                     // scenario: Alice gives Bob a root-level role and writes some chat messages. Bob invokes his root-level role to query those messages,
                     //           but his query filter does not include protocolPath.
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     const protocolDefinition = friendRoleProtocolDefinition;
-                    const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                    const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                     expect(protocolsConfigureReply.status.code).toBe(202);
                     // Alice writes a 'friend' root-level role record with Bob as recipient
-                    const friendRoleRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const friendRoleRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         recipient: bob.did,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'friend',
                         data: new TextEncoder().encode('Bob is my friend'),
                     });
-                    const friendRoleReply = yield dwn.processMessage(alice.did, friendRoleRecord.message, { dataStream: friendRoleRecord.dataStream });
+                    const friendRoleReply = await dwn.processMessage(alice.did, friendRoleRecord.message, { dataStream: friendRoleRecord.dataStream });
                     expect(friendRoleReply.status.code).toBe(202);
                     // Alice writes three 'chat' records
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: alice.did,
                             protocol: protocolDefinition.protocol,
@@ -2600,12 +2588,12 @@ export function testRecordsQueryHandler() {
                             published: false,
                             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 });
+                        const chatReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         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
-                    const chatQuery = yield TestDataGenerator.generateRecordsQuery({
+                    const chatQuery = await TestDataGenerator.generateRecordsQuery({
                         author: bob,
                         filter: {
                             protocol: protocolDefinition.protocol,
@@ -2613,32 +2601,32 @@ export function testRecordsQueryHandler() {
                         },
                         protocolRole: 'friend',
                     });
-                    const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
+                    const chatQueryReply = await dwn.processMessage(alice.did, chatQuery.message);
                     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* () {
+                });
+                it('does not execute context role authorized queries where contextId is missing from the filter', async () => {
                     // scenario: Alice writes some chat messages and gives Bob a role allowing him to access them. But Bob's filter
                     //           does not contain a contextId so the query fails.
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     const protocolDefinition = threadRoleProtocolDefinition;
-                    const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                    const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                     expect(protocolsConfigureReply.status.code).toBe(202);
                     // Alice writes a 'thread' record
-                    const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const threadRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'thread',
                     });
-                    const threadRoleReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+                    const threadRoleReply = await dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
                     expect(threadRoleReply.status.code).toBe(202);
                     // Alice writes a 'friend' root-level role record with Bob as recipient
-                    const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const participantRoleRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         recipient: bob.did,
                         protocol: protocolDefinition.protocol,
@@ -2646,12 +2634,12 @@ export function testRecordsQueryHandler() {
                         parentContextId: threadRecord.message.contextId,
                         data: new TextEncoder().encode('Bob is my friend'),
                     });
-                    const participantRoleReply = yield dwn.processMessage(alice.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
+                    const participantRoleReply = await dwn.processMessage(alice.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
                     expect(participantRoleReply.status.code).toBe(202);
                     // Alice writes three 'chat' records
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: alice.did,
                             protocol: protocolDefinition.protocol,
@@ -2660,12 +2648,12 @@ export function testRecordsQueryHandler() {
                             parentContextId: threadRecord.message.contextId,
                             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 });
+                        const chatReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         expect(chatReply.status.code).toBe(202);
                         chatRecordIds.push(chatRecord.message.recordId);
                     }
                     // Bob invokes his thread participant role to query
-                    const chatQuery = yield TestDataGenerator.generateRecordsQuery({
+                    const chatQuery = await TestDataGenerator.generateRecordsQuery({
                         author: bob,
                         filter: {
                             protocol: protocolDefinition.protocol,
@@ -2674,26 +2662,26 @@ export function testRecordsQueryHandler() {
                         },
                         protocolRole: 'thread/participant',
                     });
-                    const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
+                    const chatQueryReply = await dwn.processMessage(alice.did, chatQuery.message);
                     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* () {
+                });
+                it('should reject root-level role authorized queries if a matching root-level role record is not found for the message author', async () => {
                     // scenario: Alice creates a thread and writes some chat messages writes a chat message.
                     //           Bob invokes a root-level role but fails because he does not actually have a role.
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     const protocolDefinition = friendRoleProtocolDefinition;
-                    const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                    const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                     expect(protocolsConfigureReply.status.code).toBe(202);
                     // Alice writes three 'chat' records
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: alice.did,
                             protocol: protocolDefinition.protocol,
@@ -2701,12 +2689,12 @@ export function testRecordsQueryHandler() {
                             published: false,
                             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 });
+                        const chatReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         expect(chatReply.status.code).toBe(202);
                         chatRecordIds.push(chatRecord.message.recordId);
                     }
                     // Bob invokes his friendRole to query that records
-                    const chatQuery = yield TestDataGenerator.generateRecordsQuery({
+                    const chatQuery = await TestDataGenerator.generateRecordsQuery({
                         author: bob,
                         filter: {
                             protocol: protocolDefinition.protocol,
@@ -2714,32 +2702,32 @@ export function testRecordsQueryHandler() {
                         },
                         protocolRole: 'friend',
                     });
-                    const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
+                    const chatQueryReply = await dwn.processMessage(alice.did, chatQuery.message);
                     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();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should reject context role authorized queries if a matching context role record is not found for the message author', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     const protocolDefinition = threadRoleProtocolDefinition;
-                    const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                    const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                     expect(protocolsConfigureReply.status.code).toBe(202);
                     // Alice writes a 'thread' record
-                    const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const threadRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'thread',
                     });
-                    const threadRoleReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+                    const threadRoleReply = await dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
                     expect(threadRoleReply.status.code).toBe(202);
                     // Alice writes three 'chat' records
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: alice.did,
                             protocol: protocolDefinition.protocol,
@@ -2748,12 +2736,12 @@ export function testRecordsQueryHandler() {
                             parentContextId: threadRecord.message.contextId,
                             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 });
+                        const chatReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         expect(chatReply.status.code).toBe(202);
                         chatRecordIds.push(chatRecord.message.recordId);
                     }
                     // Bob invokes his friendRole to query that records
-                    const chatQuery = yield TestDataGenerator.generateRecordsQuery({
+                    const chatQuery = await TestDataGenerator.generateRecordsQuery({
                         author: bob,
                         filter: {
                             protocol: protocolDefinition.protocol,
@@ -2762,10 +2750,10 @@ export function testRecordsQueryHandler() {
                         },
                         protocolRole: 'thread/participant',
                     });
-                    const chatQueryReply = yield dwn.processMessage(alice.did, chatQuery.message);
+                    const chatQueryReply = await dwn.processMessage(alice.did, chatQuery.message);
                     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 = {
@@ -2786,23 +2774,22 @@ export function testRecordsQueryHandler() {
                             },
                         },
                     };
-                    it('recipient can query records addressed to them via who-based rule', () => __awaiter(this, void 0, void 0, function* () {
-                        var _a, _b;
+                    it('recipient can query records addressed to them via who-based rule', async () => {
                         // 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({
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
+                        const carol = await TestDataGenerator.generateDidKeyPersona();
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition: whoQueryProtocol,
                         });
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await 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({
+                            const msg = await TestDataGenerator.generateRecordsWrite({
                                 author: alice,
                                 recipient: bob.did,
                                 protocol: whoQueryProtocol.protocol,
@@ -2811,12 +2798,12 @@ export function testRecordsQueryHandler() {
                                 dataFormat: 'text/plain',
                                 data: new TextEncoder().encode(`message for bob ${i}`),
                             });
-                            const reply = yield dwn.processMessage(alice.did, msg.message, { dataStream: msg.dataStream });
+                            const reply = await 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({
+                        const carolMsg = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: carol.did,
                             protocol: whoQueryProtocol.protocol,
@@ -2825,48 +2812,47 @@ export function testRecordsQueryHandler() {
                             dataFormat: 'text/plain',
                             data: new TextEncoder().encode('message for carol'),
                         });
-                        const carolWriteReply = yield dwn.processMessage(alice.did, carolMsg.message, { dataStream: carolMsg.dataStream });
+                        const carolWriteReply = await 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({
+                        const bobQuery = await TestDataGenerator.generateRecordsQuery({
                             author: bob,
                             filter: {
                                 protocol: whoQueryProtocol.protocol,
                                 protocolPath: 'message',
                             },
                         });
-                        const bobQueryReply = yield dwn.processMessage(alice.did, bobQuery.message);
+                        const bobQueryReply = await 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?.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({
+                        const carolQuery = await TestDataGenerator.generateRecordsQuery({
                             author: carol,
                             filter: {
                                 protocol: whoQueryProtocol.protocol,
                                 protocolPath: 'message',
                             },
                         });
-                        const carolQueryReply = yield dwn.processMessage(alice.did, carolQuery.message);
+                        const carolQueryReply = await 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?.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;
+                    });
+                    it('author can query their own records via who-based rule', async () => {
                         // 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({
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
+                        const carol = await TestDataGenerator.generateDidKeyPersona();
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition: whoQueryProtocol,
                         });
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await 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({
+                        const bobMsg = await TestDataGenerator.generateRecordsWrite({
                             author: bob,
                             recipient: alice.did,
                             protocol: whoQueryProtocol.protocol,
@@ -2875,48 +2861,47 @@ export function testRecordsQueryHandler() {
                             dataFormat: 'text/plain',
                             data: new TextEncoder().encode('message from bob'),
                         });
-                        const bobWriteReply = yield dwn.processMessage(alice.did, bobMsg.message, { dataStream: bobMsg.dataStream });
+                        const bobWriteReply = await 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({
+                        const bobQuery = await TestDataGenerator.generateRecordsQuery({
                             author: bob,
                             filter: {
                                 protocol: whoQueryProtocol.protocol,
                                 protocolPath: 'message',
                             },
                         });
-                        const bobQueryReply = yield dwn.processMessage(alice.did, bobQuery.message);
+                        const bobQueryReply = await 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?.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({
+                        const carolQuery = await TestDataGenerator.generateRecordsQuery({
                             author: carol,
                             filter: {
                                 protocol: whoQueryProtocol.protocol,
                                 protocolPath: 'message',
                             },
                         });
-                        const carolQueryReply = yield dwn.processMessage(alice.did, carolQuery.message);
+                        const carolQueryReply = await 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;
+                        expect(carolQueryReply.entries?.length).toBe(0);
+                    });
+                    it('unauthorized party cannot see any unpublished records via query', async () => {
                         // 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({
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
+                        const dave = await TestDataGenerator.generateDidKeyPersona();
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition: whoQueryProtocol,
                         });
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await 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({
+                            const msg = await TestDataGenerator.generateRecordsWrite({
                                 author: alice,
                                 recipient: bob.did,
                                 protocol: whoQueryProtocol.protocol,
@@ -2925,22 +2910,22 @@ export function testRecordsQueryHandler() {
                                 dataFormat: 'text/plain',
                                 data: new TextEncoder().encode(`secret message ${i}`),
                             });
-                            const reply = yield dwn.processMessage(alice.did, msg.message, { dataStream: msg.dataStream });
+                            const reply = await 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({
+                        const daveQuery = await TestDataGenerator.generateRecordsQuery({
                             author: dave,
                             filter: {
                                 protocol: whoQueryProtocol.protocol,
                                 protocolPath: 'message',
                             },
                         });
-                        const daveQueryReply = yield dwn.processMessage(alice.did, daveQuery.message);
+                        const daveQueryReply = await 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);
+                        expect(daveQueryReply.entries?.length).toBe(0);
                         // Dave queries with explicit unpublished filter — still sees nothing
-                        const daveUnpubQuery = yield TestDataGenerator.generateRecordsQuery({
+                        const daveUnpubQuery = await TestDataGenerator.generateRecordsQuery({
                             author: dave,
                             filter: {
                                 protocol: whoQueryProtocol.protocol,
@@ -2948,18 +2933,17 @@ export function testRecordsQueryHandler() {
                                 published: false,
                             },
                         });
-                        const daveUnpubReply = yield dwn.processMessage(alice.did, daveUnpubQuery.message);
+                        const daveUnpubReply = await 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;
+                        expect(daveUnpubReply.entries?.length).toBe(0);
+                    });
+                    it('who-based query rules do not grant role-like broad access', async () => {
                         // 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();
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
+                        const dave = await TestDataGenerator.generateDidKeyPersona();
                         // Protocol with both a role AND who-based rules
                         const mixedProtocol = {
                             published: true,
@@ -2984,33 +2968,33 @@ export function testRecordsQueryHandler() {
                                 },
                             },
                         };
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition: mixedProtocol,
                         });
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates a thread
-                        const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const threadRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: mixedProtocol.protocol,
                             protocolPath: 'thread',
                         });
-                        const threadReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+                        const threadReply = await 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({
+                        const participantRecord = await 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 });
+                        const participantReply = await 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({
+                            const chatRecord = await TestDataGenerator.generateRecordsWrite({
                                 author: alice,
                                 recipient: alice.did,
                                 protocol: mixedProtocol.protocol,
@@ -3020,11 +3004,11 @@ export function testRecordsQueryHandler() {
                                 dataFormat: 'text/plain',
                                 data: new TextEncoder().encode(`chat message ${i}`),
                             });
-                            const chatReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+                            const chatReply = await 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({
+                        const bobRoleQuery = await TestDataGenerator.generateRecordsQuery({
                             author: bob,
                             filter: {
                                 protocol: mixedProtocol.protocol,
@@ -3033,11 +3017,11 @@ export function testRecordsQueryHandler() {
                             },
                             protocolRole: 'thread/participant',
                         });
-                        const bobRoleQueryReply = yield dwn.processMessage(alice.did, bobRoleQuery.message);
+                        const bobRoleQueryReply = await 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);
+                        expect(bobRoleQueryReply.entries?.length).toBe(3);
                         // Dave (who is NOT a participant) tries to invoke the role — should be rejected
-                        const daveRoleQuery = yield TestDataGenerator.generateRecordsQuery({
+                        const daveRoleQuery = await TestDataGenerator.generateRecordsQuery({
                             author: dave,
                             filter: {
                                 protocol: mixedProtocol.protocol,
@@ -3046,50 +3030,54 @@ export function testRecordsQueryHandler() {
                             },
                             protocolRole: 'thread/participant',
                         });
-                        const daveRoleQueryReply = yield dwn.processMessage(alice.did, daveRoleQuery.message);
+                        const daveRoleQueryReply = await 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({
+                        const daveNoRoleQuery = await TestDataGenerator.generateRecordsQuery({
                             author: dave,
                             filter: {
                                 protocol: mixedProtocol.protocol,
                                 protocolPath: 'thread/chat',
                             },
                         });
-                        const daveNoRoleQueryReply = yield dwn.processMessage(alice.did, daveNoRoleQuery.message);
+                        const daveNoRoleQueryReply = await 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);
-                    }));
+                        expect(daveNoRoleQueryReply.entries?.length).toBe(0);
+                    });
                 });
             });
         });
-        it('should return 401 if signature check fails', () => __awaiter(this, void 0, void 0, function* () {
-            const { author, message } = yield TestDataGenerator.generateRecordsQuery();
+        it('should return 401 if signature check fails', async () => {
+            const { author, message } = await TestDataGenerator.generateRecordsQuery();
             const tenant = author.did;
             // setting up a stub did resolver & message store
             // intentionally not supplying the public key so a different public key is generated to simulate invalid signature
-            const mismatchingPersona = yield TestDataGenerator.generatePersona({ did: author.did, keyId: author.keyId });
+            const mismatchingPersona = await TestDataGenerator.generatePersona({ did: author.did, keyId: author.keyId });
             const didResolver = TestStubGenerator.createDidResolverStub(mismatchingPersona);
             const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
             const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-            const recordsQueryHandler = new RecordsQueryHandler(didResolver, messageStoreStub, dataStoreStub);
-            const reply = yield recordsQueryHandler.handle({ tenant, message });
+            const recordsQueryHandler = new RecordsQueryHandler({
+                didResolver, messageStore: messageStoreStub, dataStore: dataStoreStub,
+            });
+            const reply = await recordsQueryHandler.handle({ tenant, message });
             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();
+        });
+        it('should return 400 if fail parsing the message', async () => {
+            const { author, message } = await TestDataGenerator.generateRecordsQuery();
             const tenant = author.did;
             // setting up a stub method resolver & message store
             const didResolver = TestStubGenerator.createDidResolverStub(author);
             const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
             const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-            const recordsQueryHandler = new RecordsQueryHandler(didResolver, messageStoreStub, dataStoreStub);
+            const recordsQueryHandler = new RecordsQueryHandler({
+                didResolver, messageStore: messageStoreStub, dataStore: dataStoreStub,
+            });
             // stub the `parse()` function to throw an error
             sinon.stub(RecordsQuery, 'parse').throws('anyError');
-            const reply = yield recordsQueryHandler.handle({ tenant, message });
+            const reply = await recordsQueryHandler.handle({ tenant, message });
             expect(reply.status.code).toBe(400);
-        }));
+        });
     });
 }
 //# sourceMappingURL=records-query.spec.js.map