@enbox/dwn-sdk-js 0.0.6 → 0.0.8

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

@@ -1,18 +1,9 @@
-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 { GeneralJwsVerifier } from '../../src/jose/jws/general/verifier.js';
 import { Message } from '../../src/core/message.js';
 import minimalProtocolDefinition from '../vectors/protocol-definitions/minimal.json' with { type: 'json' };
 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 { DataStream, Dwn, DwnConstant, DwnErrorCode, DwnInterfaceName, DwnMethodName, Jws, PermissionGrant, PermissionsProtocol, Time } from '../../src/index.js';
@@ -25,114 +16,116 @@ export function testMessagesReadHandler() {
         let dataStore;
         let resumableTaskStore;
         let stateIndex;
-        let eventStream;
+        let eventLog;
         // 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 () => {
             // 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();
+            await messageStore.clear();
+            await dataStore.clear();
+            await resumableTaskStore.clear();
+            await stateIndex.clear();
             sinon.restore(); // wipe all previous stubs/spies/mocks/fakes
-        }));
-        afterAll(() => __awaiter(this, void 0, void 0, function* () {
+        });
+        afterAll(async () => {
             sinon.restore();
-            yield dwn.close();
-        }));
-        it('returns a 401 if authentication fails', () => __awaiter(this, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
+            await dwn.close();
+        });
+        it('returns a 401 if authentication fails', async () => {
+            const alice = await TestDataGenerator.generateDidKeyPersona();
             sinon.stub(GeneralJwsVerifier, 'verifySignatures').throws(new Error('Invalid signature'));
             // alice creates a record
-            const { message } = yield TestDataGenerator.generateMessagesRead({
+            const { message } = await TestDataGenerator.generateMessagesRead({
                 author: alice,
-                messageCid: yield TestDataGenerator.randomCborSha256Cid()
+                messageCid: await TestDataGenerator.randomCborSha256Cid()
             });
             // alice is not the author of the message
-            const reply = yield dwn.processMessage(alice.did, message);
+            const reply = await dwn.processMessage(alice.did, message);
             expect(reply.status.code).toBe(401);
             expect(reply.status.detail).toContain('Invalid signature');
-        }));
-        it('returns a 400 if message is invalid', () => __awaiter(this, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const { recordsWrite } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-            const { message } = yield TestDataGenerator.generateMessagesRead({
+        });
+        it('returns a 400 if message is invalid', async () => {
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const { recordsWrite } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+            const { message } = await TestDataGenerator.generateMessagesRead({
                 author: alice,
-                messageCid: yield Message.getCid(recordsWrite.message)
+                messageCid: await Message.getCid(recordsWrite.message)
             });
             message['descriptor']['troll'] = 'hehe';
-            const reply = yield dwn.processMessage(alice.did, message);
+            const reply = await dwn.processMessage(alice.did, message);
             expect(reply.status.code).toBe(400);
-        }));
-        it('returns a 400 if message contains an invalid message cid', () => __awaiter(this, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const { recordsWrite } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-            const { message } = yield TestDataGenerator.generateMessagesRead({
+        });
+        it('returns a 400 if message contains an invalid message cid', async () => {
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const { recordsWrite } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+            const { message } = await TestDataGenerator.generateMessagesRead({
                 author: alice,
-                messageCid: yield Message.getCid(recordsWrite.message)
+                messageCid: await Message.getCid(recordsWrite.message)
             });
             message.descriptor.messageCid = 'hehetroll';
-            const reply = yield dwn.processMessage(alice.did, message);
+            const reply = await dwn.processMessage(alice.did, message);
             expect(reply.status.code).toBe(400);
             expect(reply.status.detail).toContain('is not a valid CID');
             expect(reply.entry).toBeUndefined();
-        }));
-        it('returns a 404 and the entry as undefined in reply entry when a messageCid is not found', () => __awaiter(this, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const { recordsWrite } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-            const recordsWriteMessageCid = yield Message.getCid(recordsWrite.message);
-            const { message } = yield TestDataGenerator.generateMessagesRead({
+        });
+        it('returns a 404 and the entry as undefined in reply entry when a messageCid is not found', async () => {
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const { recordsWrite } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+            const recordsWriteMessageCid = await Message.getCid(recordsWrite.message);
+            const { message } = await TestDataGenerator.generateMessagesRead({
                 author: alice,
                 messageCid: recordsWriteMessageCid
             });
             // returns a 404 because the RecordsWrite created above was never stored
-            const reply = yield dwn.processMessage(alice.did, message);
+            const reply = await dwn.processMessage(alice.did, message);
             expect(reply.status.code).toBe(404);
             expect(reply.entry).toBeUndefined();
-        }));
+        });
         describe('without a grant', () => {
             describe('records interface messages', () => {
-                it('returns a 401 if the tenant is not the author', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                it('returns a 401 if the tenant is not the author', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, bob);
                     // bob creates a record that alice will try and get
-                    const { message: recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: bob });
-                    const { status } = yield dwn.processMessage(bob.did, recordsWrite, { dataStream });
+                    const { message: recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: bob });
+                    const { status } = await dwn.processMessage(bob.did, recordsWrite, { dataStream });
                     expect(status.code).toBe(202);
                     // alice tries to read the message
-                    const { message } = yield TestDataGenerator.generateMessagesRead({
+                    const { message } = await TestDataGenerator.generateMessagesRead({
                         author: alice,
-                        messageCid: yield Message.getCid(recordsWrite)
+                        messageCid: await Message.getCid(recordsWrite)
                     });
-                    const reply = yield dwn.processMessage(bob.did, message);
+                    const reply = await dwn.processMessage(bob.did, message);
                     expect(reply.status.code).toBe(401);
                     expect(reply.status.detail).toContain(DwnErrorCode.MessagesReadAuthorizationFailed);
-                }));
+                });
                 describe('gets record data in the reply entry', () => {
-                    it('data is less than threshold', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const { message: recordsWrite, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({
+                    it('data is less than threshold', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                        const { message: recordsWrite, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded),
                         });
-                        const reply = yield dwn.processMessage(alice.did, recordsWrite, { dataStream });
+                        const reply = await dwn.processMessage(alice.did, recordsWrite, { dataStream });
                         expect(reply.status.code).toBe(202);
-                        const recordsWriteMessageCid = yield Message.getCid(recordsWrite);
-                        const { message } = yield TestDataGenerator.generateMessagesRead({
+                        const recordsWriteMessageCid = await Message.getCid(recordsWrite);
+                        const { message } = await TestDataGenerator.generateMessagesRead({
                             author: alice,
                             messageCid: recordsWriteMessageCid
                         });
-                        const messagesReadReply = yield dwn.processMessage(alice.did, message);
+                        const messagesReadReply = await dwn.processMessage(alice.did, message);
                         expect(messagesReadReply.status.code).toBe(200);
                         expect(messagesReadReply.entry).toBeDefined();
                         const messageReply = messagesReadReply.entry;
@@ -140,23 +133,24 @@ export function testMessagesReadHandler() {
                         expect(messageReply.messageCid).toBe(recordsWriteMessageCid);
                         expect(messageReply.message).toBeDefined();
                         expect(messageReply.data).toBeDefined();
-                        const messageData = yield DataStream.toBytes(messageReply.data);
+                        const messageData = await DataStream.toBytes(messageReply.data);
                         expect(messageData).toEqual(dataBytes);
-                    }));
-                    it('data is greater than threshold', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const { message: recordsWrite, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({
+                    });
+                    it('data is greater than threshold', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                        const { message: recordsWrite, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 10),
                         });
-                        const reply = yield dwn.processMessage(alice.did, recordsWrite, { dataStream });
+                        const reply = await dwn.processMessage(alice.did, recordsWrite, { dataStream });
                         expect(reply.status.code).toBe(202);
-                        const recordsWriteMessageCid = yield Message.getCid(recordsWrite);
-                        const { message } = yield TestDataGenerator.generateMessagesRead({
+                        const recordsWriteMessageCid = await Message.getCid(recordsWrite);
+                        const { message } = await TestDataGenerator.generateMessagesRead({
                             author: alice,
                             messageCid: recordsWriteMessageCid
                         });
-                        const messagesReadReply = yield dwn.processMessage(alice.did, message);
+                        const messagesReadReply = await dwn.processMessage(alice.did, message);
                         expect(messagesReadReply.status.code).toBe(200);
                         expect(messagesReadReply.entry).toBeDefined();
                         const messageReply = messagesReadReply.entry;
@@ -164,31 +158,32 @@ export function testMessagesReadHandler() {
                         expect(messageReply.messageCid).toBe(recordsWriteMessageCid);
                         expect(messageReply.message).toBeDefined();
                         expect(messageReply.data).toBeDefined();
-                        const messageData = yield DataStream.toBytes(messageReply.data);
+                        const messageData = await DataStream.toBytes(messageReply.data);
                         expect(messageData).toEqual(dataBytes);
-                    }));
-                    it('data is not available', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    });
+                    it('data is not available', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                         // initial write
-                        const { message: recordsWriteMessage, recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
+                        const { message: recordsWriteMessage, recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 10),
                         });
-                        const initialMessageCid = yield Message.getCid(recordsWriteMessage);
-                        let reply = yield dwn.processMessage(alice.did, recordsWriteMessage, { dataStream });
+                        const initialMessageCid = await Message.getCid(recordsWriteMessage);
+                        let reply = await dwn.processMessage(alice.did, recordsWriteMessage, { dataStream });
                         expect(reply.status.code).toBe(202);
-                        const { recordsWrite: updateMessage, dataStream: updateDataStream } = yield TestDataGenerator.generateFromRecordsWrite({
+                        const { recordsWrite: updateMessage, dataStream: updateDataStream } = await TestDataGenerator.generateFromRecordsWrite({
                             author: alice,
                             existingWrite: recordsWrite,
                             data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 10),
                         });
-                        reply = yield dwn.processMessage(alice.did, updateMessage.toJSON(), { dataStream: updateDataStream });
+                        reply = await dwn.processMessage(alice.did, updateMessage.toJSON(), { dataStream: updateDataStream });
                         expect(reply.status.code).toBe(202);
-                        const { message } = yield TestDataGenerator.generateMessagesRead({
+                        const { message } = await TestDataGenerator.generateMessagesRead({
                             author: alice,
                             messageCid: initialMessageCid
                         });
-                        const messagesReadReply = yield dwn.processMessage(alice.did, message);
+                        const messagesReadReply = await dwn.processMessage(alice.did, message);
                         expect(messagesReadReply.status.code).toBe(200);
                         expect(messagesReadReply.entry).toBeDefined();
                         const messageReply = messagesReadReply.entry;
@@ -196,96 +191,104 @@ export function testMessagesReadHandler() {
                         expect(messageReply.messageCid).toBe(initialMessageCid);
                         expect(messageReply.message).toBeDefined();
                         expect(messageReply.data).toBeUndefined();
-                    }));
+                    });
                 });
             });
             describe('Protocol interface messages', () => {
-                it('returns a 401 if the tenant is not the author', () => __awaiter(this, void 0, void 0, function* () {
+                it('returns a 401 if the tenant is not the author', async () => {
                     // scenario:  Alice configures both a published and non-published protocol and writes it to her DWN.
                     //            Bob is unable to read either of the ProtocolConfigure messages because he is not the author.
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     // unpublished protocol configuration
-                    const unpublishedProtocolDefinition = Object.assign(Object.assign({}, minimalProtocolDefinition), { protocol: 'http://example.com/protocol/unpublished', published: false });
-                    const { message: unpublishedProtocolsConfigure } = yield TestDataGenerator.generateProtocolsConfigure({
+                    const unpublishedProtocolDefinition = {
+                        ...minimalProtocolDefinition,
+                        protocol: 'http://example.com/protocol/unpublished',
+                        published: false
+                    };
+                    const { message: unpublishedProtocolsConfigure } = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: unpublishedProtocolDefinition
                     });
-                    const unpublishedProtocolsConfigureReply = yield dwn.processMessage(alice.did, unpublishedProtocolsConfigure);
+                    const unpublishedProtocolsConfigureReply = await dwn.processMessage(alice.did, unpublishedProtocolsConfigure);
                     expect(unpublishedProtocolsConfigureReply.status.code).toBe(202);
                     // published protocol configuration
-                    const publishedProtocolDefinition = Object.assign(Object.assign({}, minimalProtocolDefinition), { protocol: 'http://example.com/protocol/published', published: true });
-                    const { message: publishedProtocolsConfigure } = yield TestDataGenerator.generateProtocolsConfigure({
+                    const publishedProtocolDefinition = {
+                        ...minimalProtocolDefinition,
+                        protocol: 'http://example.com/protocol/published',
+                        published: true
+                    };
+                    const { message: publishedProtocolsConfigure } = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: publishedProtocolDefinition
                     });
-                    const publishedProtocolsConfigureReply = yield dwn.processMessage(alice.did, publishedProtocolsConfigure);
+                    const publishedProtocolsConfigureReply = await dwn.processMessage(alice.did, publishedProtocolsConfigure);
                     expect(publishedProtocolsConfigureReply.status.code).toBe(202);
                     // get the message CIDs
-                    const unpublishedProtocolMessageCid = yield Message.getCid(unpublishedProtocolsConfigure);
-                    const publishedProtocolMessageCid = yield Message.getCid(publishedProtocolsConfigure);
+                    const unpublishedProtocolMessageCid = await Message.getCid(unpublishedProtocolsConfigure);
+                    const publishedProtocolMessageCid = await Message.getCid(publishedProtocolsConfigure);
                     // bob attempts to read the unpublished protocol configuration
-                    const { message: getUnpublishedProtocolConfigure } = yield TestDataGenerator.generateMessagesRead({
+                    const { message: getUnpublishedProtocolConfigure } = await TestDataGenerator.generateMessagesRead({
                         author: bob,
                         messageCid: unpublishedProtocolMessageCid,
                     });
-                    const getUnpublishedProtocolConfigureReply = yield dwn.processMessage(alice.did, getUnpublishedProtocolConfigure);
+                    const getUnpublishedProtocolConfigureReply = await dwn.processMessage(alice.did, getUnpublishedProtocolConfigure);
                     expect(getUnpublishedProtocolConfigureReply.status.code).toBe(401);
                     expect(getUnpublishedProtocolConfigureReply.status.detail).toContain(DwnErrorCode.MessagesReadAuthorizationFailed);
                     expect(getUnpublishedProtocolConfigureReply.entry).toBeUndefined();
                     // bob attempts to read the published protocol configuration
-                    const { message: getPublishedProtocolConfigure } = yield TestDataGenerator.generateMessagesRead({
+                    const { message: getPublishedProtocolConfigure } = await TestDataGenerator.generateMessagesRead({
                         author: bob,
                         messageCid: publishedProtocolMessageCid,
                     });
-                    const getPublishedProtocolConfigureReply = yield dwn.processMessage(alice.did, getPublishedProtocolConfigure);
+                    const getPublishedProtocolConfigureReply = await dwn.processMessage(alice.did, getPublishedProtocolConfigure);
                     expect(getPublishedProtocolConfigureReply.status.code).toBe(401);
                     expect(getPublishedProtocolConfigureReply.status.detail).toContain(DwnErrorCode.MessagesReadAuthorizationFailed);
                     expect(getPublishedProtocolConfigureReply.entry).toBeUndefined();
                     // control: alice is able to read both the published and unpublished protocol configurations
-                    const { message: getUnpublishedProtocolConfigureAlice } = yield TestDataGenerator.generateMessagesRead({
+                    const { message: getUnpublishedProtocolConfigureAlice } = await TestDataGenerator.generateMessagesRead({
                         author: alice,
                         messageCid: unpublishedProtocolMessageCid,
                     });
-                    const getUnpublishedProtocolConfigureAliceReply = yield dwn.processMessage(alice.did, getUnpublishedProtocolConfigureAlice);
+                    const getUnpublishedProtocolConfigureAliceReply = await dwn.processMessage(alice.did, getUnpublishedProtocolConfigureAlice);
                     expect(getUnpublishedProtocolConfigureAliceReply.status.code).toBe(200);
                     expect(getUnpublishedProtocolConfigureAliceReply.entry).toBeDefined();
                     expect(getUnpublishedProtocolConfigureAliceReply.entry.messageCid).toBe(unpublishedProtocolMessageCid);
                     expect(getUnpublishedProtocolConfigureAliceReply.entry.message).toEqual(unpublishedProtocolsConfigure);
-                    const { message: getPublishedProtocolConfigureAlice } = yield TestDataGenerator.generateMessagesRead({
+                    const { message: getPublishedProtocolConfigureAlice } = await TestDataGenerator.generateMessagesRead({
                         author: alice,
                         messageCid: publishedProtocolMessageCid,
                     });
-                    const getPublishedProtocolConfigureAliceReply = yield dwn.processMessage(alice.did, getPublishedProtocolConfigureAlice);
+                    const getPublishedProtocolConfigureAliceReply = await dwn.processMessage(alice.did, getPublishedProtocolConfigureAlice);
                     expect(getPublishedProtocolConfigureAliceReply.status.code).toBe(200);
                     expect(getPublishedProtocolConfigureAliceReply.entry).toBeDefined();
                     expect(getPublishedProtocolConfigureAliceReply.entry.messageCid).toBe(publishedProtocolMessageCid);
                     expect(getPublishedProtocolConfigureAliceReply.entry.message).toEqual(publishedProtocolsConfigure);
-                }));
+                });
             });
         });
         describe('with a grant', () => {
-            it('returns a 401 if grant has different DWN interface scope', () => __awaiter(this, void 0, void 0, function* () {
+            it('returns a 401 if grant has different DWN interface scope', async () => {
                 // scenario: Alice grants Bob access to RecordsWrite, then Bob tries to invoke the grant with MessagesRead
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // alice installs a protocol
-                const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition: minimalProtocolDefinition
                 });
-                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 record which Bob will later try to read
-                const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
+                const { recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: minimalProtocolDefinition.protocol,
                     protocolPath: 'foo',
                 });
-                const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
+                const recordsWriteReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
                 expect(recordsWriteReply.status.code).toBe(202);
                 // Alice gives Bob a permission grant scoped to a RecordsWrite and the protocol
-                const permissionGrant = yield PermissionsProtocol.createGrant({
+                const permissionGrant = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 60 * 60 * 24 }), // 24 hours
@@ -296,32 +299,33 @@ export function testMessagesReadHandler() {
                     }
                 });
                 const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
-                const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
+                const permissionGrantWriteReply = await dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
                 expect(permissionGrantWriteReply.status.code).toBe(202);
                 // Bob tries to MessagesRead using the RecordsWrite grant
-                const messagesRead = yield TestDataGenerator.generateMessagesRead({
+                const messagesRead = await TestDataGenerator.generateMessagesRead({
                     author: bob,
-                    messageCid: yield Message.getCid(recordsWrite.message),
+                    messageCid: await Message.getCid(recordsWrite.message),
                     permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                 });
-                const messagesReadReply = yield dwn.processMessage(alice.did, messagesRead.message);
+                const messagesReadReply = await dwn.processMessage(alice.did, messagesRead.message);
                 expect(messagesReadReply.status.code).toBe(401);
                 expect(messagesReadReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationInterfaceMismatch);
-            }));
-            it('allows external parties to read a message using a grant with unrestricted scope', () => __awaiter(this, void 0, void 0, function* () {
+            });
+            it('allows external parties to read a message using a grant with unrestricted scope', async () => {
                 // scenario: Alice gives Bob a grant allowing him to read any message in her DWN.
                 //           Bob invokes that grant to read a message.
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // Alice writes a record to her DWN
-                const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({
+                const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                 });
-                const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
-                const messageCid = yield Message.getCid(message);
+                const messageCid = await Message.getCid(message);
                 // Alice issues a permission grant allowing Bob to read any record in her DWN
-                const permissionGrant = yield PermissionsProtocol.createGrant({
+                const permissionGrant = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 60 * 60 * 24 }), // 24 hours
@@ -331,21 +335,21 @@ export function testMessagesReadHandler() {
                     }
                 });
                 const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
-                const grantReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
+                const grantReply = await dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
                 expect(grantReply.status.code).toBe(202);
                 // Bob invokes that grant to read a record from Alice's DWN
-                const messagesRead = yield TestDataGenerator.generateMessagesRead({
+                const messagesRead = await TestDataGenerator.generateMessagesRead({
                     author: bob,
                     permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     messageCid,
                 });
-                const readReply = yield dwn.processMessage(alice.did, messagesRead.message);
+                const readReply = await dwn.processMessage(alice.did, messagesRead.message);
                 expect(readReply.status.code).toBe(200);
                 expect(readReply.entry).toBeDefined();
                 expect(readReply.entry.messageCid).toBe(messageCid);
-            }));
+            });
             describe('protocol scoped messages', () => {
-                it('allows reads of protocol messages with a protocol restricted grant scope', () => __awaiter(this, void 0, void 0, function* () {
+                it('allows reads of protocol messages with a protocol restricted grant scope', async () => {
                     // This test will verify that a grant scoped to a specific protocol will allow a user to read messages associated with that protocol.
                     // These messages include the ProtocolConfiguration itself, even if not published,
                     // any RecordsWrite or RecordsDelete messages associated with the protocol,
@@ -358,20 +362,20 @@ export function testMessagesReadHandler() {
                     //           Alice revokes the grant to Carol.
                     //           Bob invokes his grant to read the various messages.
                     //           As a control, Alice writes a record not associated with the protocol and Bob tries to unsuccessfully read it.
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
-                    const carol = yield TestDataGenerator.generateDidKeyPersona();
-                    const protocolDefinition = Object.assign(Object.assign({}, minimalProtocolDefinition), { published: false });
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
+                    const carol = await TestDataGenerator.generateDidKeyPersona();
+                    const protocolDefinition = { ...minimalProtocolDefinition, published: false };
                     // Alice installs the unpublished protocol
-                    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 protocolConfigureMessageCid = yield Message.getCid(protocolsConfig.message);
+                    const protocolConfigureMessageCid = await Message.getCid(protocolsConfig.message);
                     // Carol requests a grant to write records to the protocol
-                    const permissionRequestCarol = yield PermissionsProtocol.createRequest({
+                    const permissionRequestCarol = await PermissionsProtocol.createRequest({
                         signer: Jws.createSigner(alice),
                         delegated: false,
                         scope: {
@@ -381,10 +385,10 @@ export function testMessagesReadHandler() {
                         }
                     });
                     const requestDataStreamCarol = DataStream.fromBytes(permissionRequestCarol.permissionRequestBytes);
-                    const permissionRequestWriteReplyCarol = yield dwn.processMessage(alice.did, permissionRequestCarol.recordsWrite.message, { dataStream: requestDataStreamCarol });
+                    const permissionRequestWriteReplyCarol = await dwn.processMessage(alice.did, permissionRequestCarol.recordsWrite.message, { dataStream: requestDataStreamCarol });
                     expect(permissionRequestWriteReplyCarol.status.code).toBe(202);
                     // Alice gives Carol a grant to write records to the protocol
-                    const permissionGrantCarol = yield PermissionsProtocol.createGrant({
+                    const permissionGrantCarol = await PermissionsProtocol.createGrant({
                         signer: Jws.createSigner(alice),
                         grantedTo: carol.did,
                         dateExpires: Time.createOffsetTimestamp({ seconds: 60 * 60 * 24 }), // 24 hours
@@ -392,45 +396,45 @@ export function testMessagesReadHandler() {
                         scope: permissionRequestCarol.permissionRequestData.scope,
                     });
                     const grantDataStreamCarol = DataStream.fromBytes(permissionGrantCarol.permissionGrantBytes);
-                    const permissionGrantWriteReplyCarol = yield dwn.processMessage(alice.did, permissionGrantCarol.recordsWrite.message, { dataStream: grantDataStreamCarol });
+                    const permissionGrantWriteReplyCarol = await dwn.processMessage(alice.did, permissionGrantCarol.recordsWrite.message, { dataStream: grantDataStreamCarol });
                     expect(permissionGrantWriteReplyCarol.status.code).toBe(202);
-                    const carolGrantMessageCiD = yield Message.getCid(permissionGrantCarol.recordsWrite.message);
+                    const carolGrantMessageCiD = await Message.getCid(permissionGrantCarol.recordsWrite.message);
                     // Alice writes a record associated with the protocol
-                    const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
+                    const { recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'foo',
                     });
-                    const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
+                    const recordsWriteReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
                     expect(recordsWriteReply.status.code).toBe(202);
-                    const aliceRecordMessageCid = yield Message.getCid(recordsWrite.message);
+                    const aliceRecordMessageCid = await Message.getCid(recordsWrite.message);
                     // Alice deletes a record associated with the protocol
-                    const recordsDelete = yield TestDataGenerator.generateRecordsDelete({
+                    const recordsDelete = await TestDataGenerator.generateRecordsDelete({
                         author: alice,
                         recordId: recordsWrite.message.recordId,
                     });
-                    const recordsDeleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                    const recordsDeleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                     expect(recordsDeleteReply.status.code).toBe(202);
                     // Carol writes a record associated with the protocol
-                    const { recordsWrite: recordsWriteCarol, dataStream: dataStreamCarol } = yield TestDataGenerator.generateRecordsWrite({
+                    const { recordsWrite: recordsWriteCarol, dataStream: dataStreamCarol } = await TestDataGenerator.generateRecordsWrite({
                         author: carol,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'foo',
                         permissionGrantId: permissionGrantCarol.recordsWrite.message.recordId,
                     });
-                    const recordsWriteReplyCarol = yield dwn.processMessage(alice.did, recordsWriteCarol.message, { dataStream: dataStreamCarol });
+                    const recordsWriteReplyCarol = await dwn.processMessage(alice.did, recordsWriteCarol.message, { dataStream: dataStreamCarol });
                     expect(recordsWriteReplyCarol.status.code).toBe(202);
-                    const carolRecordMessageCid = yield Message.getCid(recordsWriteCarol.message);
+                    const carolRecordMessageCid = await Message.getCid(recordsWriteCarol.message);
                     // Alice revokes Carol's grant
-                    const permissionRevocationCarol = yield PermissionsProtocol.createRevocation({
+                    const permissionRevocationCarol = await PermissionsProtocol.createRevocation({
                         signer: Jws.createSigner(alice),
-                        grant: yield PermissionGrant.parse(permissionGrantCarol.dataEncodedMessage),
+                        grant: PermissionGrant.parse(permissionGrantCarol.dataEncodedMessage),
                     });
                     const permissionRevocationCarolDataStream = DataStream.fromBytes(permissionRevocationCarol.permissionRevocationBytes);
-                    const permissionRevocationCarolReply = yield dwn.processMessage(alice.did, permissionRevocationCarol.recordsWrite.message, { dataStream: permissionRevocationCarolDataStream });
+                    const permissionRevocationCarolReply = await dwn.processMessage(alice.did, permissionRevocationCarol.recordsWrite.message, { dataStream: permissionRevocationCarolDataStream });
                     expect(permissionRevocationCarolReply.status.code).toBe(202);
                     // Alice gives Bob a permission grant with scope MessagesRead
-                    const permissionGrant = yield PermissionsProtocol.createGrant({
+                    const permissionGrant = await PermissionsProtocol.createGrant({
                         signer: Jws.createSigner(alice),
                         grantedTo: bob.did,
                         dateExpires: Time.createOffsetTimestamp({ seconds: 60 * 60 * 24 }), // 24 hours
@@ -441,14 +445,14 @@ export function testMessagesReadHandler() {
                         }
                     });
                     const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
-                    const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
+                    const permissionGrantWriteReply = await dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
                     expect(permissionGrantWriteReply.status.code).toBe(202);
                     // Bob is unable to read the message without using the permission grant
-                    const messagesReadWithoutGrant = yield TestDataGenerator.generateMessagesRead({
+                    const messagesReadWithoutGrant = await TestDataGenerator.generateMessagesRead({
                         author: bob,
                         messageCid: aliceRecordMessageCid,
                     });
-                    const messagesReadWithoutGrantReply = yield dwn.processMessage(alice.did, messagesReadWithoutGrant.message);
+                    const messagesReadWithoutGrantReply = await dwn.processMessage(alice.did, messagesReadWithoutGrant.message);
                     expect(messagesReadWithoutGrantReply.status.code).toBe(401);
                     expect(messagesReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.MessagesReadAuthorizationFailed);
                     // Bob is able to read all the associated messages when using the permission grant
@@ -461,113 +465,114 @@ export function testMessagesReadHandler() {
                     // - Carol's RecordsWrite
                     // - Alice's Revocation of Carol's Grant
                     // Protocol configuration
-                    const messagesReadProtocolConfigure = yield TestDataGenerator.generateMessagesRead({
+                    const messagesReadProtocolConfigure = await TestDataGenerator.generateMessagesRead({
                         author: bob,
                         messageCid: protocolConfigureMessageCid,
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
-                    const messagesReadProtocolConfigureReply = yield dwn.processMessage(alice.did, messagesReadProtocolConfigure.message);
+                    const messagesReadProtocolConfigureReply = await dwn.processMessage(alice.did, messagesReadProtocolConfigure.message);
                     expect(messagesReadProtocolConfigureReply.status.code).toBe(200);
                     expect(messagesReadProtocolConfigureReply.entry).toBeDefined();
                     expect(messagesReadProtocolConfigureReply.entry.message).toEqual(protocolsConfig.message);
                     // alice RecordsWrite
-                    const messagesReadWithGrant = yield TestDataGenerator.generateMessagesRead({
+                    const messagesReadWithGrant = await TestDataGenerator.generateMessagesRead({
                         author: bob,
                         messageCid: aliceRecordMessageCid,
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
-                    const messagesReadWithGrantReply = yield dwn.processMessage(alice.did, messagesReadWithGrant.message);
+                    const messagesReadWithGrantReply = await dwn.processMessage(alice.did, messagesReadWithGrant.message);
                     expect(messagesReadWithGrantReply.status.code).toBe(200);
                     expect(messagesReadWithGrantReply.entry).toBeDefined();
                     expect(messagesReadWithGrantReply.entry.message).toEqual(recordsWrite.message);
                     // alice RecordsDelete
-                    const messagesReadDelete = yield TestDataGenerator.generateMessagesRead({
+                    const messagesReadDelete = await TestDataGenerator.generateMessagesRead({
                         author: bob,
-                        messageCid: yield Message.getCid(recordsDelete.message),
+                        messageCid: await Message.getCid(recordsDelete.message),
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
-                    const messagesReadDeleteReply = yield dwn.processMessage(alice.did, messagesReadDelete.message);
+                    const messagesReadDeleteReply = await dwn.processMessage(alice.did, messagesReadDelete.message);
                     expect(messagesReadDeleteReply.status.code).toBe(200);
                     expect(messagesReadDeleteReply.entry).toBeDefined();
                     expect(messagesReadDeleteReply.entry.message).toEqual(recordsDelete.message);
                     // carol's Permission Request
-                    const messagesReadCarolRequest = yield TestDataGenerator.generateMessagesRead({
+                    const messagesReadCarolRequest = await TestDataGenerator.generateMessagesRead({
                         author: bob,
-                        messageCid: yield Message.getCid(permissionRequestCarol.recordsWrite.message),
+                        messageCid: await Message.getCid(permissionRequestCarol.recordsWrite.message),
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
-                    const messagesReadCarolRequestReply = yield dwn.processMessage(alice.did, messagesReadCarolRequest.message);
+                    const messagesReadCarolRequestReply = await dwn.processMessage(alice.did, messagesReadCarolRequest.message);
                     expect(messagesReadCarolRequestReply.status.code).toBe(200);
                     expect(messagesReadCarolRequestReply.entry).toBeDefined();
                     expect(messagesReadCarolRequestReply.entry.message).toEqual(permissionRequestCarol.recordsWrite.message);
                     // carol's Permission Grant
-                    const messagesReadCarolGrant = yield TestDataGenerator.generateMessagesRead({
+                    const messagesReadCarolGrant = await TestDataGenerator.generateMessagesRead({
                         author: bob,
                         messageCid: carolGrantMessageCiD,
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
-                    const messagesReadCarolGrantReply = yield dwn.processMessage(alice.did, messagesReadCarolGrant.message);
+                    const messagesReadCarolGrantReply = await dwn.processMessage(alice.did, messagesReadCarolGrant.message);
                     expect(messagesReadCarolGrantReply.status.code).toBe(200);
                     expect(messagesReadCarolGrantReply.entry).toBeDefined();
                     expect(messagesReadCarolGrantReply.entry.message).toEqual(permissionGrantCarol.recordsWrite.message);
                     // carol's RecordsWrite
-                    const messagesReadCarolRecord = yield TestDataGenerator.generateMessagesRead({
+                    const messagesReadCarolRecord = await TestDataGenerator.generateMessagesRead({
                         author: bob,
                         messageCid: carolRecordMessageCid,
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
-                    const messagesReadCarolRecordReply = yield dwn.processMessage(alice.did, messagesReadCarolRecord.message);
+                    const messagesReadCarolRecordReply = await dwn.processMessage(alice.did, messagesReadCarolRecord.message);
                     expect(messagesReadCarolRecordReply.status.code).toBe(200);
                     expect(messagesReadCarolRecordReply.entry).toBeDefined();
                     expect(messagesReadCarolRecordReply.entry.message).toEqual(recordsWriteCarol.message);
                     // carol's Grant Revocation
-                    const messagesReadCarolGrantRevocation = yield TestDataGenerator.generateMessagesRead({
+                    const messagesReadCarolGrantRevocation = await TestDataGenerator.generateMessagesRead({
                         author: bob,
-                        messageCid: yield Message.getCid(permissionRevocationCarol.recordsWrite.message),
+                        messageCid: await Message.getCid(permissionRevocationCarol.recordsWrite.message),
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
-                    const messagesReadCarolGrantRevocationReply = yield dwn.processMessage(alice.did, messagesReadCarolGrantRevocation.message);
+                    const messagesReadCarolGrantRevocationReply = await dwn.processMessage(alice.did, messagesReadCarolGrantRevocation.message);
                     expect(messagesReadCarolGrantRevocationReply.status.code).toBe(200);
                     expect(messagesReadCarolGrantRevocationReply.entry).toBeDefined();
                     expect(messagesReadCarolGrantRevocationReply.entry.message).toEqual(permissionRevocationCarol.recordsWrite.message);
                     // CONTROL: Alice writes a record not associated with the protocol
-                    const { recordsWrite: recordsWriteControl, dataStream: dataStreamControl } = yield TestDataGenerator.generateRecordsWrite({
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                    const { recordsWrite: recordsWriteControl, dataStream: dataStreamControl } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                     });
-                    const recordsWriteControlReply = yield dwn.processMessage(alice.did, recordsWriteControl.message, { dataStream: dataStreamControl });
+                    const recordsWriteControlReply = await dwn.processMessage(alice.did, recordsWriteControl.message, { dataStream: dataStreamControl });
                     expect(recordsWriteControlReply.status.code).toBe(202);
                     // Bob is unable to read the control message
-                    const messagesReadControl = yield TestDataGenerator.generateMessagesRead({
+                    const messagesReadControl = await TestDataGenerator.generateMessagesRead({
                         author: bob,
-                        messageCid: yield Message.getCid(recordsWriteControl.message),
+                        messageCid: await Message.getCid(recordsWriteControl.message),
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
-                    const messagesReadControlReply = yield dwn.processMessage(alice.did, messagesReadControl.message);
+                    const messagesReadControlReply = await dwn.processMessage(alice.did, messagesReadControl.message);
                     expect(messagesReadControlReply.status.code).toBe(401);
-                }));
-                it('rejects message read of protocol messages with mismatching protocol grant scopes', () => __awaiter(this, void 0, void 0, function* () {
+                });
+                it('rejects message read of protocol messages with mismatching protocol grant scopes', async () => {
                     // scenario: Alice writes a protocol record. Alice gives Bob a grant to read messages from a different protocol
                     //           Bob invokes that grant to read the protocol message, but fails.
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     const protocolDefinition = minimalProtocolDefinition;
                     // Alice installs the protocol
-                    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 record which Bob will later try to read
-                    const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
+                    const { recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'foo',
                     });
-                    const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
+                    const recordsWriteReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
                     expect(recordsWriteReply.status.code).toBe(202);
                     // Alice gives Bob a permission grant with scope MessagesRead
-                    const permissionGrant = yield PermissionsProtocol.createGrant({
+                    const permissionGrant = await PermissionsProtocol.createGrant({
                         signer: Jws.createSigner(alice),
                         grantedTo: bob.did,
                         dateExpires: Time.createOffsetTimestamp({ seconds: 60 * 60 * 24 }), // 24 hours
@@ -578,32 +583,32 @@ export function testMessagesReadHandler() {
                         }
                     });
                     const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
-                    const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
+                    const permissionGrantWriteReply = await dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
                     expect(permissionGrantWriteReply.status.code).toBe(202);
                     // Bob is unable to read the record using the mismatched permission grant
-                    const messagesReadWithoutGrant = yield TestDataGenerator.generateMessagesRead({
+                    const messagesReadWithoutGrant = await TestDataGenerator.generateMessagesRead({
                         author: bob,
-                        messageCid: yield Message.getCid(recordsWrite.message),
+                        messageCid: await Message.getCid(recordsWrite.message),
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
-                    const messagesReadWithoutGrantReply = yield dwn.processMessage(alice.did, messagesReadWithoutGrant.message);
+                    const messagesReadWithoutGrantReply = await dwn.processMessage(alice.did, messagesReadWithoutGrant.message);
                     expect(messagesReadWithoutGrantReply.status.code).toBe(401);
                     expect(messagesReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.MessagesReadVerifyScopeFailed);
-                }));
-                it('rejects message if the RecordsWrite message is not found for a RecordsDelete being retrieved', () => __awaiter(this, void 0, void 0, function* () {
+                });
+                it('rejects message if the RecordsWrite message is not found for a RecordsDelete being retrieved', async () => {
                     // NOTE: This is a corner case that is unlikely to happen in practice, but is tested for completeness
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     const protocolDefinition = minimalProtocolDefinition;
                     // Alice installs the protocol
-                    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 gives bob a grant to read messages in the protocol
-                    const permissionGrant = yield PermissionsProtocol.createGrant({
+                    const permissionGrant = await PermissionsProtocol.createGrant({
                         signer: Jws.createSigner(alice),
                         grantedTo: bob.did,
                         dateExpires: Time.createOffsetTimestamp({ seconds: 60 * 60 * 24 }), // 24 hours
@@ -614,32 +619,32 @@ export function testMessagesReadHandler() {
                         }
                     });
                     const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
-                    const permissionGrantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
+                    const permissionGrantWriteReply = await dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
                     expect(permissionGrantWriteReply.status.code).toBe(202);
                     // Alice creates the records write and records delete messages
-                    const { recordsWrite } = yield TestDataGenerator.generateRecordsWrite({
+                    const { recordsWrite } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'foo',
                     });
-                    const { recordsDelete } = yield TestDataGenerator.generateRecordsDelete({
+                    const { recordsDelete } = await TestDataGenerator.generateRecordsDelete({
                         author: alice,
                         recordId: recordsWrite.message.recordId,
                     });
                     // Alice inserts the RecordsDelete message directly into the message store
-                    const recordsDeleteCid = yield Message.getCid(recordsDelete.message);
+                    const recordsDeleteCid = await Message.getCid(recordsDelete.message);
                     const indexes = recordsDelete.constructIndexes(recordsWrite.message);
-                    yield messageStore.put(alice.did, recordsDelete.message, indexes);
+                    await messageStore.put(alice.did, recordsDelete.message, indexes);
                     // Bob tries to read the message
-                    const messagesRead = yield TestDataGenerator.generateMessagesRead({
+                    const messagesRead = await TestDataGenerator.generateMessagesRead({
                         author: bob,
                         messageCid: recordsDeleteCid,
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
-                    const messagesReadReply = yield dwn.processMessage(alice.did, messagesRead.message);
+                    const messagesReadReply = await dwn.processMessage(alice.did, messagesRead.message);
                     expect(messagesReadReply.status.code).toBe(401);
                     expect(messagesReadReply.status.detail).toContain(DwnErrorCode.RecordsWriteGetNewestWriteRecordNotFound);
-                }));
+                });
             });
         });
     });