@enbox/dwn-sdk-js 0.0.6 → 0.0.8

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

@@ -1,12 +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());
-    });
-};
 import sinon from 'sinon';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import friendRoleProtocolDefinition from '../vectors/protocol-definitions/friend-role.json' with { type: 'json' };
@@ -17,14 +8,14 @@ import { Poller } from '../utils/poller.js';
 import { RecordsSubscribe } from '../../src/interfaces/records-subscribe.js';
 import { RecordsSubscribeHandler } from '../../src/handlers/records-subscribe.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 { DidKey, UniversalResolver } from '@enbox/dids';
-import { Dwn, DwnErrorCode, DwnMethodName, EventEmitterStream, MessageStoreLevel, Time } from '../../src/index.js';
+import { Dwn, DwnErrorCode, DwnMethodName, EventEmitterEventLog, MessageStoreLevel, Time } from '../../src/index.js';
 export function testRecordsSubscribeHandler() {
     describe('RecordsSubscribeHandler.handle()', () => {
-        describe('EventStream disabled', () => {
+        describe('EventLog disabled', () => {
             let didResolver;
             let messageStore;
             let resumableTaskStore;
@@ -33,44 +24,44 @@ export function testRecordsSubscribeHandler() {
             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;
-                dwn = yield Dwn.create({
+                dwn = await Dwn.create({
                     didResolver,
                     messageStore,
                     dataStore,
                     resumableTaskStore,
                     stateIndex,
                 });
-            }));
-            beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+            });
+            beforeEach(async () => {
                 sinon.restore(); // wipe all previous stubs/spies/mocks/fakes
                 // 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 respond with a 501 if subscriptions are not supported', () => __awaiter(this, void 0, void 0, function* () {
-                yield dwn.close(); // close the original dwn instance
-                dwn = yield Dwn.create({ didResolver, messageStore, dataStore, stateIndex, resumableTaskStore }); // leave out eventStream
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                await messageStore.clear();
+                await dataStore.clear();
+                await resumableTaskStore.clear();
+                await stateIndex.clear();
+            });
+            afterAll(async () => {
+                await dwn.close();
+            });
+            it('should respond with a 501 if subscriptions are not supported', async () => {
+                await dwn.close(); // close the original dwn instance
+                dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, resumableTaskStore }); // leave out eventLog
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // attempt to subscribe
-                const { message } = yield TestDataGenerator.generateRecordsSubscribe({
+                const { message } = await TestDataGenerator.generateRecordsSubscribe({
                     author: alice,
                 });
-                const subscriptionMessageReply = yield dwn.processMessage(alice.did, message, { subscriptionHandler: (_) => { } });
+                const subscriptionMessageReply = await dwn.processMessage(alice.did, message, { subscriptionHandler: (_) => { } });
                 expect(subscriptionMessageReply.status.code).toBe(501, subscriptionMessageReply.status.detail);
-                expect(subscriptionMessageReply.status.detail).toContain(DwnErrorCode.RecordsSubscribeEventStreamUnimplemented);
-            }));
+                expect(subscriptionMessageReply.status.detail).toContain(DwnErrorCode.RecordsSubscribeEventLogUnimplemented);
+            });
         });
         describe('functional tests', () => {
             let didResolver;
@@ -78,63 +69,64 @@ export function testRecordsSubscribeHandler() {
             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();
+                dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventLog, resumableTaskStore });
+            });
+            beforeEach(async () => {
                 sinon.restore(); // wipe all previous stubs/spies/mocks/fakes
                 // 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 return a subscription object', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const recordsSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
+                await messageStore.clear();
+                await dataStore.clear();
+                await resumableTaskStore.clear();
+                await stateIndex.clear();
+            });
+            afterAll(async () => {
+                await dwn.close();
+            });
+            it('should return a subscription object', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const recordsSubscribe = await TestDataGenerator.generateRecordsSubscribe({
                     author: alice,
                     filter: { schema: 'some-schema' },
                 });
                 // Send records subscribe message
-                const reply = yield dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler: () => { } });
+                const reply = await dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler: () => { } });
                 expect(reply.status.code).toBe(200);
                 expect(reply.subscription).toBeDefined();
                 expect(reply.entries).toBeDefined();
                 expect(reply.entries.length).toBe(0); // no matching records exist yet
-            }));
-            it('should return initial entries matching the filter', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should return initial entries matching the filter', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // write some records before subscribing
-                const write1 = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://test-schema' });
-                const write1Reply = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                const write1 = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://test-schema' });
+                const write1Reply = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
                 expect(write1Reply.status.code).toBe(202);
-                const write2 = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://test-schema' });
-                const write2Reply = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                const write2 = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://test-schema' });
+                const write2Reply = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
                 expect(write2Reply.status.code).toBe(202);
                 // write a record with a different schema that should NOT be in the entries
-                const write3 = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://other-schema' });
-                const write3Reply = yield dwn.processMessage(alice.did, write3.message, { dataStream: write3.dataStream });
+                const write3 = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://other-schema' });
+                const write3Reply = await dwn.processMessage(alice.did, write3.message, { dataStream: write3.dataStream });
                 expect(write3Reply.status.code).toBe(202);
                 // subscribe with a filter that matches only the first two writes
-                const recordsSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
+                const recordsSubscribe = await TestDataGenerator.generateRecordsSubscribe({
                     author: alice,
                     filter: { schema: 'http://test-schema' },
                 });
-                const subReply = yield dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler: () => { } });
+                const subReply = await dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler: () => { } });
                 expect(subReply.status.code).toBe(200);
                 expect(subReply.subscription).toBeDefined();
                 expect(subReply.entries).toBeDefined();
@@ -142,47 +134,49 @@ export function testRecordsSubscribeHandler() {
                 const returnedRecordIds = subReply.entries.map(e => e.recordId);
                 expect(returnedRecordIds).toContain(write1.message.recordId);
                 expect(returnedRecordIds).toContain(write2.message.recordId);
-            }));
-            it('should support pagination on initial entries', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should support pagination on initial entries', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // write 5 records
                 for (let i = 0; i < 5; i++) {
-                    const write = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://paginated' });
-                    const writeReply = yield dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
+                    const write = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://paginated' });
+                    const writeReply = await dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
                     expect(writeReply.status.code).toBe(202);
                 }
                 // subscribe with a limit of 2
-                const recordsSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
+                const recordsSubscribe = await TestDataGenerator.generateRecordsSubscribe({
                     author: alice,
                     filter: { schema: 'http://paginated' },
                     pagination: { limit: 2 },
                 });
-                const subReply = yield dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler: () => { } });
+                const subReply = await dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler: () => { } });
                 expect(subReply.status.code).toBe(200);
                 expect(subReply.subscription).toBeDefined();
                 expect(subReply.entries).toBeDefined();
                 expect(subReply.entries.length).toBe(2);
                 expect(subReply.cursor).toBeDefined();
-            }));
-            it('should include initialWrite for updated records in entries', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should include initialWrite for updated records in entries', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // create a record
-                const write = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://update-test' });
-                const writeReply = yield dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
+                const write = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://update-test' });
+                const writeReply = await dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // update the record
-                const update = yield TestDataGenerator.generateFromRecordsWrite({
+                const update = await TestDataGenerator.generateFromRecordsWrite({
                     author: alice,
                     existingWrite: write.recordsWrite,
                 });
-                const updateReply = yield dwn.processMessage(alice.did, update.message, { dataStream: update.dataStream });
+                const updateReply = await dwn.processMessage(alice.did, update.message, { dataStream: update.dataStream });
                 expect(updateReply.status.code).toBe(202);
                 // subscribe and check the entries
-                const recordsSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
+                const recordsSubscribe = await TestDataGenerator.generateRecordsSubscribe({
                     author: alice,
                     filter: { schema: 'http://update-test' },
                 });
-                const subReply = yield dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler: () => { } });
+                const subReply = await dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler: () => { } });
                 expect(subReply.status.code).toBe(200);
                 expect(subReply.entries).toBeDefined();
                 expect(subReply.entries.length).toBe(1);
@@ -190,188 +184,306 @@ export function testRecordsSubscribeHandler() {
                 expect(subReply.entries[0].recordId).toBe(write.message.recordId);
                 expect(subReply.entries[0].initialWrite).toBeDefined();
                 expect(subReply.entries[0].initialWrite.descriptor.dateCreated).toBe(write.message.descriptor.dateCreated);
-            }));
-            it('should still receive live events after initial entries', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should still receive live events after initial entries', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // write a record before subscribing
-                const write1 = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://live-test' });
-                const write1Reply = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                const write1 = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://live-test' });
+                const write1Reply = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
                 expect(write1Reply.status.code).toBe(202);
                 // subscribe
                 const receivedEvents = [];
-                const subscriptionHandler = (event) => { receivedEvents.push(event); };
-                const recordsSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
+                const subscriptionHandler = (msg) => { if (msg.type === 'event') {
+                    receivedEvents.push(msg.event);
+                } };
+                const recordsSubscribe = await TestDataGenerator.generateRecordsSubscribe({
                     author: alice,
                     filter: { schema: 'http://live-test' },
                 });
-                const subReply = yield dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler });
+                const subReply = await dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler });
                 expect(subReply.status.code).toBe(200);
                 expect(subReply.entries.length).toBe(1); // initial entries has write1
                 // write another record after subscribing
-                const write2 = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://live-test' });
-                const write2Reply = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                const write2 = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://live-test' });
+                const write2Reply = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
                 expect(write2Reply.status.code).toBe(202);
                 // wait for the event to arrive
-                yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                await Poller.pollUntilSuccessOrTimeout(async () => {
                     expect(receivedEvents.length).toBe(1);
                     expect(receivedEvents[0].message.recordId).toBe(write2.message.recordId);
-                }));
-            }));
-            it('should return 400 if protocol is not normalized', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+            });
+            describe('cursor-based subscriptions', () => {
+                it('should use EventLog catch-up when cursor is provided (no initial MessageStore query)', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                    // Read the EventLog to get the current cursor position before writing records.
+                    const { cursor: cursorBefore } = await eventLog.read(alice.did);
+                    // Write records before subscribing.
+                    const write1 = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://cursor-test' });
+                    const write1Reply = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                    expect(write1Reply.status.code).toBe(202);
+                    const write2 = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://cursor-test' });
+                    const write2Reply = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                    expect(write2Reply.status.code).toBe(202);
+                    // Subscribe with the cursor from before the writes. The handler takes the
+                    // EventLog catch-up path, replaying events through the subscription handler.
+                    const receivedEvents = [];
+                    const subscriptionHandler = (msg) => { if (msg.type === 'event') {
+                        receivedEvents.push(msg.event);
+                    } };
+                    const recordsSubscribe = await TestDataGenerator.generateRecordsSubscribe({
+                        author: alice,
+                        filter: { schema: 'http://cursor-test' },
+                        cursor: cursorBefore,
+                    });
+                    const subReply = await dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler });
+                    expect(subReply.status.code).toBe(200);
+                    expect(subReply.subscription).toBeDefined();
+                    // In cursor mode, initial entries are NOT returned via the reply —
+                    // they come through the subscription handler as catch-up events.
+                    // The handler wraps SubscriptionListener→RecordSubscriptionHandler,
+                    // so we get plain RecordEvents (EOSE is silently consumed).
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
+                        expect(receivedEvents.length).toBeGreaterThanOrEqual(2);
+                    });
+                    // Verify the catch-up events are our records.
+                    const recordIds = receivedEvents.map(e => e.message.recordId);
+                    expect(recordIds).toContain(write1.message.recordId);
+                    expect(recordIds).toContain(write2.message.recordId);
+                });
+                it('should receive live events after cursor catch-up', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                    // Write a record before subscribing.
+                    const write1 = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://cursor-live' });
+                    await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                    // Read to get a cursor that includes write1's protocol config + the record.
+                    const { cursor: cursorAfterWrite1 } = await eventLog.read(alice.did);
+                    // Write another record that we'll want to catch up on.
+                    const write2 = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://cursor-live' });
+                    await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                    const receivedEvents = [];
+                    const subscriptionHandler = (msg) => { if (msg.type === 'event') {
+                        receivedEvents.push(msg.event);
+                    } };
+                    const recordsSubscribe = await TestDataGenerator.generateRecordsSubscribe({
+                        author: alice,
+                        filter: { schema: 'http://cursor-live' },
+                        cursor: cursorAfterWrite1,
+                    });
+                    const subReply = await dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler });
+                    expect(subReply.status.code).toBe(200);
+                    // Wait for catch-up event (write2).
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
+                        expect(receivedEvents.length).toBeGreaterThanOrEqual(1);
+                    });
+                    // Write a live record after subscribing.
+                    const write3 = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://cursor-live' });
+                    await dwn.processMessage(alice.did, write3.message, { dataStream: write3.dataStream });
+                    // Wait for the live event.
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
+                        expect(receivedEvents.length).toBeGreaterThanOrEqual(2);
+                    });
+                    const recordIds = receivedEvents.map(e => e.message.recordId);
+                    expect(recordIds).toContain(write2.message.recordId);
+                    expect(recordIds).toContain(write3.message.recordId);
+                });
+                it('should filter catch-up events when cursor and filter are provided', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                    // Get cursor before writing.
+                    const { cursor: cursorBefore } = await eventLog.read(alice.did);
+                    // Write records with different schemas.
+                    const matchWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://filter-match' });
+                    await dwn.processMessage(alice.did, matchWrite.message, { dataStream: matchWrite.dataStream });
+                    const noMatchWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'http://filter-other' });
+                    await dwn.processMessage(alice.did, noMatchWrite.message, { dataStream: noMatchWrite.dataStream });
+                    const receivedEvents = [];
+                    const subscriptionHandler = (msg) => { if (msg.type === 'event') {
+                        receivedEvents.push(msg.event);
+                    } };
+                    const recordsSubscribe = await TestDataGenerator.generateRecordsSubscribe({
+                        author: alice,
+                        filter: { schema: 'http://filter-match' },
+                        cursor: cursorBefore,
+                    });
+                    const subReply = await dwn.processMessage(alice.did, recordsSubscribe.message, { subscriptionHandler });
+                    expect(subReply.status.code).toBe(200);
+                    // Wait for catch-up events. Should only get the matching one.
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
+                        expect(receivedEvents.length).toBe(1);
+                        expect(receivedEvents[0].message.recordId).toBe(matchWrite.message.recordId);
+                    });
+                });
+            });
+            it('should return 400 if protocol is not normalized', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // subscribe for non-normalized protocol
-                const recordsSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
+                const recordsSubscribe = await TestDataGenerator.generateRecordsSubscribe({
                     author: alice,
                     filter: { protocol: 'example.com/' },
                 });
                 // overwrite protocol because #create auto-normalizes protocol
                 recordsSubscribe.message.descriptor.filter.protocol = 'example.com/';
                 // Re-create auth because we altered the descriptor after signing
-                recordsSubscribe.message.authorization = yield Message.createAuthorization({
+                recordsSubscribe.message.authorization = await Message.createAuthorization({
                     descriptor: recordsSubscribe.message.descriptor,
                     signer: Jws.createSigner(alice)
                 });
                 // Send records subscribe message
-                const reply = yield dwn.processMessage(alice.did, recordsSubscribe.message);
+                const reply = await dwn.processMessage(alice.did, recordsSubscribe.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();
                 // subscribe for non-normalized schema
-                const recordsSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
+                const recordsSubscribe = await TestDataGenerator.generateRecordsSubscribe({
                     author: alice,
                     filter: { schema: 'example.com/' },
                 });
                 // overwrite schema because #create auto-normalizes schema
                 recordsSubscribe.message.descriptor.filter.schema = 'example.com/';
                 // Re-create auth because we altered the descriptor after signing
-                recordsSubscribe.message.authorization = yield Message.createAuthorization({
+                recordsSubscribe.message.authorization = await Message.createAuthorization({
                     descriptor: recordsSubscribe.message.descriptor,
                     signer: Jws.createSigner(alice)
                 });
                 // Send records subscribe message
-                const reply = yield dwn.processMessage(alice.did, recordsSubscribe.message);
+                const reply = await dwn.processMessage(alice.did, recordsSubscribe.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 recordSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
+                const recordSubscribe = await TestDataGenerator.generateRecordsSubscribe({
                     author: alice,
                     filter: { datePublished: { from: fromDatePublished }, published: true }
                 });
                 // set to false
                 recordSubscribe.message.descriptor.filter.published = false;
-                const subscribeResponse = yield dwn.processMessage(alice.did, recordSubscribe.message);
+                const subscribeResponse = await dwn.processMessage(alice.did, recordSubscribe.message);
                 expect(subscribeResponse.status.code).toBe(400);
                 expect(subscribeResponse.status.detail).toContain('descriptor/filter/published: must be equal to one of the allowed values');
-            }));
-            it('should return 401 for anonymous subscriptions that filter explicitly for unpublished records', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should return 401 for anonymous subscriptions 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 subscribe
-                const unpublishedPostSubscribe = yield TestDataGenerator.generateRecordsSubscribe({ author: alice, filter: { schema: 'post', published: false } });
-                const unpublishedPostReply = yield dwn.processMessage(alice.did, unpublishedPostSubscribe.message, { subscriptionHandler: () => { } });
+                const unpublishedPostSubscribe = await TestDataGenerator.generateRecordsSubscribe({ author: alice, filter: { schema: 'post', published: false } });
+                const unpublishedPostReply = await dwn.processMessage(alice.did, unpublishedPostSubscribe.message, { subscriptionHandler: () => { } });
                 expect(unpublishedPostReply.status.code).toBe(200);
                 expect(unpublishedPostReply.subscription).toBeDefined();
                 // anonymous subscribe for unpublished records
-                const unpublishedAnonymous = yield RecordsSubscribe.create({ filter: { schema: 'post', published: false } });
-                const anonymousPostReply = yield dwn.processMessage(alice.did, unpublishedAnonymous.message);
+                const unpublishedAnonymous = await RecordsSubscribe.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');
                 expect(anonymousPostReply.subscription).toBeUndefined();
-            }));
-            it('should return 401 if signature check fails', () => __awaiter(this, void 0, void 0, function* () {
-                const { author, message } = yield TestDataGenerator.generateRecordsSubscribe();
+            });
+            it('should return 401 if signature check fails', async () => {
+                const { author, message } = await TestDataGenerator.generateRecordsSubscribe();
                 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 eventStreamStub = sinon.createStubInstance(EventEmitterStream);
-                const recordsSubscribeHandler = new RecordsSubscribeHandler(didResolver, messageStoreStub, eventStreamStub);
-                const reply = yield recordsSubscribeHandler.handle({ tenant, message, subscriptionHandler: () => { } });
+                const eventLogStub = sinon.createStubInstance(EventEmitterEventLog);
+                const recordsSubscribeHandler = new RecordsSubscribeHandler({
+                    didResolver, messageStore: messageStoreStub, eventLog: eventLogStub,
+                });
+                const reply = await recordsSubscribeHandler.handle({ tenant, message, subscriptionHandler: () => { } });
                 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.generateRecordsSubscribe();
+            });
+            it('should return 400 if fail parsing the message', async () => {
+                const { author, message } = await TestDataGenerator.generateRecordsSubscribe();
                 const tenant = author.did;
                 // setting up a stub method resolver & message store
                 const didResolver = TestStubGenerator.createDidResolverStub(author);
                 const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
-                const eventStreamStub = sinon.createStubInstance(EventEmitterStream);
-                const recordsSubscribeHandler = new RecordsSubscribeHandler(didResolver, messageStoreStub, eventStreamStub);
+                const eventLogStub = sinon.createStubInstance(EventEmitterEventLog);
+                const recordsSubscribeHandler = new RecordsSubscribeHandler({
+                    didResolver, messageStore: messageStoreStub, eventLog: eventLogStub,
+                });
                 // stub the `parse()` function to throw an error
                 sinon.stub(RecordsSubscribe, 'parse').throws('anyError');
-                const reply = yield recordsSubscribeHandler.handle({ tenant, message, subscriptionHandler: () => { } });
+                const reply = await recordsSubscribeHandler.handle({ tenant, message, subscriptionHandler: () => { } });
                 expect(reply.status.code).toBe(400);
-            }));
+            });
             describe('protocol based subscriptions', () => {
-                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:
                     //           Bob and Carol subscribe to a chat protocol without invoking a protocolRole,
                     //           they should receive chat messages addressed to them, respectively.
                     //           Alice creates a thread and writes some chat messages to Bob and Carol.
                     //           Bob receives only the chat messages addressed to him, Carol receives only the chat messages addressed to her.
-                    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 = 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);
                     const bobMessages = [];
-                    const handleForBob = (event) => __awaiter(this, void 0, void 0, function* () {
-                        const { message } = event;
-                        const messageCid = yield Message.getCid(message);
+                    const handleForBob = async (msg) => {
+                        if (msg.type !== 'event') {
+                            return;
+                        }
+                        const { message } = msg.event;
+                        const messageCid = await Message.getCid(message);
                         bobMessages.push(messageCid);
-                    });
-                    const bobSubscription = yield TestDataGenerator.generateRecordsSubscribe({
+                    };
+                    const bobSubscription = await TestDataGenerator.generateRecordsSubscribe({
                         author: bob,
                         filter: {
                             published: false,
                             protocol: protocolDefinition.protocol,
                         }
                     });
-                    const subscriptionReply = yield dwn.processMessage(alice.did, bobSubscription.message, { subscriptionHandler: handleForBob });
+                    const subscriptionReply = await dwn.processMessage(alice.did, bobSubscription.message, { subscriptionHandler: handleForBob });
                     expect(subscriptionReply.status.code).toBe(200);
                     expect(subscriptionReply.subscription).toBeDefined();
                     const carolMessages = [];
-                    const handleForCarol = (event) => __awaiter(this, void 0, void 0, function* () {
-                        const { message } = event;
-                        const messageCid = yield Message.getCid(message);
+                    const handleForCarol = async (msg) => {
+                        if (msg.type !== 'event') {
+                            return;
+                        }
+                        const { message } = msg.event;
+                        const messageCid = await Message.getCid(message);
                         carolMessages.push(messageCid);
-                    });
-                    const carolSubscription = yield TestDataGenerator.generateRecordsSubscribe({
+                    };
+                    const carolSubscription = await TestDataGenerator.generateRecordsSubscribe({
                         author: carol,
                         filter: {
                             published: false,
                             protocol: protocolDefinition.protocol,
                         }
                     });
-                    const carolSubscriptionReply = yield dwn.processMessage(alice.did, carolSubscription.message, { subscriptionHandler: handleForCarol });
+                    const carolSubscriptionReply = await dwn.processMessage(alice.did, carolSubscription.message, { subscriptionHandler: handleForCarol });
                     expect(carolSubscriptionReply.status.code).toBe(200);
                     expect(carolSubscriptionReply.subscription).toBeDefined();
                     // 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,
@@ -380,11 +492,11 @@ export function testRecordsSubscribeHandler() {
                         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);
-                    const chatRecordForBobCid = yield Message.getCid(chatRecordForBob.message);
+                    const chatRecordForBobCid = await Message.getCid(chatRecordForBob.message);
                     // Alice writes two 'chat' records addressed to Carol
-                    const chatRecordForCarol1 = yield TestDataGenerator.generateRecordsWrite({
+                    const chatRecordForCarol1 = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         recipient: carol.did,
                         protocol: protocolDefinition.protocol,
@@ -393,10 +505,10 @@ export function testRecordsSubscribeHandler() {
                         parentContextId: threadRecord.message.contextId,
                         data: new TextEncoder().encode('Bob cannot read this'),
                     });
-                    const chatRecordForCarol1Reply = yield dwn.processMessage(alice.did, chatRecordForCarol1.message, { dataStream: chatRecordForCarol1.dataStream });
+                    const chatRecordForCarol1Reply = await dwn.processMessage(alice.did, chatRecordForCarol1.message, { dataStream: chatRecordForCarol1.dataStream });
                     expect(chatRecordForCarol1Reply.status.code).toBe(202);
-                    const chatRecordForCarol1Cid = yield Message.getCid(chatRecordForCarol1.message);
-                    const chatRecordForCarol2 = yield TestDataGenerator.generateRecordsWrite({
+                    const chatRecordForCarol1Cid = await Message.getCid(chatRecordForCarol1.message);
+                    const chatRecordForCarol2 = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         recipient: carol.did,
                         protocol: protocolDefinition.protocol,
@@ -405,86 +517,90 @@ export function testRecordsSubscribeHandler() {
                         parentContextId: threadRecord.message.contextId,
                         data: new TextEncoder().encode('Bob cannot read this either'),
                     });
-                    const chatRecordForCarol2Reply = yield dwn.processMessage(alice.did, chatRecordForCarol2.message, { dataStream: chatRecordForCarol2.dataStream });
+                    const chatRecordForCarol2Reply = await dwn.processMessage(alice.did, chatRecordForCarol2.message, { dataStream: chatRecordForCarol2.dataStream });
                     expect(chatRecordForCarol2Reply.status.code).toBe(202);
-                    const chatRecordForCarol2Cid = yield Message.getCid(chatRecordForCarol2.message);
-                    yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    const chatRecordForCarol2Cid = await Message.getCid(chatRecordForCarol2.message);
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
                         expect(bobMessages.length).toBe(1);
                         expect(bobMessages).toEqual(expect.arrayContaining([chatRecordForBobCid]));
-                    }));
-                    yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
                         expect(carolMessages.length).toBe(2);
                         expect(carolMessages).toEqual(expect.arrayContaining([chatRecordForCarol1Cid, chatRecordForCarol2Cid]));
-                    }));
-                }));
-                it('allows root-level role authorized subscriptions', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                });
+                it('allows root-level role authorized subscriptions', async () => {
                     // scenario: Alice creates a thread and writes some chat messages writes a chat message. Bob invokes his
                     //           thread member role in order to subscribe to the chat messages.
-                    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 = 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);
                     const filter = {
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'chat'
                     };
                     const noRoleRecords = new Set();
-                    const addNoRole = (event) => __awaiter(this, void 0, void 0, function* () {
-                        const { message } = event;
+                    const addNoRole = async (msg) => {
+                        if (msg.type !== 'event') {
+                            return;
+                        }
+                        const { message } = msg.event;
                         if (message.descriptor.method === DwnMethodName.Write) {
-                            const recordsWriteMessage = message;
-                            noRoleRecords.add(recordsWriteMessage.recordId);
+                            noRoleRecords.add(message.recordId);
                         }
                         else {
                             noRoleRecords.delete(message.descriptor.recordId);
                         }
-                    });
+                    };
                     // subscribe without role, expect no messages
-                    const noRoleSubscription = yield TestDataGenerator.generateRecordsSubscribe({
+                    const noRoleSubscription = await TestDataGenerator.generateRecordsSubscribe({
                         author: bob,
                         filter
                     });
-                    const subscriptionReply = yield dwn.processMessage(alice.did, noRoleSubscription.message, { subscriptionHandler: addNoRole });
+                    const subscriptionReply = await dwn.processMessage(alice.did, noRoleSubscription.message, { subscriptionHandler: addNoRole });
                     expect(subscriptionReply.status.code).toBe(200);
                     expect(subscriptionReply.subscription).toBeDefined();
                     // 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);
                     const recordIds = new Set();
-                    const addRecord = (event) => __awaiter(this, void 0, void 0, function* () {
-                        const { message } = event;
+                    const addRecord = async (msg) => {
+                        if (msg.type !== 'event') {
+                            return;
+                        }
+                        const { message } = msg.event;
                         if (message.descriptor.method === DwnMethodName.Write) {
-                            const recordsWriteMessage = message;
-                            recordIds.add(recordsWriteMessage.recordId);
+                            recordIds.add(message.recordId);
                         }
                         else {
                             recordIds.delete(message.descriptor.recordId);
                         }
-                    });
+                    };
                     // subscribe with friend role
-                    const bobSubscriptionWithRole = yield TestDataGenerator.generateRecordsSubscribe({
+                    const bobSubscriptionWithRole = await TestDataGenerator.generateRecordsSubscribe({
                         filter,
                         author: bob,
                         protocolRole: 'friend',
                     });
-                    const subscriptionWithRoleReply = yield dwn.processMessage(alice.did, bobSubscriptionWithRole.message, { subscriptionHandler: addRecord });
+                    const subscriptionWithRoleReply = await dwn.processMessage(alice.did, bobSubscriptionWithRole.message, { subscriptionHandler: addRecord });
                     expect(subscriptionWithRoleReply.status.code).toBe(200);
                     expect(subscriptionWithRoleReply.subscription).toBeDefined();
                     // Create one chat message for Bob as a control to show up in the `noRoleRecords` array
-                    const chatRecordForBob = yield TestDataGenerator.generateRecordsWrite({
+                    const chatRecordForBob = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         recipient: bob.did,
                         protocol: protocolDefinition.protocol,
@@ -492,12 +608,12 @@ export function testRecordsSubscribeHandler() {
                         published: false,
                         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 three more 'chat' records for carol, Bob's friend role should allow him to see these messages.
                     const chatRecordIds = [];
                     for (let i = 0; i < 3; i++) {
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: carol.did,
                             protocol: protocolDefinition.protocol,
@@ -505,20 +621,20 @@ export function testRecordsSubscribeHandler() {
                             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);
                     }
                     // there should only be the control message for bob in the subscription without a friend role.
-                    yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
                         expect(noRoleRecords.size).toBe(1);
                         expect([...noRoleRecords]).toEqual(expect.arrayContaining([chatRecordForBob.message.recordId]));
-                    }));
+                    });
                     // All chats should be in the subscription with the friend role.
-                    yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
                         expect(recordIds.size).toBe(4);
                         expect([...recordIds]).toEqual(expect.arrayContaining([chatRecordForBob.message.recordId, ...chatRecordIds]));
-                    }));
+                    });
                     // TODO: https://github.com/enboxorg/enbox/issues/759
                     //      When `RecordsSubscribeHandler` builds up the matchFilters there are no matching filters for a delete within a context
                     //      so the delete event is not being captured by the subscription handler. This is likely due to some of the filters including
@@ -544,26 +660,26 @@ export function testRecordsSubscribeHandler() {
                     //   expect(recordIds.size).toBe(2); // both chat records were removed from the set
                     //   expect([ ...recordIds ]).toEqual(expect.arrayContaining([ ...chatRecordIds.slice(1) ])); // only the last two chat records remain
                     // });
-                }));
-                it('can authorize subscriptions using a context role', () => __awaiter(this, void 0, void 0, function* () {
+                });
+                it('can authorize subscriptions using a context role', async () => {
                     // scenario: Alice writes some chat messages.
                     //           Bob, having a thread/participant record, can subscribe to the chat.
-                    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);
                     const filter = {
                         protocol: protocolDefinition.protocol,
@@ -571,23 +687,26 @@ export function testRecordsSubscribeHandler() {
                         contextId: threadRecord.message.contextId,
                     };
                     const noRoleRecords = [];
-                    const addNoRole = (event) => __awaiter(this, void 0, void 0, function* () {
-                        const { message } = event;
+                    const addNoRole = async (msg) => {
+                        if (msg.type !== 'event') {
+                            return;
+                        }
+                        const { message } = msg.event;
                         if (message.descriptor.method === DwnMethodName.Write) {
                             const recordsWriteMessage = message;
                             noRoleRecords.push(recordsWriteMessage.recordId);
                         }
-                    });
+                    };
                     // subscribe without role, expect no messages
-                    const noRoleSubscription = yield TestDataGenerator.generateRecordsSubscribe({
+                    const noRoleSubscription = await TestDataGenerator.generateRecordsSubscribe({
                         author: bob,
                         filter
                     });
-                    const subscriptionReply = yield dwn.processMessage(alice.did, noRoleSubscription.message, { subscriptionHandler: addNoRole });
+                    const subscriptionReply = await dwn.processMessage(alice.did, noRoleSubscription.message, { subscriptionHandler: addNoRole });
                     expect(subscriptionReply.status.code).toBe(200);
                     expect(subscriptionReply.subscription).toBeDefined();
                     // 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,
@@ -595,29 +714,32 @@ export function testRecordsSubscribeHandler() {
                         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);
                     const recordIds = [];
-                    const addRecord = (event) => __awaiter(this, void 0, void 0, function* () {
-                        const { message } = event;
+                    const addRecord = async (msg) => {
+                        if (msg.type !== 'event') {
+                            return;
+                        }
+                        const { message } = msg.event;
                         if (message.descriptor.method === DwnMethodName.Write) {
                             const recordsWriteMessage = message;
                             recordIds.push(recordsWriteMessage.recordId);
                         }
-                    });
+                    };
                     // subscribe with the participant role
-                    const bobSubscriptionWithRole = yield TestDataGenerator.generateRecordsSubscribe({
+                    const bobSubscriptionWithRole = await TestDataGenerator.generateRecordsSubscribe({
                         filter,
                         author: bob,
                         protocolRole: 'thread/participant',
                     });
-                    const subscriptionWithRoleReply = yield dwn.processMessage(alice.did, bobSubscriptionWithRole.message, { subscriptionHandler: addRecord });
+                    const subscriptionWithRoleReply = await dwn.processMessage(alice.did, bobSubscriptionWithRole.message, { subscriptionHandler: addRecord });
                     expect(subscriptionWithRoleReply.status.code).toBe(200);
                     expect(subscriptionWithRoleReply.subscription).toBeDefined();
                     // 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,
@@ -626,41 +748,41 @@ export function testRecordsSubscribeHandler() {
                             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);
                     }
-                    yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
                         // should have all chat messages.
                         expect(recordIds).toEqual(expect.arrayContaining(chatRecordIds));
                         // there should not be any messages in the subscription without a participant role.
                         expect(noRoleRecords.length).toBe(0);
-                    }));
-                }));
-                it('does not execute protocol subscriptions where protocolPath is missing from the filter', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                });
+                it('does not execute protocol subscriptions where protocolPath is missing from the filter', async () => {
                     // scenario: Alice assigns Bob a friend role and writes some chat messages. Bob invokes his role to subscribe those messages,
                     //           but his subscription 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);
                     // Bob invokes his friendRole to subscribe but does not have `protocolPath` in the filter
-                    const chatSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
+                    const chatSubscribe = await TestDataGenerator.generateRecordsSubscribe({
                         author: bob,
                         filter: {
                             protocol: protocolDefinition.protocol,
@@ -668,33 +790,33 @@ export function testRecordsSubscribeHandler() {
                         },
                         protocolRole: 'friend',
                     });
-                    const chatSubscribeReply = yield dwn.processMessage(alice.did, chatSubscribe.message);
+                    const chatSubscribeReply = await dwn.processMessage(alice.did, chatSubscribe.message);
                     expect(chatSubscribeReply.status.code).toBe(400);
                     expect(chatSubscribeReply.status.detail).toContain(DwnErrorCode.RecordsSubscribeFilterMissingRequiredProperties);
                     expect(chatSubscribeReply.subscription).toBeUndefined();
-                }));
-                it('does not execute context role authorized subscriptions where contextId is missing from the filter', () => __awaiter(this, void 0, void 0, function* () {
+                });
+                it('does not execute context role authorized subscriptions where contextId is missing from the filter', async () => {
                     // scenario: Alice gives Bob a role allowing him to access a particular chat thread.
                     //           But Bob's filter does not contain a contextId so the subscription 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,
@@ -702,10 +824,10 @@ export function testRecordsSubscribeHandler() {
                         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);
                     // Bob invokes his thread participant role to subscribe but omits the contextId
-                    const chatSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
+                    const chatSubscribe = await TestDataGenerator.generateRecordsSubscribe({
                         author: bob,
                         filter: {
                             protocol: protocolDefinition.protocol,
@@ -714,25 +836,25 @@ export function testRecordsSubscribeHandler() {
                         },
                         protocolRole: 'thread/participant',
                     });
-                    const chatSubscribeReply = yield dwn.processMessage(alice.did, chatSubscribe.message);
+                    const chatSubscribeReply = await dwn.processMessage(alice.did, chatSubscribe.message);
                     expect(chatSubscribeReply.status.code).toBe(401);
                     expect(chatSubscribeReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMissingContextId);
                     expect(chatSubscribeReply.subscription).toBeUndefined();
-                }));
-                it('rejects role authorized subscriptions if the request author does not have a matching root-level role', () => __awaiter(this, void 0, void 0, function* () {
+                });
+                it('rejects role authorized subscriptions if the request author does not have a matching root-level role', async () => {
                     // scenario: Alice installs a chat protocol.
                     // Bob invokes a root-level role within that protocol to subscribe 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);
                     // Bob invokes a friendRole he does not have to subscribe to the records
-                    const chatSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
+                    const chatSubscribe = await TestDataGenerator.generateRecordsSubscribe({
                         author: bob,
                         filter: {
                             protocol: protocolDefinition.protocol,
@@ -740,31 +862,31 @@ export function testRecordsSubscribeHandler() {
                         },
                         protocolRole: 'friend',
                     });
-                    const chatSubscribeReply = yield dwn.processMessage(alice.did, chatSubscribe.message);
+                    const chatSubscribeReply = await dwn.processMessage(alice.did, chatSubscribe.message);
                     expect(chatSubscribeReply.status.code).toBe(401);
                     expect(chatSubscribeReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
                     expect(chatSubscribeReply.subscription).toBeUndefined();
-                }));
-                it('rejects role authorized subscriptions where the subscription author does not have a matching context role', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('rejects role authorized subscriptions where the subscription author does not have a matching context role', 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);
                     // Bob invokes his a `thread/participant` role which he does not have to subscribe to the records
-                    const chatSubscribe = yield TestDataGenerator.generateRecordsSubscribe({
+                    const chatSubscribe = await TestDataGenerator.generateRecordsSubscribe({
                         author: bob,
                         filter: {
                             protocol: protocolDefinition.protocol,
@@ -773,11 +895,11 @@ export function testRecordsSubscribeHandler() {
                         },
                         protocolRole: 'thread/participant',
                     });
-                    const chatSubscribeReply = yield dwn.processMessage(alice.did, chatSubscribe.message);
+                    const chatSubscribeReply = await dwn.processMessage(alice.did, chatSubscribe.message);
                     expect(chatSubscribeReply.status.code).toBe(401);
                     expect(chatSubscribeReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
                     expect(chatSubscribeReply.subscription).toBeUndefined();
-                }));
+                });
                 describe('who-based query/subscribe action rules', () => {
                     const whoSubscribeProtocol = {
                         published: true,
@@ -797,75 +919,84 @@ export function testRecordsSubscribeHandler() {
                             },
                         },
                     };
-                    it('recipient receives only events for records addressed to them', () => __awaiter(this, void 0, void 0, function* () {
+                    it('recipient receives only events for records addressed to them', async () => {
                         // scenario: Bob and Carol each subscribe to Alice's DWN. Alice writes messages
                         //           to Bob and Carol. Each subscriber only receives their own messages.
                         //           Dave subscribes and receives nothing.
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const bob = yield TestDataGenerator.generateDidKeyPersona();
-                        const carol = yield TestDataGenerator.generateDidKeyPersona();
-                        const dave = yield TestDataGenerator.generateDidKeyPersona();
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
+                        const carol = await TestDataGenerator.generateDidKeyPersona();
+                        const dave = await TestDataGenerator.generateDidKeyPersona();
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition: whoSubscribeProtocol,
                         });
-                        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 subscribes — no role
                         const bobRecordIds = new Set();
-                        const bobHandler = (event) => __awaiter(this, void 0, void 0, function* () {
-                            const { message } = event;
+                        const bobHandler = async (msg) => {
+                            if (msg.type !== 'event') {
+                                return;
+                            }
+                            const { message } = msg.event;
                             if (message.descriptor.method === DwnMethodName.Write) {
                                 bobRecordIds.add(message.recordId);
                             }
-                        });
-                        const bobSub = yield TestDataGenerator.generateRecordsSubscribe({
+                        };
+                        const bobSub = await TestDataGenerator.generateRecordsSubscribe({
                             author: bob,
                             filter: {
                                 published: false,
                                 protocol: whoSubscribeProtocol.protocol,
                             },
                         });
-                        const bobSubReply = yield dwn.processMessage(alice.did, bobSub.message, { subscriptionHandler: bobHandler });
+                        const bobSubReply = await dwn.processMessage(alice.did, bobSub.message, { subscriptionHandler: bobHandler });
                         expect(bobSubReply.status.code).toBe(200);
                         // Carol subscribes — no role
                         const carolRecordIds = new Set();
-                        const carolHandler = (event) => __awaiter(this, void 0, void 0, function* () {
-                            const { message } = event;
+                        const carolHandler = async (msg) => {
+                            if (msg.type !== 'event') {
+                                return;
+                            }
+                            const { message } = msg.event;
                             if (message.descriptor.method === DwnMethodName.Write) {
                                 carolRecordIds.add(message.recordId);
                             }
-                        });
-                        const carolSub = yield TestDataGenerator.generateRecordsSubscribe({
+                        };
+                        const carolSub = await TestDataGenerator.generateRecordsSubscribe({
                             author: carol,
                             filter: {
                                 published: false,
                                 protocol: whoSubscribeProtocol.protocol,
                             },
                         });
-                        const carolSubReply = yield dwn.processMessage(alice.did, carolSub.message, { subscriptionHandler: carolHandler });
+                        const carolSubReply = await dwn.processMessage(alice.did, carolSub.message, { subscriptionHandler: carolHandler });
                         expect(carolSubReply.status.code).toBe(200);
                         // Dave subscribes — no role, not a participant at all
                         const daveRecordIds = new Set();
-                        const daveHandler = (event) => __awaiter(this, void 0, void 0, function* () {
-                            const { message } = event;
+                        const daveHandler = async (msg) => {
+                            if (msg.type !== 'event') {
+                                return;
+                            }
+                            const { message } = msg.event;
                             if (message.descriptor.method === DwnMethodName.Write) {
                                 daveRecordIds.add(message.recordId);
                             }
-                        });
-                        const daveSub = yield TestDataGenerator.generateRecordsSubscribe({
+                        };
+                        const daveSub = await TestDataGenerator.generateRecordsSubscribe({
                             author: dave,
                             filter: {
                                 published: false,
                                 protocol: whoSubscribeProtocol.protocol,
                             },
                         });
-                        const daveSubReply = yield dwn.processMessage(alice.did, daveSub.message, { subscriptionHandler: daveHandler });
+                        const daveSubReply = await dwn.processMessage(alice.did, daveSub.message, { subscriptionHandler: daveHandler });
                         expect(daveSubReply.status.code).toBe(200);
                         // Alice writes 2 messages for Bob
                         const expectedBobIds = [];
                         for (let i = 0; i < 2; i++) {
-                            const msg = yield TestDataGenerator.generateRecordsWrite({
+                            const msg = await TestDataGenerator.generateRecordsWrite({
                                 author: alice,
                                 recipient: bob.did,
                                 protocol: whoSubscribeProtocol.protocol,
@@ -874,12 +1005,12 @@ export function testRecordsSubscribeHandler() {
                                 dataFormat: 'text/plain',
                                 data: new TextEncoder().encode(`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);
                             expectedBobIds.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: whoSubscribeProtocol.protocol,
@@ -888,10 +1019,10 @@ export function testRecordsSubscribeHandler() {
                             dataFormat: 'text/plain',
                             data: new TextEncoder().encode('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);
                         // Alice writes 1 message addressed to herself (nobody else should see it)
-                        const aliceMsg = yield TestDataGenerator.generateRecordsWrite({
+                        const aliceMsg = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: alice.did,
                             protocol: whoSubscribeProtocol.protocol,
@@ -900,28 +1031,28 @@ export function testRecordsSubscribeHandler() {
                             dataFormat: 'text/plain',
                             data: new TextEncoder().encode('private'),
                         });
-                        const aliceWriteReply = yield dwn.processMessage(alice.did, aliceMsg.message, { dataStream: aliceMsg.dataStream });
+                        const aliceWriteReply = await dwn.processMessage(alice.did, aliceMsg.message, { dataStream: aliceMsg.dataStream });
                         expect(aliceWriteReply.status.code).toBe(202);
                         // Bob should receive exactly 2 events
-                        yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                        await Poller.pollUntilSuccessOrTimeout(async () => {
                             expect(bobRecordIds.size).toBe(2);
                             expect([...bobRecordIds]).toEqual(expect.arrayContaining(expectedBobIds));
-                        }));
+                        });
                         // Carol should receive exactly 1 event
-                        yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                        await Poller.pollUntilSuccessOrTimeout(async () => {
                             expect(carolRecordIds.size).toBe(1);
                             expect([...carolRecordIds]).toEqual(expect.arrayContaining([carolMsg.message.recordId]));
-                        }));
+                        });
                         // Dave should receive zero events
                         // Give a small window for any stray events to arrive, then assert empty
-                        yield Time.sleep(200);
+                        await Time.sleep(200);
                         expect(daveRecordIds.size).toBe(0);
-                    }));
-                    it('who-based subscribe rules do not grant role-like broad access', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    it('who-based subscribe rules do not grant role-like broad access', async () => {
                         // scenario: Dave tries to invoke a protocolRole on a protocol with who-based
                         //           subscribe rules. Should be rejected because he has no role record.
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const dave = yield TestDataGenerator.generateDidKeyPersona();
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const dave = await TestDataGenerator.generateDidKeyPersona();
                         const mixedProtocol = {
                             published: true,
                             protocol: 'http://mixed-sub-test.xyz',
@@ -945,22 +1076,22 @@ export function testRecordsSubscribeHandler() {
                                 },
                             },
                         };
-                        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);
                         // Dave tries to subscribe with a role he doesn't have — should be rejected
-                        const daveRoleSub = yield TestDataGenerator.generateRecordsSubscribe({
+                        const daveRoleSub = await TestDataGenerator.generateRecordsSubscribe({
                             author: dave,
                             filter: {
                                 protocol: mixedProtocol.protocol,
@@ -969,11 +1100,11 @@ export function testRecordsSubscribeHandler() {
                             },
                             protocolRole: 'thread/participant',
                         });
-                        const daveRoleSubReply = yield dwn.processMessage(alice.did, daveRoleSub.message);
+                        const daveRoleSubReply = await dwn.processMessage(alice.did, daveRoleSub.message);
                         expect(daveRoleSubReply.status.code).toBe(401);
                         expect(daveRoleSubReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
                         expect(daveRoleSubReply.subscription).toBeUndefined();
-                    }));
+                    });
                 });
             });
         });