@enbox/dwn-sdk-js 0.0.6 → 0.0.8

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

@@ -1,30 +1,21 @@
-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 { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
+import freeForAll from '../vectors/protocol-definitions/free-for-all.json' with { type: 'json' };
+import sinon from 'sinon';
 import { Dwn } from '../../src/dwn.js';
 import { DwnErrorCode } from '../../src/core/dwn-error.js';
-import freeForAll from '../vectors/protocol-definitions/free-for-all.json' with { type: 'json' };
 import { Jws } from '../../src/utils/jws.js';
 import { Message } from '../../src/core/message.js';
 import { MessagesSubscribe } from '../../src/interfaces/messages-subscribe.js';
 import { MessagesSubscribeHandler } from '../../src/handlers/messages-subscribe.js';
 import { Poller } from '../utils/poller.js';
-import sinon from 'sinon';
 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 { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import { DidKey, UniversalResolver } from '@enbox/dids';
 import { DwnInterfaceName, DwnMethodName } from '../../src/index.js';
 export function testMessagesSubscribeHandler() {
     describe('MessagesSubscribe.handle()', () => {
-        describe('EventStream disabled', () => {
+        describe('EventLog disabled', () => {
             let didResolver;
             let messageStore;
             let dataStore;
@@ -33,147 +24,229 @@ export function testMessagesSubscribeHandler() {
             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 MessagesSubscribe.create({ signer: Jws.createSigner(alice) });
-                const subscriptionMessageReply = yield dwn.processMessage(alice.did, message, { subscriptionHandler: (_) => { } });
+                const { message } = await MessagesSubscribe.create({ signer: Jws.createSigner(alice) });
+                const subscriptionMessageReply = await dwn.processMessage(alice.did, message, { subscriptionHandler: (_) => { } });
                 expect(subscriptionMessageReply.status.code).toBe(501);
-                expect(subscriptionMessageReply.status.detail).toContain(DwnErrorCode.MessagesSubscribeEventStreamUnimplemented);
-            }));
+                expect(subscriptionMessageReply.status.detail).toContain(DwnErrorCode.MessagesSubscribeEventLogUnimplemented);
+            });
         });
-        describe('EventStream enabled', () => {
+        describe('EventLog enabled', () => {
             let didResolver;
             let messageStore;
             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({
+                eventLog = TestEventLog.get();
+                eventLog = TestEventLog.get();
+                dwn = await Dwn.create({
                     didResolver,
                     messageStore,
                     dataStore,
                     resumableTaskStore,
                     stateIndex,
-                    eventStream,
+                    eventLog,
                 });
-            }));
-            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('returns a 400 if message is invalid', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const { message } = yield TestDataGenerator.generateMessagesSubscribe({ author: alice });
+                await messageStore.clear();
+                await dataStore.clear();
+                await resumableTaskStore.clear();
+                await stateIndex.clear();
+            });
+            afterAll(async () => {
+                await dwn.close();
+            });
+            it('returns a 400 if message is invalid', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const { message } = await TestDataGenerator.generateMessagesSubscribe({ author: alice });
                 // add an invalid property to the descriptor
                 message['descriptor']['invalid'] = 'invalid';
-                const messagesSubscribeHandler = new MessagesSubscribeHandler(didResolver, messageStore, eventStream);
-                const reply = yield messagesSubscribeHandler.handle({ tenant: alice.did, message, subscriptionHandler: (_) => { } });
+                const messagesSubscribeHandler = new MessagesSubscribeHandler({
+                    didResolver, messageStore, eventLog,
+                });
+                const reply = await messagesSubscribeHandler.handle({ tenant: alice.did, message, subscriptionHandler: (_) => { } });
                 expect(reply.status.code).toBe(400);
-            }));
-            it('should allow tenant to subscribe their own event stream', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should allow tenant to subscribe their own event stream', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // set up a promise to read later that captures the emitted messageCid
                 let handler;
                 const messageSubscriptionPromise = new Promise((resolve) => {
-                    handler = (event) => __awaiter(this, void 0, void 0, function* () {
-                        const { message } = event;
-                        const messageCid = yield Message.getCid(message);
+                    handler = async (msg) => {
+                        if (msg.type !== 'event') {
+                            return;
+                        }
+                        const { message } = msg.event;
+                        const messageCid = await Message.getCid(message);
                         resolve(messageCid);
-                    });
+                    };
                 });
                 // testing MessagesSubscribe
-                const messagesSubscribe = yield MessagesSubscribe.create({
+                const messagesSubscribe = await MessagesSubscribe.create({
                     signer: Jws.createSigner(alice),
                 });
-                const subscriptionReply = yield dwn.processMessage(alice.did, messagesSubscribe.message, { subscriptionHandler: handler });
+                const subscriptionReply = await dwn.processMessage(alice.did, messagesSubscribe.message, { subscriptionHandler: handler });
                 expect(subscriptionReply.status.code).toBe(200);
                 expect(subscriptionReply.subscription).toBeDefined();
-                const messageWrite = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                const writeReply = yield dwn.processMessage(alice.did, messageWrite.message, { dataStream: messageWrite.dataStream });
+                const messageWrite = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                const writeReply = await dwn.processMessage(alice.did, messageWrite.message, { dataStream: messageWrite.dataStream });
                 expect(writeReply.status.code).toBe(202);
-                const messageCid = yield Message.getCid(messageWrite.message);
+                const messageCid = await Message.getCid(messageWrite.message);
                 // control: ensure that the event exists
-                const events = yield stateIndex.getLeaves(alice.did, []);
-                expect(events.length).toBe(1);
-                expect(events[0]).toBe(messageCid);
+                const events = await stateIndex.getLeaves(alice.did, []);
+                expect(events.length).toBe(2);
+                expect(events).toContain(messageCid);
                 // await the event
-                const resolvedCid = yield messageSubscriptionPromise;
+                const resolvedCid = await messageSubscriptionPromise;
                 expect(resolvedCid).toBe(messageCid);
-            }));
-            it('should not allow non-tenant to subscribe to an event stream they are not authorized for', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should not allow non-tenant to subscribe to an event stream they are not authorized for', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // test anonymous request
-                const anonymousSubscription = yield TestDataGenerator.generateMessagesSubscribe();
+                const anonymousSubscription = await TestDataGenerator.generateMessagesSubscribe();
                 delete anonymousSubscription.message.authorization;
-                const anonymousReply = yield dwn.processMessage(alice.did, anonymousSubscription.message);
+                const anonymousReply = await dwn.processMessage(alice.did, anonymousSubscription.message);
                 expect(anonymousReply.status.code).toBe(400);
                 expect(anonymousReply.status.detail).toContain(`MessagesSubscribe: must have required property 'authorization'`);
                 expect(anonymousReply.subscription).toBeUndefined();
                 // testing MessagesSubscribe
-                const messagesSubscribe = yield MessagesSubscribe.create({
+                const messagesSubscribe = await MessagesSubscribe.create({
                     signer: Jws.createSigner(bob),
                 });
-                const subscriptionReply = yield dwn.processMessage(alice.did, messagesSubscribe.message);
+                const subscriptionReply = await dwn.processMessage(alice.did, messagesSubscribe.message);
                 expect(subscriptionReply.status.code).toBe(401);
                 expect(subscriptionReply.subscription).toBeUndefined();
-            }));
+            });
+            describe('cursor-based subscriptions', () => {
+                it('should deliver catch-up events through the handler when cursor is provided', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                    // Read the EventLog to get a cursor before writing.
+                    const { cursor: cursorBefore } = await eventLog.read(alice.did);
+                    // Write a record before subscribing.
+                    const write1 = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                    const write1Reply = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                    expect(write1Reply.status.code).toBe(202);
+                    const write1Cid = await Message.getCid(write1.message);
+                    // Subscribe with cursor from before the write to catch up.
+                    const messageCids = [];
+                    const handler = async (msg) => {
+                        if (msg.type !== 'event') {
+                            return;
+                        }
+                        const { message } = msg.event;
+                        const cid = await Message.getCid(message);
+                        messageCids.push(cid);
+                    };
+                    const { message: subMessage } = await TestDataGenerator.generateMessagesSubscribe({
+                        author: alice,
+                        cursor: cursorBefore,
+                    });
+                    const subReply = await dwn.processMessage(alice.did, subMessage, { subscriptionHandler: handler });
+                    expect(subReply.status.code).toBe(200);
+                    expect(subReply.subscription).toBeDefined();
+                    // Wait for the catch-up events.
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
+                        expect(messageCids.length).toBeGreaterThanOrEqual(1);
+                        expect(messageCids).toContain(write1Cid);
+                    });
+                });
+                it('should receive live events after cursor catch-up completes', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                    // Write before subscribing.
+                    const write1 = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                    await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                    // Read to get cursor after write1.
+                    const { cursor: cursorAfterWrite1 } = await eventLog.read(alice.did);
+                    // Write another record that we'll catch up on.
+                    const write2 = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                    await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                    const write2Cid = await Message.getCid(write2.message);
+                    const messageCids = [];
+                    const handler = async (msg) => {
+                        if (msg.type !== 'event') {
+                            return;
+                        }
+                        const { message } = msg.event;
+                        const cid = await Message.getCid(message);
+                        messageCids.push(cid);
+                    };
+                    const { message: subMessage } = await TestDataGenerator.generateMessagesSubscribe({
+                        author: alice,
+                        cursor: cursorAfterWrite1,
+                    });
+                    const subReply = await dwn.processMessage(alice.did, subMessage, { subscriptionHandler: handler });
+                    expect(subReply.status.code).toBe(200);
+                    // Wait for catch-up (write2).
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
+                        expect(messageCids).toContain(write2Cid);
+                    });
+                    // Write a live record.
+                    const write3 = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                    await dwn.processMessage(alice.did, write3.message, { dataStream: write3.dataStream });
+                    const write3Cid = await Message.getCid(write3.message);
+                    // Wait for the live event.
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
+                        expect(messageCids).toContain(write3Cid);
+                    });
+                });
+            });
             describe('grant based subscribes', () => {
-                it('allows subscribe of messages with matching interface and method grant scope', () => __awaiter(this, void 0, void 0, function* () {
+                it('allows subscribe of messages with matching interface and method grant scope', async () => {
                     // scenario: Alice gives Bob permission to subscribe for all of her messages
                     // Alice writes various messages
                     // When Bob subscribes for messages, he should receive updates to all of Alice's messages
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     // create grant that is scoped to `MessagesSubscribe` for bob
-                    const { message: grantMessage, dataStream } = yield TestDataGenerator.generateGrantCreate({
+                    const { message: grantMessage, dataStream } = await TestDataGenerator.generateGrantCreate({
                         author: alice,
                         grantedTo: bob,
                         scope: {
@@ -181,67 +254,126 @@ export function testMessagesSubscribeHandler() {
                             method: DwnMethodName.Subscribe
                         }
                     });
-                    const grantReply = yield dwn.processMessage(alice.did, grantMessage, { dataStream });
+                    const grantReply = await dwn.processMessage(alice.did, grantMessage, { dataStream });
                     expect(grantReply.status.code).toBe(202);
+                    // install the default test protocol used by generateRecordsWrite
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     // create a handler to capture the emitted messageCids
                     const messageCids = [];
-                    const handler = (event) => __awaiter(this, void 0, void 0, function* () {
-                        const { message } = event;
-                        const messageCid = yield Message.getCid(message);
+                    const handler = async (msg) => {
+                        if (msg.type !== 'event') {
+                            return;
+                        }
+                        const { message } = msg.event;
+                        const messageCid = await Message.getCid(message);
                         messageCids.push(messageCid);
-                    });
+                    };
                     // subscribe to messages
-                    const { message: subscribeMessage } = yield TestDataGenerator.generateMessagesSubscribe({
+                    const { message: subscribeMessage } = await TestDataGenerator.generateMessagesSubscribe({
                         author: bob,
                         permissionGrantId: grantMessage.recordId,
                     });
-                    const subscribeReply = yield dwn.processMessage(alice.did, subscribeMessage, { subscriptionHandler: handler });
+                    const subscribeReply = await dwn.processMessage(alice.did, subscribeMessage, { subscriptionHandler: handler });
                     expect(subscribeReply.status.code).toBe(200);
                     // configure the freeForAll protocol
-                    const { message: freeForAllConfigure } = yield TestDataGenerator.generateProtocolsConfigure({
+                    const { message: freeForAllConfigure } = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: freeForAll,
                     });
-                    const { status: freeForAllReplyStatus } = yield dwn.processMessage(alice.did, freeForAllConfigure);
+                    const { status: freeForAllReplyStatus } = await dwn.processMessage(alice.did, freeForAllConfigure);
                     expect(freeForAllReplyStatus.code).toBe(202);
                     // configure a random protocol configuration
-                    const { message: protocolMessage } = yield TestDataGenerator.generateProtocolsConfigure({
+                    const { message: protocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                     });
-                    const { status: configureStatus } = yield dwn.processMessage(alice.did, protocolMessage);
+                    const { status: configureStatus } = await dwn.processMessage(alice.did, protocolMessage);
                     expect(configureStatus.code).toBe(202);
                     // write a message to the Records free for all interface
-                    const { message: recordMessage, dataStream: recordDataStream } = yield TestDataGenerator.generateRecordsWrite({
+                    const { message: recordMessage, dataStream: recordDataStream } = await TestDataGenerator.generateRecordsWrite({
                         protocol: freeForAll.protocol,
                         protocolPath: 'post',
                         schema: freeForAll.types.post.schema,
                         author: alice
                     });
-                    const recordReply = yield dwn.processMessage(alice.did, recordMessage, { dataStream: recordDataStream });
+                    const recordReply = await dwn.processMessage(alice.did, recordMessage, { dataStream: recordDataStream });
                     expect(recordReply.status.code).toBe(202);
                     // write a random message
-                    const { message: randomMessage, dataStream: randomDataStream } = yield TestDataGenerator.generateRecordsWrite({
+                    const { message: randomMessage, dataStream: randomDataStream } = await TestDataGenerator.generateRecordsWrite({
                         author: alice
                     });
-                    const randomReply = yield dwn.processMessage(alice.did, randomMessage, { dataStream: randomDataStream });
+                    const randomReply = await dwn.processMessage(alice.did, randomMessage, { dataStream: randomDataStream });
                     expect(randomReply.status.code).toBe(202);
                     // ensure that all messages have been received
-                    yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
                         expect(messageCids.length).toBe(4);
                         const expectedCids = [
-                            yield Message.getCid(freeForAllConfigure),
-                            yield Message.getCid(protocolMessage),
-                            yield Message.getCid(recordMessage),
-                            yield Message.getCid(randomMessage),
+                            await Message.getCid(freeForAllConfigure),
+                            await Message.getCid(protocolMessage),
+                            await Message.getCid(recordMessage),
+                            await Message.getCid(randomMessage),
                         ];
                         expect(messageCids.sort()).toEqual(expectedCids.sort());
-                    }));
-                }));
-                it('rejects subscribe of messages with mismatching interface grant scope', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    });
+                });
+                it('allows subscribe of messages with a unified MessagesRead grant scope', async () => {
+                    // scenario: A Messages.Read grant should also authorize MessagesSubscribe operations
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
+                    // create grant that is scoped to `MessagesRead` (unified) for bob
+                    const { message: grantMessage, dataStream } = await TestDataGenerator.generateGrantCreate({
+                        author: alice,
+                        grantedTo: bob,
+                        scope: {
+                            interface: DwnInterfaceName.Messages,
+                            method: DwnMethodName.Read,
+                        }
+                    });
+                    const grantReply = await dwn.processMessage(alice.did, grantMessage, { dataStream });
+                    expect(grantReply.status.code).toBe(202);
+                    // install the default test protocol used by generateRecordsWrite
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                    // create a handler to capture the emitted messageCids
+                    const messageCids = [];
+                    const handler = async (msg) => {
+                        if (msg.type !== 'event') {
+                            return;
+                        }
+                        const { message } = msg.event;
+                        const messageCid = await Message.getCid(message);
+                        messageCids.push(messageCid);
+                    };
+                    // bob subscribes to messages using the Messages.Read grant
+                    const { message: subscribeMessage } = await TestDataGenerator.generateMessagesSubscribe({
+                        author: bob,
+                        permissionGrantId: grantMessage.recordId,
+                    });
+                    const subscribeReply = await dwn.processMessage(alice.did, subscribeMessage, { subscriptionHandler: handler });
+                    expect(subscribeReply.status.code).toBe(200);
+                    // install the freeForAll protocol and write a record to trigger events
+                    const { message: freeForAllConfigure } = await TestDataGenerator.generateProtocolsConfigure({
+                        author: alice,
+                        protocolDefinition: freeForAll,
+                    });
+                    const { status: freeForAllReplyStatus } = await dwn.processMessage(alice.did, freeForAllConfigure);
+                    expect(freeForAllReplyStatus.code).toBe(202);
+                    const { message: recordMessage, dataStream: recordDataStream } = await TestDataGenerator.generateRecordsWrite({
+                        protocol: freeForAll.protocol,
+                        protocolPath: 'post',
+                        schema: freeForAll.types.post.schema,
+                        author: alice
+                    });
+                    const recordReply = await dwn.processMessage(alice.did, recordMessage, { dataStream: recordDataStream });
+                    expect(recordReply.status.code).toBe(202);
+                    // ensure that at least one event was received
+                    await Poller.pollUntilSuccessOrTimeout(async () => {
+                        expect(messageCids.length).toBeGreaterThanOrEqual(1);
+                    });
+                });
+                it('rejects subscribe of messages with mismatching interface grant scope', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     // create grant that is scoped to `RecordsWrite` for bob scoped to the `freeForAll` protocol
-                    const { message: grantMessage, dataStream } = yield TestDataGenerator.generateGrantCreate({
+                    const { message: grantMessage, dataStream } = await TestDataGenerator.generateGrantCreate({
                         author: alice,
                         grantedTo: bob,
                         scope: {
@@ -250,22 +382,22 @@ export function testMessagesSubscribeHandler() {
                             protocol: freeForAll.protocol
                         }
                     });
-                    const grantReply = yield dwn.processMessage(alice.did, grantMessage, { dataStream });
+                    const grantReply = await dwn.processMessage(alice.did, grantMessage, { dataStream });
                     expect(grantReply.status.code).toBe(202);
                     // bob attempts to use the `RecordsWrite` grant on an `MessagesSubscribe` message
-                    const { message: bobSubscribe } = yield TestDataGenerator.generateMessagesSubscribe({
+                    const { message: bobSubscribe } = await TestDataGenerator.generateMessagesSubscribe({
                         author: bob,
                         permissionGrantId: grantMessage.recordId
                     });
-                    const bobReply = yield dwn.processMessage(alice.did, bobSubscribe);
+                    const bobReply = await dwn.processMessage(alice.did, bobSubscribe);
                     expect(bobReply.status.code).toBe(401);
                     expect(bobReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationInterfaceMismatch);
-                }));
-                it('rejects subscribe of messages with mismatching method grant scopes', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('rejects subscribe of messages with mismatching method grant scopes', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     // create grant that is scoped to `MessagesSync` for bob
-                    const { message: grantMessage, dataStream } = yield TestDataGenerator.generateGrantCreate({
+                    const { message: grantMessage, dataStream } = await TestDataGenerator.generateGrantCreate({
                         author: alice,
                         grantedTo: bob,
                         scope: {
@@ -273,39 +405,39 @@ export function testMessagesSubscribeHandler() {
                             method: DwnMethodName.Sync,
                         }
                     });
-                    const grantReply = yield dwn.processMessage(alice.did, grantMessage, { dataStream });
+                    const grantReply = await dwn.processMessage(alice.did, grantMessage, { dataStream });
                     expect(grantReply.status.code).toBe(202);
                     // bob attempts to use the `MessagesSync` grant on an `MessagesSubscribe` message
-                    const { message: bobSubscribe } = yield TestDataGenerator.generateMessagesSubscribe({
+                    const { message: bobSubscribe } = await TestDataGenerator.generateMessagesSubscribe({
                         author: bob,
                         permissionGrantId: grantMessage.recordId
                     });
-                    const bobReply = yield dwn.processMessage(alice.did, bobSubscribe);
+                    const bobReply = await dwn.processMessage(alice.did, bobSubscribe);
                     expect(bobReply.status.code).toBe(401);
                     expect(bobReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationMethodMismatch);
-                }));
+                });
                 describe('protocol filtered messages', () => {
-                    it('allows subscribe of protocol filtered messages with matching protocol grant scopes', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    it('allows subscribe of protocol filtered messages with matching protocol grant scopes', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
                         // install protocol 1
-                        const protocol1 = Object.assign(Object.assign({}, freeForAll), { published: true, protocol: 'http://protcol1' });
-                        const { message: protocol1Configure } = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocol1 = { ...freeForAll, published: true, protocol: 'http://protcol1' };
+                        const { message: protocol1Configure } = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition: protocol1,
                         });
-                        const { status: protocol1ConfigureStatus } = yield dwn.processMessage(alice.did, protocol1Configure);
+                        const { status: protocol1ConfigureStatus } = await dwn.processMessage(alice.did, protocol1Configure);
                         expect(protocol1ConfigureStatus.code).toBe(202);
                         // install protocol 2
-                        const protocol2 = Object.assign(Object.assign({}, freeForAll), { published: true, protocol: 'http://protcol2' });
-                        const { message: protocol2Configure } = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocol2 = { ...freeForAll, published: true, protocol: 'http://protcol2' };
+                        const { message: protocol2Configure } = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition: protocol2,
                         });
-                        const { status: protocol2ConfigureStatus } = yield dwn.processMessage(alice.did, protocol2Configure);
+                        const { status: protocol2ConfigureStatus } = await dwn.processMessage(alice.did, protocol2Configure);
                         expect(protocol2ConfigureStatus.code).toBe(202);
                         // grant bob permission to subscribe for protocol 1
-                        const { message: grant1Message, dataStream: grant1DataStream } = yield TestDataGenerator.generateGrantCreate({
+                        const { message: grant1Message, dataStream: grant1DataStream } = await TestDataGenerator.generateGrantCreate({
                             author: alice,
                             grantedTo: bob,
                             scope: {
@@ -314,86 +446,92 @@ export function testMessagesSubscribeHandler() {
                                 protocol: protocol1.protocol
                             }
                         });
-                        const grant1Reply = yield dwn.processMessage(alice.did, grant1Message, { dataStream: grant1DataStream });
+                        const grant1Reply = await dwn.processMessage(alice.did, grant1Message, { dataStream: grant1DataStream });
                         expect(grant1Reply.status.code).toBe(202);
                         // bob uses the grant to subscribe to protocol 1 messages
                         const proto1MessageCids = [];
-                        const proto1Handler = (event) => __awaiter(this, void 0, void 0, function* () {
-                            const { message } = event;
-                            const messageCid = yield Message.getCid(message);
+                        const proto1Handler = async (msg) => {
+                            if (msg.type !== 'event') {
+                                return;
+                            }
+                            const { message } = msg.event;
+                            const messageCid = await Message.getCid(message);
                             proto1MessageCids.push(messageCid);
-                        });
-                        const { message: bobSubscribe1 } = yield TestDataGenerator.generateMessagesSubscribe({
+                        };
+                        const { message: bobSubscribe1 } = await TestDataGenerator.generateMessagesSubscribe({
                             author: bob,
                             filters: [{ protocol: protocol1.protocol }],
                             permissionGrantId: grant1Message.recordId
                         });
-                        const bobReply1 = yield dwn.processMessage(alice.did, bobSubscribe1, { subscriptionHandler: proto1Handler });
+                        const bobReply1 = await dwn.processMessage(alice.did, bobSubscribe1, { subscriptionHandler: proto1Handler });
                         expect(bobReply1.status.code).toBe(200);
                         const allMessages = [];
-                        const allHandler = (event) => __awaiter(this, void 0, void 0, function* () {
-                            const { message } = event;
-                            const messageCid = yield Message.getCid(message);
+                        const allHandler = async (msg) => {
+                            if (msg.type !== 'event') {
+                                return;
+                            }
+                            const { message } = msg.event;
+                            const messageCid = await Message.getCid(message);
                             allMessages.push(messageCid);
-                        });
-                        const { message: allSubscribe } = yield TestDataGenerator.generateMessagesSubscribe({
+                        };
+                        const { message: allSubscribe } = await TestDataGenerator.generateMessagesSubscribe({
                             author: alice,
                         });
-                        const allReply = yield dwn.processMessage(alice.did, allSubscribe, { subscriptionHandler: allHandler });
+                        const allReply = await dwn.processMessage(alice.did, allSubscribe, { subscriptionHandler: allHandler });
                         expect(allReply.status.code).toBe(200);
                         // alice writes a message to protocol 1
-                        const { message: proto1Message, dataStream: proto1DataStream } = yield TestDataGenerator.generateRecordsWrite({
+                        const { message: proto1Message, dataStream: proto1DataStream } = await TestDataGenerator.generateRecordsWrite({
                             protocol: protocol1.protocol,
                             protocolPath: 'post',
                             schema: protocol1.types.post.schema,
                             author: alice
                         });
-                        const proto1Reply = yield dwn.processMessage(alice.did, proto1Message, { dataStream: proto1DataStream });
+                        const proto1Reply = await dwn.processMessage(alice.did, proto1Message, { dataStream: proto1DataStream });
                         expect(proto1Reply.status.code).toBe(202);
                         // alice writes a message to protocol 2
-                        const { message: proto2Message, dataStream: proto2DataStream } = yield TestDataGenerator.generateRecordsWrite({
+                        const { message: proto2Message, dataStream: proto2DataStream } = await TestDataGenerator.generateRecordsWrite({
                             protocol: protocol2.protocol,
                             protocolPath: 'post',
                             schema: protocol2.types.post.schema,
                             author: alice
                         });
-                        const proto2Reply = yield dwn.processMessage(alice.did, proto2Message, { dataStream: proto2DataStream });
+                        const proto2Reply = await dwn.processMessage(alice.did, proto2Message, { dataStream: proto2DataStream });
                         expect(proto2Reply.status.code).toBe(202);
                         // ensure that all messages have been received as a control
-                        yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                        await Poller.pollUntilSuccessOrTimeout(async () => {
                             expect(allMessages.length).toBe(2);
                             const expectedAllCids = [
-                                yield Message.getCid(proto1Message),
-                                yield Message.getCid(proto2Message)
+                                await Message.getCid(proto1Message),
+                                await Message.getCid(proto2Message)
                             ];
                             expect(allMessages.sort()).toEqual(expectedAllCids.sort());
                             // proto 1 messages should only have one message
                             expect(proto1MessageCids.length).toBe(1);
-                            const expectedProto1Cids = [yield Message.getCid(proto1Message)];
+                            const expectedProto1Cids = [await Message.getCid(proto1Message)];
                             expect(proto1MessageCids.sort()).toEqual(expectedProto1Cids.sort());
-                        }));
-                    }));
-                    it('rejects subscribe of protocol filtered messages with mismatching protocol grant scopes', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const bob = yield TestDataGenerator.generateDidKeyPersona();
+                        });
+                    });
+                    it('rejects subscribe of protocol filtered messages with mismatching protocol grant scopes', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
                         // install protocol 1
-                        const protocol1 = Object.assign(Object.assign({}, freeForAll), { published: true, protocol: 'http://protcol1' });
-                        const { message: protocol1Configure } = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocol1 = { ...freeForAll, published: true, protocol: 'http://protcol1' };
+                        const { message: protocol1Configure } = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition: protocol1,
                         });
-                        const { status: protocol1ConfigureStatus } = yield dwn.processMessage(alice.did, protocol1Configure);
+                        const { status: protocol1ConfigureStatus } = await dwn.processMessage(alice.did, protocol1Configure);
                         expect(protocol1ConfigureStatus.code).toBe(202);
                         // install protocol 2
-                        const protocol2 = Object.assign(Object.assign({}, freeForAll), { published: true, protocol: 'http://protcol2' });
-                        const { message: protocol2Configure } = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocol2 = { ...freeForAll, published: true, protocol: 'http://protcol2' };
+                        const { message: protocol2Configure } = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition: protocol2,
                         });
-                        const { status: protocol2ConfigureStatus } = yield dwn.processMessage(alice.did, protocol2Configure);
+                        const { status: protocol2ConfigureStatus } = await dwn.processMessage(alice.did, protocol2Configure);
                         expect(protocol2ConfigureStatus.code).toBe(202);
                         // grant bob permission to subscribe for protocol 1
-                        const { message: grant1Message, dataStream: grant1DataStream } = yield TestDataGenerator.generateGrantCreate({
+                        const { message: grant1Message, dataStream: grant1DataStream } = await TestDataGenerator.generateGrantCreate({
                             author: alice,
                             grantedTo: bob,
                             scope: {
@@ -402,30 +540,30 @@ export function testMessagesSubscribeHandler() {
                                 protocol: protocol1.protocol
                             }
                         });
-                        const grant1Reply = yield dwn.processMessage(alice.did, grant1Message, { dataStream: grant1DataStream });
+                        const grant1Reply = await dwn.processMessage(alice.did, grant1Message, { dataStream: grant1DataStream });
                         expect(grant1Reply.status.code).toBe(202);
                         // bob uses the grant for protocol 1 to subscribe for protocol 2 messages
-                        const { message: bobSubscribe1 } = yield TestDataGenerator.generateMessagesSubscribe({
+                        const { message: bobSubscribe1 } = await TestDataGenerator.generateMessagesSubscribe({
                             author: bob,
                             filters: [{ protocol: protocol2.protocol }],
                             permissionGrantId: grant1Message.recordId
                         });
-                        const bobReply1 = yield dwn.processMessage(alice.did, bobSubscribe1);
+                        const bobReply1 = await dwn.processMessage(alice.did, bobSubscribe1);
                         expect(bobReply1.status.code).toBe(401);
                         expect(bobReply1.status.detail).toContain(DwnErrorCode.MessagesGrantAuthorizationMismatchedProtocol);
                         expect(bobReply1.subscription).toBeUndefined();
                         // bob attempts to use the grant for protocol 1 to subscribe to messages in protocol 1 OR protocol 2 given two filters
                         // this should fail because the grant is scoped to protocol 1 only
-                        const { message: bobSubscribe2 } = yield TestDataGenerator.generateMessagesSubscribe({
+                        const { message: bobSubscribe2 } = await TestDataGenerator.generateMessagesSubscribe({
                             author: bob,
                             filters: [{ protocol: protocol1.protocol }, { protocol: protocol2.protocol }],
                             permissionGrantId: grant1Message.recordId
                         });
-                        const bobReply2 = yield dwn.processMessage(alice.did, bobSubscribe2);
+                        const bobReply2 = await dwn.processMessage(alice.did, bobSubscribe2);
                         expect(bobReply2.status.code).toBe(401);
                         expect(bobReply2.status.detail).toContain(DwnErrorCode.MessagesGrantAuthorizationMismatchedProtocol);
                         expect(bobReply2.subscription).toBeUndefined();
-                    }));
+                    });
                 });
             });
         });