@enbox/dwn-sdk-js 0.0.5 → 0.0.7

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

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import chatProtocolDefinition from '../vectors/protocol-definitions/chat.json' with { type: 'json' };
 import emailProtocolDefinition from '../vectors/protocol-definitions/email.json' with { type: 'json' };
 import friendRoleProtocolDefinition from '../vectors/protocol-definitions/friend-role.json' with { type: 'json' };
@@ -46,7 +37,7 @@ export function testRecordsReadHandler() {
         describe('functional tests', () => {
             // 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;
@@ -54,152 +45,150 @@ export function testRecordsReadHandler() {
                 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* () {
+                dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
+            });
+            beforeEach(async () => {
                 // clean up before each test rather than after so that a test does not depend on other tests to do the clean up
-                yield messageStore.clear();
-                yield dataStore.clear();
-                yield resumableTaskStore.clear();
-                yield stateIndex.clear();
-            }));
-            afterAll(() => __awaiter(this, void 0, void 0, function* () {
-                yield dwn.close();
-            }));
-            it('should allow tenant to RecordsRead their own record', () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                await messageStore.clear();
+                await dataStore.clear();
+                await resumableTaskStore.clear();
+                await stateIndex.clear();
+            });
+            afterAll(async () => {
+                await dwn.close();
+            });
+            it('should allow tenant to RecordsRead their own record', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // insert data
-                const { message, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // testing RecordsRead
-                const recordsRead = yield RecordsRead.create({
+                const recordsRead = await RecordsRead.create({
                     filter: {
                         recordId: message.recordId,
                     },
                     signer: Jws.createSigner(alice)
                 });
-                const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                 expect(readReply.status.code).toBe(200);
                 expect(readReply.entry.recordsWrite).toBeDefined();
-                expect((_a = readReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.authorization).toEqual(message.authorization);
-                expect((_b = readReply.entry.recordsWrite) === null || _b === void 0 ? void 0 : _b.descriptor).toEqual(message.descriptor);
-                const dataFetched = yield DataStream.toBytes(readReply.entry.data);
+                expect(readReply.entry.recordsWrite?.authorization).toEqual(message.authorization);
+                expect(readReply.entry.recordsWrite?.descriptor).toEqual(message.descriptor);
+                const dataFetched = await DataStream.toBytes(readReply.entry.data);
                 expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).toBe(true);
-            }));
-            it('should not allow non-tenant to RecordsRead a record', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should not allow non-tenant to RecordsRead a record', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // insert data
-                const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // testing RecordsRead
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                const recordsRead = yield RecordsRead.create({
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const recordsRead = await RecordsRead.create({
                     filter: {
                         recordId: message.recordId,
                     },
                     signer: Jws.createSigner(bob)
                 });
-                const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                 expect(readReply.status.code).toBe(401);
-            }));
-            it('should allow reading of data that is published without `authorization`', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should allow reading of data that is published without `authorization`', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // insert public data
-                const { message, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({ author: alice, published: true });
-                const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({ author: alice, published: true });
+                const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // testing public RecordsRead
-                const recordsRead = yield RecordsRead.create({
+                const recordsRead = await RecordsRead.create({
                     filter: {
                         recordId: message.recordId
                     }
                 });
                 expect(recordsRead.author).toBeUndefined(); // making sure no author/authorization is created
-                const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                 expect(readReply.status.code).toBe(200);
-                const dataFetched = yield DataStream.toBytes(readReply.entry.data);
+                const dataFetched = await DataStream.toBytes(readReply.entry.data);
                 expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).toBe(true);
-            }));
-            it('should allow an authenticated user to RecordRead data that is published', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should allow an authenticated user to RecordRead data that is published', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // insert public data
-                const { message, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({ author: alice, published: true });
-                const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({ author: alice, published: true });
+                const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // testing public RecordsRead
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                const recordsRead = yield RecordsRead.create({
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const recordsRead = await RecordsRead.create({
                     filter: {
                         recordId: message.recordId,
                     },
                     signer: Jws.createSigner(bob)
                 });
-                const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                 expect(readReply.status.code).toBe(200);
-                const dataFetched = yield DataStream.toBytes(readReply.entry.data);
+                const dataFetched = await DataStream.toBytes(readReply.entry.data);
                 expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).toBe(true);
-            }));
-            it('should allow a non-tenant to read RecordsRead data they have received', () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should allow a non-tenant to read RecordsRead data they have received', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // Alice inserts data with Bob as recipient
-                const { message, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({
+                const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: bob.did,
                 });
-                const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // Bob reads the data that Alice sent him
-                const recordsRead = yield RecordsRead.create({
+                const recordsRead = await RecordsRead.create({
                     filter: {
                         recordId: message.recordId,
                     },
                     signer: Jws.createSigner(bob)
                 });
-                const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                 expect(readReply.status.code).toBe(200);
                 expect(readReply.entry.recordsWrite).toBeDefined();
-                expect((_a = readReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.descriptor).toBeDefined();
-                const dataFetched = yield DataStream.toBytes(readReply.entry.data);
+                expect(readReply.entry.recordsWrite?.descriptor).toBeDefined();
+                const dataFetched = await DataStream.toBytes(readReply.entry.data);
                 expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).toBe(true);
-            }));
-            it('should return 400 when fetching initial write for a deleted record fails', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should return 400 when fetching initial write for a deleted record fails', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // Write a record
-                const { message: writeMessage, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                const writeReply = yield dwn.processMessage(alice.did, writeMessage, { dataStream });
+                const { message: writeMessage, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                const writeReply = await dwn.processMessage(alice.did, writeMessage, { dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // Delete the record
-                const recordsDelete = yield RecordsDelete.create({
+                const recordsDelete = await RecordsDelete.create({
                     signer: Jws.createSigner(alice),
                     recordId: writeMessage.recordId
                 });
-                const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                const deleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                 expect(deleteReply.status.code).toBe(202);
                 // Stub the messageStore.query method to simulate failure in fetching initial write
                 const queryStub = sinon.stub(dwn['messageStore'], 'query');
                 queryStub.onFirstCall().resolves({ messages: [recordsDelete.message] });
                 queryStub.onSecondCall().resolves({ messages: [] }); // Simulate no initial write found
                 // Attempt to read the deleted record
-                const recordsRead = yield RecordsRead.create({
+                const recordsRead = await RecordsRead.create({
                     filter: { recordId: writeMessage.recordId },
                     signer: Jws.createSigner(alice)
                 });
-                const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                 // Verify the response
                 expect(readReply.status.code).toBe(400);
                 expect(readReply.status.detail).toContain(DwnErrorCode.RecordsReadInitialWriteNotFound);
                 // Restore the original messageStore.query method
                 queryStub.restore();
-            }));
-            it('should return 401 when a non-author attempts to read the initial write of a deleted record', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                const carol = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should return 401 when a non-author attempts to read the initial write of a deleted record', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const carol = await TestDataGenerator.generateDidKeyPersona();
                 // Alice installs a protocol that allows anyone to write
                 const protocolDefinition = {
                     published: true,
@@ -216,42 +205,41 @@ export function testRecordsReadHandler() {
                         }
                     }
                 };
-                const configureProtocol = yield TestDataGenerator.generateProtocolsConfigure({
+                const configureProtocol = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition: protocolDefinition,
                 });
-                const configureProtocolReply = yield dwn.processMessage(alice.did, configureProtocol.message);
+                const configureProtocolReply = await dwn.processMessage(alice.did, configureProtocol.message);
                 expect(configureProtocolReply.status.code).toBe(202);
                 // Bob writes a record to Alice's DWN
-                const { message: writeMessage, dataStream } = yield TestDataGenerator.generateRecordsWrite({
+                const { message: writeMessage, dataStream } = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     protocol: protocolDefinition.protocol,
                     protocolPath: 'foo'
                 });
-                const writeReply = yield dwn.processMessage(alice.did, writeMessage, { dataStream });
+                const writeReply = await dwn.processMessage(alice.did, writeMessage, { dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // Bob deletes the record
-                const recordsDelete = yield RecordsDelete.create({
+                const recordsDelete = await RecordsDelete.create({
                     signer: Jws.createSigner(bob),
                     recordId: writeMessage.recordId
                 });
-                const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                const deleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                 expect(deleteReply.status.code).toBe(202);
                 // Carol attempts to read the deleted record
-                const recordsRead = yield RecordsRead.create({
+                const recordsRead = await RecordsRead.create({
                     filter: { recordId: writeMessage.recordId },
                     signer: Jws.createSigner(carol)
                 });
-                const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                 // Verify the response
                 expect(readReply.status.code).toBe(401);
                 expect(readReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
-            }));
-            it('should allow a non-tenant to read RecordsRead data they have authored', () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                const carol = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should allow a non-tenant to read RecordsRead data they have authored', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const carol = await TestDataGenerator.generateDidKeyPersona();
                 // Alice installs a protocol that allows anyone to write foo record
                 const protocolDefinition = {
                     published: true,
@@ -268,76 +256,75 @@ export function testRecordsReadHandler() {
                         }
                     }
                 };
-                const configureProtocol = yield TestDataGenerator.generateProtocolsConfigure({
+                const configureProtocol = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition: protocolDefinition,
                 });
-                const configureProtocolReply = yield dwn.processMessage(alice.did, configureProtocol.message);
+                const configureProtocolReply = await dwn.processMessage(alice.did, configureProtocol.message);
                 expect(configureProtocolReply.status.code).toBe(202);
                 // Bob writes a foo record to Alice's DWN
-                const { message, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({
+                const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     protocol: protocolDefinition.protocol,
                     protocolPath: 'foo',
                 });
-                const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // Bob reads the record he sent to Alice from Alice's DWN
-                const recordsRead = yield RecordsRead.create({
+                const recordsRead = await RecordsRead.create({
                     filter: {
                         recordId: message.recordId,
                     },
                     signer: Jws.createSigner(bob)
                 });
-                const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                 expect(readReply.status.code).toBe(200);
                 expect(readReply.entry.recordsWrite).toBeDefined();
-                expect((_a = readReply.entry.recordsWrite) === null || _a === void 0 ? void 0 : _a.descriptor).toBeDefined();
-                const dataFetched = yield DataStream.toBytes(readReply.entry.data);
+                expect(readReply.entry.recordsWrite?.descriptor).toBeDefined();
+                const dataFetched = await DataStream.toBytes(readReply.entry.data);
                 expect(ArrayUtility.byteArraysEqual(dataFetched, dataBytes)).toBe(true);
                 // carol attempts to read Bob's record
-                const carolRecordsRead = yield RecordsRead.create({
+                const carolRecordsRead = await RecordsRead.create({
                     filter: {
                         recordId: message.recordId,
                     },
                     signer: Jws.createSigner(carol)
                 });
-                const carolReadReply = yield dwn.processMessage(alice.did, carolRecordsRead.message);
+                const carolReadReply = await dwn.processMessage(alice.did, carolRecordsRead.message);
                 expect(carolReadReply.status.code).toBe(401);
-            }));
-            it('should include `initialWrite` property if RecordsWrite is not initial write', () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const write = yield TestDataGenerator.generateRecordsWrite({ author: alice, published: false });
-                const writeReply = yield dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
+            });
+            it('should include `initialWrite` property if RecordsWrite is not initial write', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const write = await TestDataGenerator.generateRecordsWrite({ author: alice, published: false });
+                const writeReply = await dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // write an update to the record
-                const write2 = yield RecordsWrite.createFrom({ recordsWriteMessage: write.message, published: true, signer: Jws.createSigner(alice) });
-                const write2Reply = yield dwn.processMessage(alice.did, write2.message);
+                const write2 = await RecordsWrite.createFrom({ recordsWriteMessage: write.message, published: true, signer: Jws.createSigner(alice) });
+                const write2Reply = await dwn.processMessage(alice.did, write2.message);
                 expect(write2Reply.status.code).toBe(202);
                 // make sure result returned now has `initialWrite` property
-                const messageData = yield RecordsRead.create({ filter: { recordId: write.message.recordId }, signer: Jws.createSigner(alice) });
-                const reply = yield dwn.processMessage(alice.did, messageData.message);
+                const messageData = await RecordsRead.create({ filter: { recordId: write.message.recordId }, signer: Jws.createSigner(alice) });
+                const reply = await dwn.processMessage(alice.did, messageData.message);
                 expect(reply.status.code).toBe(200);
                 expect(reply.entry.initialWrite).toBeDefined();
-                expect((_a = reply.entry.initialWrite) === null || _a === void 0 ? void 0 : _a.recordId).toBe(write.message.recordId);
-            }));
+                expect(reply.entry.initialWrite?.recordId).toBe(write.message.recordId);
+            });
             describe('protocol based reads', () => {
-                it('should allow read with allow-anyone rule', () => __awaiter(this, void 0, void 0, function* () {
+                it('should allow read with allow-anyone rule', async () => {
                     // scenario: Alice writes an image to her DWN, then Bob reads the image because he is "anyone".
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     const protocolDefinition = socialMediaProtocolDefinition;
                     // Install social-media protocol on Alice's DWN
-                    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 image to her DWN
                     const encodedImage = new TextEncoder().encode('cafe-aesthetic.jpg');
-                    const imageRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                    const imageRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'image', // this comes from `types` in protocol definition
@@ -346,32 +333,32 @@ export function testRecordsReadHandler() {
                         data: encodedImage,
                         recipient: alice.did
                     });
-                    const imageReply = yield dwn.processMessage(alice.did, imageRecordsWrite.message, { dataStream: imageRecordsWrite.dataStream });
+                    const imageReply = await dwn.processMessage(alice.did, imageRecordsWrite.message, { dataStream: imageRecordsWrite.dataStream });
                     expect(imageReply.status.code).toBe(202);
                     // Bob (anyone) reads the image that Alice wrote
-                    const imageRecordsRead = yield RecordsRead.create({
+                    const imageRecordsRead = await RecordsRead.create({
                         filter: {
                             recordId: imageRecordsWrite.message.recordId,
                         },
                         signer: Jws.createSigner(bob)
                     });
-                    const imageReadReply = yield dwn.processMessage(alice.did, imageRecordsRead.message);
+                    const imageReadReply = await dwn.processMessage(alice.did, imageRecordsRead.message);
                     expect(imageReadReply.status.code).toBe(200);
-                }));
-                it('should not allow anonymous reads when there is no allow-anyone rule', () => __awaiter(this, void 0, void 0, function* () {
+                });
+                it('should not allow anonymous reads when there is no allow-anyone rule', async () => {
                     // scenario: Alice's writes a record to a protocol. An anonymous read his Alice's DWN and is rejected
                     //           because there is not an allow-anyone rule.
-                    const alice = yield TestDataGenerator.generatePersona();
+                    const alice = await TestDataGenerator.generatePersona();
                     const protocolDefinition = emailProtocolDefinition;
                     TestStubGenerator.stubDidResolver(didResolver, [alice]);
-                    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 message to the minimal protocol
-                    const recordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                    const recordsWrite = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'email',
@@ -379,36 +366,36 @@ export function testRecordsReadHandler() {
                         dataFormat: protocolDefinition.types.email.dataFormats[0],
                         data: new TextEncoder().encode('foo')
                     });
-                    const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
+                    const recordsWriteReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
                     expect(recordsWriteReply.status.code).toBe(202);
                     // Anonymous tries and fails to read Alice's message
-                    const recordsRead = yield RecordsRead.create({
+                    const recordsRead = await RecordsRead.create({
                         filter: {
                             recordId: recordsWrite.message.recordId,
                         }
                     });
-                    const recordsReadReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                    const recordsReadReply = await dwn.processMessage(alice.did, recordsRead.message);
                     expect(recordsReadReply.status.code).toBe(401);
                     expect(recordsReadReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
-                }));
+                });
                 describe('recipient rules', () => {
-                    it('should allow read with ancestor recipient rule', () => __awaiter(this, void 0, void 0, function* () {
+                    it('should allow read with ancestor recipient rule', async () => {
                         // scenario: Alice sends an email to Bob, then Bob reads the email.
                         //           ImposterBob tries and fails to read the email.
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const bob = yield TestDataGenerator.generateDidKeyPersona();
-                        const imposterBob = yield TestDataGenerator.generateDidKeyPersona();
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
+                        const imposterBob = await TestDataGenerator.generateDidKeyPersona();
                         const protocolDefinition = emailProtocolDefinition;
                         // Install email protocol on Alice's DWN
-                        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 an email with Bob as recipient
                         const encodedEmail = new TextEncoder().encode('Dear Bob, hello!');
-                        const emailRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                        const emailRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'email', // this comes from `types` in protocol definition
@@ -417,47 +404,47 @@ export function testRecordsReadHandler() {
                             data: encodedEmail,
                             recipient: bob.did
                         });
-                        const imageReply = yield dwn.processMessage(alice.did, emailRecordsWrite.message, { dataStream: emailRecordsWrite.dataStream });
+                        const imageReply = await dwn.processMessage(alice.did, emailRecordsWrite.message, { dataStream: emailRecordsWrite.dataStream });
                         expect(imageReply.status.code).toBe(202);
                         // Bob reads Alice's email
-                        const bobRecordsRead = yield RecordsRead.create({
+                        const bobRecordsRead = await RecordsRead.create({
                             filter: {
                                 recordId: emailRecordsWrite.message.recordId,
                             },
                             signer: Jws.createSigner(bob)
                         });
-                        const bobReadReply = yield dwn.processMessage(alice.did, bobRecordsRead.message);
+                        const bobReadReply = await dwn.processMessage(alice.did, bobRecordsRead.message);
                         expect(bobReadReply.status.code).toBe(200);
                         // ImposterBob is not able to read Alice's email
-                        const imposterRecordsRead = yield RecordsRead.create({
+                        const imposterRecordsRead = await RecordsRead.create({
                             filter: {
                                 recordId: emailRecordsWrite.message.recordId,
                             },
                             signer: Jws.createSigner(imposterBob)
                         });
-                        const imposterReadReply = yield dwn.processMessage(alice.did, imposterRecordsRead.message);
+                        const imposterReadReply = await dwn.processMessage(alice.did, imposterRecordsRead.message);
                         expect(imposterReadReply.status.code).toBe(401);
                         expect(imposterReadReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
-                    }));
+                    });
                 });
                 describe('author action rules', () => {
-                    it('should allow read with ancestor author rule', () => __awaiter(this, void 0, void 0, function* () {
+                    it('should allow read with ancestor author rule', async () => {
                         // scenario: Bob sends an email to Alice, then Bob reads the email.
                         //           ImposterBob tries and fails to read the email.
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const bob = yield TestDataGenerator.generateDidKeyPersona();
-                        const imposterBob = yield TestDataGenerator.generateDidKeyPersona();
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
+                        const imposterBob = await TestDataGenerator.generateDidKeyPersona();
                         const protocolDefinition = emailProtocolDefinition;
                         // Install email protocol on Alice's DWN
-                        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 an email with Bob as recipient
                         const encodedEmail = new TextEncoder().encode('Dear Alice, hello!');
-                        const emailRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                        const emailRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                             author: bob,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'email', // this comes from `types` in protocol definition
@@ -466,40 +453,40 @@ export function testRecordsReadHandler() {
                             data: encodedEmail,
                             recipient: alice.did
                         });
-                        const imageReply = yield dwn.processMessage(alice.did, emailRecordsWrite.message, { dataStream: emailRecordsWrite.dataStream });
+                        const imageReply = await dwn.processMessage(alice.did, emailRecordsWrite.message, { dataStream: emailRecordsWrite.dataStream });
                         expect(imageReply.status.code).toBe(202);
                         // Bob reads the email he just sent
-                        const bobRecordsRead = yield RecordsRead.create({
+                        const bobRecordsRead = await RecordsRead.create({
                             filter: {
                                 recordId: emailRecordsWrite.message.recordId,
                             },
                             signer: Jws.createSigner(bob)
                         });
-                        const bobReadReply = yield dwn.processMessage(alice.did, bobRecordsRead.message);
+                        const bobReadReply = await dwn.processMessage(alice.did, bobRecordsRead.message);
                         expect(bobReadReply.status.code).toBe(200);
                         // ImposterBob is not able to read the email
-                        const imposterRecordsRead = yield RecordsRead.create({
+                        const imposterRecordsRead = await RecordsRead.create({
                             filter: {
                                 recordId: emailRecordsWrite.message.recordId,
                             },
                             signer: Jws.createSigner(imposterBob)
                         });
-                        const imposterReadReply = yield dwn.processMessage(alice.did, imposterRecordsRead.message);
+                        const imposterReadReply = await dwn.processMessage(alice.did, imposterRecordsRead.message);
                         expect(imposterReadReply.status.code).toBe(401);
                         expect(imposterReadReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
-                    }));
+                    });
                 });
                 describe('filter based reads', () => {
-                    it('should return a filter based read if there is only a single result', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const protocolDefinition = Object.assign({}, nestedProtocol);
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    it('should return a filter based read if there is only a single result', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const protocolDefinition = { ...nestedProtocol };
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
-                        const protocolConfigReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolConfigReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolConfigReply.status.code).toBe(202);
-                        const foo1Write = yield TestDataGenerator.generateRecordsWrite({
+                        const foo1Write = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'foo',
@@ -508,29 +495,29 @@ export function testRecordsReadHandler() {
                             data: new TextEncoder().encode('foo'),
                             recipient: alice.did
                         });
-                        const foo1WriteReply = yield dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
+                        const foo1WriteReply = await dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
                         expect(foo1WriteReply.status.code).toBe(202);
-                        const fooPathRead = yield RecordsRead.create({
+                        const fooPathRead = await RecordsRead.create({
                             filter: {
                                 protocol: protocolDefinition.protocol,
                                 protocolPath: 'foo',
                             },
                             signer: Jws.createSigner(alice),
                         });
-                        const fooPathReply = yield dwn.processMessage(alice.did, fooPathRead.message);
+                        const fooPathReply = await dwn.processMessage(alice.did, fooPathRead.message);
                         expect(fooPathReply.status.code).toBe(200);
                         expect(fooPathReply.entry.recordsWrite.recordId).toBe(foo1Write.message.recordId);
-                    }));
-                    it('should return the most recently updated record when filter matches multiple results', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const protocolDefinition = Object.assign({}, nestedProtocol);
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    });
+                    it('should return the most recently updated record when filter matches multiple results', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const protocolDefinition = { ...nestedProtocol };
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
-                        const protocolConfigReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolConfigReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolConfigReply.status.code).toBe(202);
-                        const foo1Write = yield TestDataGenerator.generateRecordsWrite({
+                        const foo1Write = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'foo',
@@ -539,10 +526,10 @@ export function testRecordsReadHandler() {
                             data: new TextEncoder().encode('foo1'),
                             recipient: alice.did
                         });
-                        const foo1WriteReply = yield dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
+                        const foo1WriteReply = await dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
                         expect(foo1WriteReply.status.code).toBe(202);
-                        yield Time.minimalSleep();
-                        const foo2Write = yield TestDataGenerator.generateRecordsWrite({
+                        await Time.minimalSleep();
+                        const foo2Write = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'foo',
@@ -551,30 +538,30 @@ export function testRecordsReadHandler() {
                             data: new TextEncoder().encode('foo2'),
                             recipient: alice.did
                         });
-                        const foo2WriteReply = yield dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
+                        const foo2WriteReply = await dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
                         expect(foo2WriteReply.status.code).toBe(202);
                         // default sort is updatedDescending, so the most recently updated record should be returned
-                        const fooPathRead = yield RecordsRead.create({
+                        const fooPathRead = await RecordsRead.create({
                             filter: {
                                 protocol: protocolDefinition.protocol,
                                 protocolPath: 'foo',
                             },
                             signer: Jws.createSigner(alice),
                         });
-                        const fooPathReply = yield dwn.processMessage(alice.did, fooPathRead.message);
+                        const fooPathReply = await dwn.processMessage(alice.did, fooPathRead.message);
                         expect(fooPathReply.status.code).toBe(200);
                         expect(fooPathReply.entry.recordsWrite.recordId).toBe(foo2Write.message.recordId);
-                    }));
-                    it('should return the oldest record when `dateSort` is `CreatedAscending` and filter matches multiple results', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const protocolDefinition = Object.assign({}, nestedProtocol);
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    });
+                    it('should return the oldest record when `dateSort` is `CreatedAscending` and filter matches multiple results', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const protocolDefinition = { ...nestedProtocol };
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
-                        const protocolConfigReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolConfigReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolConfigReply.status.code).toBe(202);
-                        const foo1Write = yield TestDataGenerator.generateRecordsWrite({
+                        const foo1Write = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'foo',
@@ -583,10 +570,10 @@ export function testRecordsReadHandler() {
                             data: new TextEncoder().encode('foo1'),
                             recipient: alice.did
                         });
-                        const foo1WriteReply = yield dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
+                        const foo1WriteReply = await dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
                         expect(foo1WriteReply.status.code).toBe(202);
-                        yield Time.minimalSleep();
-                        const foo2Write = yield TestDataGenerator.generateRecordsWrite({
+                        await Time.minimalSleep();
+                        const foo2Write = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'foo',
@@ -595,10 +582,10 @@ export function testRecordsReadHandler() {
                             data: new TextEncoder().encode('foo2'),
                             recipient: alice.did
                         });
-                        const foo2WriteReply = yield dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
+                        const foo2WriteReply = await dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
                         expect(foo2WriteReply.status.code).toBe(202);
                         // with createdAscending sort, the oldest record should be returned
-                        const fooPathRead = yield RecordsRead.create({
+                        const fooPathRead = await RecordsRead.create({
                             filter: {
                                 protocol: protocolDefinition.protocol,
                                 protocolPath: 'foo',
@@ -606,20 +593,20 @@ export function testRecordsReadHandler() {
                             dateSort: DateSort.CreatedAscending,
                             signer: Jws.createSigner(alice),
                         });
-                        const fooPathReply = yield dwn.processMessage(alice.did, fooPathRead.message);
+                        const fooPathReply = await dwn.processMessage(alice.did, fooPathRead.message);
                         expect(fooPathReply.status.code).toBe(200);
                         expect(fooPathReply.entry.recordsWrite.recordId).toBe(foo1Write.message.recordId);
-                    }));
-                    it('should return the newest record when `dateSort` is `CreatedDescending` and filter matches multiple results', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const protocolDefinition = Object.assign({}, nestedProtocol);
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    });
+                    it('should return the newest record when `dateSort` is `CreatedDescending` and filter matches multiple results', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const protocolDefinition = { ...nestedProtocol };
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
-                        const protocolConfigReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolConfigReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolConfigReply.status.code).toBe(202);
-                        const foo1Write = yield TestDataGenerator.generateRecordsWrite({
+                        const foo1Write = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'foo',
@@ -628,10 +615,10 @@ export function testRecordsReadHandler() {
                             data: new TextEncoder().encode('foo1'),
                             recipient: alice.did
                         });
-                        const foo1WriteReply = yield dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
+                        const foo1WriteReply = await dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
                         expect(foo1WriteReply.status.code).toBe(202);
-                        yield Time.minimalSleep();
-                        const foo2Write = yield TestDataGenerator.generateRecordsWrite({
+                        await Time.minimalSleep();
+                        const foo2Write = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'foo',
@@ -640,9 +627,9 @@ export function testRecordsReadHandler() {
                             data: new TextEncoder().encode('foo2'),
                             recipient: alice.did
                         });
-                        const foo2WriteReply = yield dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
+                        const foo2WriteReply = await dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
                         expect(foo2WriteReply.status.code).toBe(202);
-                        const fooPathRead = yield RecordsRead.create({
+                        const fooPathRead = await RecordsRead.create({
                             filter: {
                                 protocol: protocolDefinition.protocol,
                                 protocolPath: 'foo',
@@ -650,20 +637,20 @@ export function testRecordsReadHandler() {
                             dateSort: DateSort.CreatedDescending,
                             signer: Jws.createSigner(alice),
                         });
-                        const fooPathReply = yield dwn.processMessage(alice.did, fooPathRead.message);
+                        const fooPathReply = await dwn.processMessage(alice.did, fooPathRead.message);
                         expect(fooPathReply.status.code).toBe(200);
                         expect(fooPathReply.entry.recordsWrite.recordId).toBe(foo2Write.message.recordId);
-                    }));
-                    it('should return the oldest updated record when `dateSort` is `UpdatedAscending`', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const protocolDefinition = Object.assign({}, nestedProtocol);
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    });
+                    it('should return the oldest updated record when `dateSort` is `UpdatedAscending`', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const protocolDefinition = { ...nestedProtocol };
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
-                        const protocolConfigReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolConfigReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolConfigReply.status.code).toBe(202);
-                        const foo1Write = yield TestDataGenerator.generateRecordsWrite({
+                        const foo1Write = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'foo',
@@ -672,10 +659,10 @@ export function testRecordsReadHandler() {
                             data: new TextEncoder().encode('foo1'),
                             recipient: alice.did
                         });
-                        const foo1WriteReply = yield dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
+                        const foo1WriteReply = await dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
                         expect(foo1WriteReply.status.code).toBe(202);
-                        yield Time.minimalSleep();
-                        const foo2Write = yield TestDataGenerator.generateRecordsWrite({
+                        await Time.minimalSleep();
+                        const foo2Write = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'foo',
@@ -684,9 +671,9 @@ export function testRecordsReadHandler() {
                             data: new TextEncoder().encode('foo2'),
                             recipient: alice.did
                         });
-                        const foo2WriteReply = yield dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
+                        const foo2WriteReply = await dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
                         expect(foo2WriteReply.status.code).toBe(202);
-                        const fooPathRead = yield RecordsRead.create({
+                        const fooPathRead = await RecordsRead.create({
                             filter: {
                                 protocol: protocolDefinition.protocol,
                                 protocolPath: 'foo',
@@ -694,20 +681,20 @@ export function testRecordsReadHandler() {
                             dateSort: DateSort.UpdatedAscending,
                             signer: Jws.createSigner(alice),
                         });
-                        const fooPathReply = yield dwn.processMessage(alice.did, fooPathRead.message);
+                        const fooPathReply = await dwn.processMessage(alice.did, fooPathRead.message);
                         expect(fooPathReply.status.code).toBe(200);
                         expect(fooPathReply.entry.recordsWrite.recordId).toBe(foo1Write.message.recordId);
-                    }));
-                    it('should return the most recently updated record when `dateSort` is `UpdatedDescending`', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const protocolDefinition = Object.assign({}, nestedProtocol);
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    });
+                    it('should return the most recently updated record when `dateSort` is `UpdatedDescending`', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const protocolDefinition = { ...nestedProtocol };
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
-                        const protocolConfigReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolConfigReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolConfigReply.status.code).toBe(202);
-                        const foo1Write = yield TestDataGenerator.generateRecordsWrite({
+                        const foo1Write = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'foo',
@@ -716,10 +703,10 @@ export function testRecordsReadHandler() {
                             data: new TextEncoder().encode('foo1'),
                             recipient: alice.did
                         });
-                        const foo1WriteReply = yield dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
+                        const foo1WriteReply = await dwn.processMessage(alice.did, foo1Write.message, { dataStream: foo1Write.dataStream });
                         expect(foo1WriteReply.status.code).toBe(202);
-                        yield Time.minimalSleep();
-                        const foo2Write = yield TestDataGenerator.generateRecordsWrite({
+                        await Time.minimalSleep();
+                        const foo2Write = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'foo',
@@ -728,9 +715,9 @@ export function testRecordsReadHandler() {
                             data: new TextEncoder().encode('foo2'),
                             recipient: alice.did
                         });
-                        const foo2WriteReply = yield dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
+                        const foo2WriteReply = await dwn.processMessage(alice.did, foo2Write.message, { dataStream: foo2Write.dataStream });
                         expect(foo2WriteReply.status.code).toBe(202);
-                        const fooPathRead = yield RecordsRead.create({
+                        const fooPathRead = await RecordsRead.create({
                             filter: {
                                 protocol: protocolDefinition.protocol,
                                 protocolPath: 'foo',
@@ -738,219 +725,219 @@ export function testRecordsReadHandler() {
                             dateSort: DateSort.UpdatedDescending,
                             signer: Jws.createSigner(alice),
                         });
-                        const fooPathReply = yield dwn.processMessage(alice.did, fooPathRead.message);
+                        const fooPathReply = await dwn.processMessage(alice.did, fooPathRead.message);
                         expect(fooPathReply.status.code).toBe(200);
                         expect(fooPathReply.entry.recordsWrite.recordId).toBe(foo2Write.message.recordId);
-                    }));
-                    it('should return the earliest published record when `dateSort` is `PublishedAscending`', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    });
+                    it('should return the earliest published record when `dateSort` is `PublishedAscending`', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
                         const schema = 'aSchema';
-                        const write1 = yield TestDataGenerator.generateRecordsWrite({
+                        const write1 = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             schema,
                             published: true,
                         });
-                        const write1Reply = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                        const write1Reply = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
                         expect(write1Reply.status.code).toBe(202);
-                        yield Time.minimalSleep();
-                        const write2 = yield TestDataGenerator.generateRecordsWrite({
+                        await Time.minimalSleep();
+                        const write2 = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             schema,
                             published: true,
                         });
-                        const write2Reply = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                        const write2Reply = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
                         expect(write2Reply.status.code).toBe(202);
-                        const read = yield RecordsRead.create({
+                        const read = await RecordsRead.create({
                             filter: { schema },
                             dateSort: DateSort.PublishedAscending,
                             signer: Jws.createSigner(alice),
                         });
-                        const readReply = yield dwn.processMessage(alice.did, read.message);
+                        const readReply = await dwn.processMessage(alice.did, read.message);
                         expect(readReply.status.code).toBe(200);
                         expect(readReply.entry.recordsWrite.recordId).toBe(write1.message.recordId);
-                    }));
-                    it('should return the latest published record when `dateSort` is `PublishedDescending`', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    });
+                    it('should return the latest published record when `dateSort` is `PublishedDescending`', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
                         const schema = 'aSchema';
-                        const write1 = yield TestDataGenerator.generateRecordsWrite({
+                        const write1 = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             schema,
                             published: true,
                         });
-                        const write1Reply = yield dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
+                        const write1Reply = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
                         expect(write1Reply.status.code).toBe(202);
-                        yield Time.minimalSleep();
-                        const write2 = yield TestDataGenerator.generateRecordsWrite({
+                        await Time.minimalSleep();
+                        const write2 = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             schema,
                             published: true,
                         });
-                        const write2Reply = yield dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
+                        const write2Reply = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
                         expect(write2Reply.status.code).toBe(202);
-                        const read = yield RecordsRead.create({
+                        const read = await RecordsRead.create({
                             filter: { schema },
                             dateSort: DateSort.PublishedDescending,
                             signer: Jws.createSigner(alice),
                         });
-                        const readReply = yield dwn.processMessage(alice.did, read.message);
+                        const readReply = await dwn.processMessage(alice.did, read.message);
                         expect(readReply.status.code).toBe(200);
                         expect(readReply.entry.recordsWrite.recordId).toBe(write2.message.recordId);
-                    }));
+                    });
                 });
                 describe('protocolRole based reads', () => {
-                    it('uses a root-level role to authorize a read', () => __awaiter(this, void 0, void 0, function* () {
+                    it('uses a root-level role to authorize a read', async () => {
                         // scenario: Alice writes a chat message writes a chat message. Bob invokes his
                         //           friend role in order to read the chat message.
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const bob = yield TestDataGenerator.generateDidKeyPersona();
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
                         const protocolDefinition = friendRoleProtocolDefinition;
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice writes a 'friend' root-level role record with Bob as recipient
-                        const friendRoleRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const friendRoleRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: bob.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'friend',
                             data: new TextEncoder().encode('Bob is my friend'),
                         });
-                        const friendRoleReply = yield dwn.processMessage(alice.did, friendRoleRecord.message, { dataStream: friendRoleRecord.dataStream });
+                        const friendRoleReply = await dwn.processMessage(alice.did, friendRoleRecord.message, { dataStream: friendRoleRecord.dataStream });
                         expect(friendRoleReply.status.code).toBe(202);
                         // Alice writes a 'chat' record
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: alice.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'chat',
                             data: new TextEncoder().encode('Bob can read this cuz he is my friend'),
                         });
-                        const chatReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+                        const chatReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         expect(chatReply.status.code).toBe(202);
                         // Bob reads Alice's chat record
-                        const readChatRecord = yield RecordsRead.create({
+                        const readChatRecord = await RecordsRead.create({
                             signer: Jws.createSigner(bob),
                             filter: {
                                 recordId: chatRecord.message.recordId,
                             },
                             protocolRole: 'friend'
                         });
-                        const chatReadReply = yield dwn.processMessage(alice.did, readChatRecord.message);
+                        const chatReadReply = await dwn.processMessage(alice.did, readChatRecord.message);
                         expect(chatReadReply.status.code).toBe(200);
-                    }));
-                    it('rejects root-level role authorized reads if the protocolRole is not a valid protocol path to an active role record', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    it('rejects root-level role authorized reads if the protocolRole is not a valid protocol path to an active role record', async () => {
                         // scenario: Alice writes a chat message writes a chat message. Bob tries to invoke the 'chat' role,
                         //           but 'chat' is not a role.
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const bob = yield TestDataGenerator.generateDidKeyPersona();
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
                         const protocolDefinition = friendRoleProtocolDefinition;
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice writes a 'chat' record
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: alice.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'chat',
                             data: new TextEncoder().encode('Blah blah blah'),
                         });
-                        const chatReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+                        const chatReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         expect(chatReply.status.code).toBe(202);
                         // Bob tries to invoke a 'chat' role but 'chat' is not a role
-                        const readChatRecord = yield RecordsRead.create({
+                        const readChatRecord = await RecordsRead.create({
                             signer: Jws.createSigner(bob),
                             filter: {
                                 recordId: chatRecord.message.recordId,
                             },
                             protocolRole: 'chat'
                         });
-                        const chatReadReply = yield dwn.processMessage(alice.did, readChatRecord.message);
+                        const chatReadReply = await dwn.processMessage(alice.did, readChatRecord.message);
                         expect(chatReadReply.status.code).toBe(401);
                         expect(chatReadReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationNotARole);
-                    }));
-                    it('rejects root-level role authorized reads if there is no active role for the recipient', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    it('rejects root-level role authorized reads if there is no active role for the recipient', async () => {
                         // scenario: Alice writes a chat message writes a chat message. Bob tries to invoke a role,
                         //           but he has not been given one.
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const bob = yield TestDataGenerator.generateDidKeyPersona();
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
                         const protocolDefinition = friendRoleProtocolDefinition;
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice writes a 'chat' record
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: alice.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'chat',
                             data: new TextEncoder().encode('Blah blah blah'),
                         });
-                        const chatReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+                        const chatReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         expect(chatReply.status.code).toBe(202);
                         // Bob tries to invoke a 'friend' role but he is not a 'friend'
-                        const readChatRecord = yield RecordsRead.create({
+                        const readChatRecord = await RecordsRead.create({
                             signer: Jws.createSigner(bob),
                             filter: {
                                 recordId: chatRecord.message.recordId,
                             },
                             protocolRole: 'friend',
                         });
-                        const chatReadReply = yield dwn.processMessage(alice.did, readChatRecord.message);
+                        const chatReadReply = await dwn.processMessage(alice.did, readChatRecord.message);
                         expect(chatReadReply.status.code).toBe(401);
                         expect(chatReadReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
-                    }));
-                    it('can authorize a read using a context role', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    it('can authorize a read using a context role', async () => {
                         // scenario: Alice creates a thread and adds Bob to the 'thread/participant' role. Alice writes a chat message.
                         //           Bob invokes the record to read in the chat message.
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const bob = yield TestDataGenerator.generateDidKeyPersona();
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
                         const protocolDefinition = threadRoleProtocolDefinition;
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates a thread
-                        const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const threadRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'thread'
                         });
-                        const threadRecordReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+                        const threadRecordReply = await dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
                         expect(threadRecordReply.status.code).toBe(202);
                         // Alice adds Bob as a 'thread/participant' in that thread
-                        const participantRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const participantRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: bob.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'thread/participant',
                             parentContextId: threadRecord.message.contextId,
                         });
-                        const participantRecordReply = yield dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
+                        const participantRecordReply = await dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
                         expect(participantRecordReply.status.code).toBe(202);
                         // Alice writes a chat message in the thread
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'thread/chat',
                             parentContextId: threadRecord.message.contextId,
                         });
-                        const chatRecordReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+                        const chatRecordReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         expect(chatRecordReply.status.code).toBe(202);
                         // Bob is able to read his own 'participant' role
                         // He doesn't need to invoke the role because recipients of a record are always authorized to read it
-                        const participantRead = yield RecordsRead.create({
+                        const participantRead = await RecordsRead.create({
                             signer: Jws.createSigner(bob),
                             filter: {
                                 protocolPath: 'thread/participant',
@@ -958,105 +945,105 @@ export function testRecordsReadHandler() {
                                 contextId: threadRecord.message.contextId
                             },
                         });
-                        const participantReadReply = yield dwn.processMessage(alice.did, participantRead.message);
+                        const participantReadReply = await dwn.processMessage(alice.did, participantRead.message);
                         expect(participantReadReply.status.code).toBe(200);
                         // Bob is able to read the thread root record
-                        const threadRead = yield RecordsRead.create({
+                        const threadRead = await RecordsRead.create({
                             signer: Jws.createSigner(bob),
                             filter: {
                                 recordId: participantReadReply.entry.recordsWrite.descriptor.parentId,
                             },
                             protocolRole: 'thread/participant'
                         });
-                        const threadReadReply = yield dwn.processMessage(alice.did, threadRead.message);
+                        const threadReadReply = await dwn.processMessage(alice.did, threadRead.message);
                         expect(threadReadReply.status.code).toBe(200);
                         // Bob invokes his 'participant' role to read the chat message
-                        const chatRead = yield RecordsRead.create({
+                        const chatRead = await RecordsRead.create({
                             signer: Jws.createSigner(bob),
                             filter: {
                                 recordId: chatRecord.message.recordId,
                             },
                             protocolRole: 'thread/participant'
                         });
-                        const chatReadReply = yield dwn.processMessage(alice.did, chatRead.message);
+                        const chatReadReply = await dwn.processMessage(alice.did, chatRead.message);
                         expect(chatReadReply.status.code).toBe(200);
-                    }));
-                    it('should not allow context role to be invoked against a wrong context', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    it('should not allow context role to be invoked against a wrong context', async () => {
                         // scenario: Alice creates a thread and adds Bob as a participant. Alice creates another thread. Bob tries and fails to invoke his
                         //           context role to write a chat in the second thread
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const bob = yield TestDataGenerator.generateDidKeyPersona();
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
                         const protocolDefinition = threadRoleProtocolDefinition;
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates a thread
-                        const threadRecord1 = yield TestDataGenerator.generateRecordsWrite({
+                        const threadRecord1 = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: bob.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'thread'
                         });
-                        const threadRecordReply1 = yield dwn.processMessage(alice.did, threadRecord1.message, { dataStream: threadRecord1.dataStream });
+                        const threadRecordReply1 = await dwn.processMessage(alice.did, threadRecord1.message, { dataStream: threadRecord1.dataStream });
                         expect(threadRecordReply1.status.code).toBe(202);
                         // Alice adds Bob as a 'thread/participant' in that thread
-                        const participantRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const participantRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: bob.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'thread/participant',
                             parentContextId: threadRecord1.message.contextId,
                         });
-                        const participantRecordReply = yield dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
+                        const participantRecordReply = await dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
                         expect(participantRecordReply.status.code).toBe(202);
                         // Alice creates a second thread
-                        const threadRecord2 = yield TestDataGenerator.generateRecordsWrite({
+                        const threadRecord2 = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: bob.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'thread'
                         });
-                        const threadRecordReply2 = yield dwn.processMessage(alice.did, threadRecord2.message, { dataStream: threadRecord2.dataStream });
+                        const threadRecordReply2 = await dwn.processMessage(alice.did, threadRecord2.message, { dataStream: threadRecord2.dataStream });
                         expect(threadRecordReply2.status.code).toBe(202);
                         // Alice writes a chat message in the thread
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'thread/chat',
                             parentContextId: threadRecord2.message.contextId,
                         });
-                        const chatRecordReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+                        const chatRecordReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         expect(chatRecordReply.status.code).toBe(202);
                         // Bob invokes his 'participant' role to read the chat message
-                        const chatRead = yield RecordsRead.create({
+                        const chatRead = await RecordsRead.create({
                             signer: Jws.createSigner(bob),
                             filter: {
                                 recordId: chatRecord.message.recordId,
                             },
                             protocolRole: 'thread/participant'
                         });
-                        const chatReadReply = yield dwn.processMessage(alice.did, chatRead.message);
+                        const chatReadReply = await dwn.processMessage(alice.did, chatRead.message);
                         expect(chatReadReply.status.code).toBe(401);
                         expect(chatReadReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
-                    }));
+                    });
                 });
             });
             describe('grant based reads', () => {
-                it('rejects with 401 an external party attempts to RecordReads if grant has different DWN method scope', () => __awaiter(this, void 0, void 0, function* () {
+                it('rejects with 401 an external party attempts to RecordReads if grant has different DWN method scope', async () => {
                     // scenario: Alice grants Bob access to RecordsWrite, then Bob tries to invoke the grant with RecordsRead
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     // 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,
                     });
-                    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 RecordsRead
-                    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
@@ -1067,44 +1054,44 @@ export function testRecordsReadHandler() {
                         }
                     });
                     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 RecordsRead
-                    const recordsRead = yield RecordsRead.create({
+                    const recordsRead = await RecordsRead.create({
                         filter: {
                             recordId: recordsWrite.message.recordId,
                         },
                         signer: Jws.createSigner(bob),
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
-                    const recordsReadReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                    const recordsReadReply = await dwn.processMessage(alice.did, recordsRead.message);
                     expect(recordsReadReply.status.code).toBe(401);
                     expect(recordsReadReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationMethodMismatch);
-                }));
+                });
                 describe('protocol records', () => {
-                    it('allows reads of protocol records with unrestricted grant scopes', () => __awaiter(this, void 0, void 0, function* () {
+                    it('allows reads of protocol records with unrestricted grant scopes', async () => {
                         // scenario: Alice writes a protocol record. Alice gives Bob a grant to read all records in her DWN
                         //           Bob invokes that grant to read the protocol record.
-                        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 RecordsRead
-                        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
@@ -1115,52 +1102,52 @@ export function testRecordsReadHandler() {
                             }
                         });
                         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 without using the permission grant
-                        const recordsReadWithoutGrant = yield RecordsRead.create({
+                        const recordsReadWithoutGrant = await RecordsRead.create({
                             filter: {
                                 recordId: recordsWrite.message.recordId,
                             },
                             signer: Jws.createSigner(bob),
                         });
-                        const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
+                        const recordsReadWithoutGrantReply = await dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
                         expect(recordsReadWithoutGrantReply.status.code).toBe(401);
                         expect(recordsReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionRulesNotFound);
                         // Bob is able to read the record when he uses the permission grant
-                        const recordsReadWithGrant = yield RecordsRead.create({
+                        const recordsReadWithGrant = await RecordsRead.create({
                             filter: {
                                 recordId: recordsWrite.message.recordId,
                             },
                             signer: Jws.createSigner(bob),
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
-                        const recordsReadWithGrantReply = yield dwn.processMessage(alice.did, recordsReadWithGrant.message);
+                        const recordsReadWithGrantReply = await dwn.processMessage(alice.did, recordsReadWithGrant.message);
                         expect(recordsReadWithGrantReply.status.code).toBe(200);
-                    }));
-                    it('allows reads of protocol records with matching protocol grant scopes', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    it('allows reads of protocol records with matching protocol grant scopes', async () => {
                         // scenario: Alice writes a protocol record. Alice gives Bob a grant to read all records in the protocol
                         //           Bob invokes that grant to read the protocol record.
-                        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 RecordsRead
-                        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
@@ -1171,52 +1158,52 @@ export function testRecordsReadHandler() {
                             }
                         });
                         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 without using the permission grant
-                        const recordsReadWithoutGrant = yield RecordsRead.create({
+                        const recordsReadWithoutGrant = await RecordsRead.create({
                             filter: {
                                 recordId: recordsWrite.message.recordId,
                             },
                             signer: Jws.createSigner(bob),
                         });
-                        const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
+                        const recordsReadWithoutGrantReply = await dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
                         expect(recordsReadWithoutGrantReply.status.code).toBe(401);
                         expect(recordsReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionRulesNotFound);
                         // Bob is able to read the record when he uses the permission grant
-                        const recordsReadWithGrant = yield RecordsRead.create({
+                        const recordsReadWithGrant = await RecordsRead.create({
                             filter: {
                                 recordId: recordsWrite.message.recordId,
                             },
                             signer: Jws.createSigner(bob),
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
-                        const recordsReadWithGrantReply = yield dwn.processMessage(alice.did, recordsReadWithGrant.message);
+                        const recordsReadWithGrantReply = await dwn.processMessage(alice.did, recordsReadWithGrant.message);
                         expect(recordsReadWithGrantReply.status.code).toBe(200);
-                    }));
-                    it('rejects reads of protocol records with mismatching protocol grant scopes', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    it('rejects reads of protocol records with mismatching protocol grant scopes', async () => {
                         // scenario: Alice writes a protocol record. Alice gives Bob a grant to read a different protocol
                         //           Bob invokes that grant to read the protocol record, 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 RecordsRead
-                        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
@@ -1227,43 +1214,43 @@ export function testRecordsReadHandler() {
                             }
                         });
                         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 recordsReadWithoutGrant = yield RecordsRead.create({
+                        const recordsReadWithoutGrant = await RecordsRead.create({
                             filter: {
                                 recordId: recordsWrite.message.recordId,
                             },
                             signer: Jws.createSigner(bob),
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
-                        const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
+                        const recordsReadWithoutGrantReply = await dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
                         expect(recordsReadWithoutGrantReply.status.code).toBe(401);
                         expect(recordsReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolMismatch);
-                    }));
-                    it('allows reads of records in the contextId specified in the grant', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    it('allows reads of records in the contextId specified in the grant', async () => {
                         // scenario: Alice grants Bob access to RecordsRead records with a specific contextId.
                         //           Bob uses it to read a record in that context.
-                        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 RecordsRead
-                        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
@@ -1275,42 +1262,42 @@ export function testRecordsReadHandler() {
                             }
                         });
                         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 recordsReadWithoutGrant = yield RecordsRead.create({
+                        const recordsReadWithoutGrant = await RecordsRead.create({
                             filter: {
                                 recordId: recordsWrite.message.recordId,
                             },
                             signer: Jws.createSigner(bob),
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
-                        const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
+                        const recordsReadWithoutGrantReply = await dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
                         expect(recordsReadWithoutGrantReply.status.code).toBe(200);
-                    }));
-                    it('rejects reads of records in a different contextId than is specified in the grant', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    it('rejects reads of records in a different contextId than is specified in the grant', async () => {
                         // scenario: Alice grants Bob access to RecordsRead records with a specific contextId.
                         //           Bob tries and fails to invoke the grant in order to read a record outside of the context.
-                        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 RecordsRead
-                        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
@@ -1318,47 +1305,47 @@ export function testRecordsReadHandler() {
                                 interface: DwnInterfaceName.Records,
                                 method: DwnMethodName.Read,
                                 protocol: protocolDefinition.protocol,
-                                contextId: yield TestDataGenerator.randomCborSha256Cid(), // different contextId than what Bob will try to read
+                                contextId: await TestDataGenerator.randomCborSha256Cid(), // different contextId than what Bob will try to read
                             }
                         });
                         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 recordsReadWithoutGrant = yield RecordsRead.create({
+                        const recordsReadWithoutGrant = await RecordsRead.create({
                             filter: {
                                 recordId: recordsWrite.message.recordId,
                             },
                             signer: Jws.createSigner(bob),
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
-                        const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
+                        const recordsReadWithoutGrantReply = await dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
                         expect(recordsReadWithoutGrantReply.status.code).toBe(401);
                         expect(recordsReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeContextIdMismatch);
-                    }));
-                    it('allows reads of records in the protocolPath specified in the grant', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    it('allows reads of records in the protocolPath specified in the grant', async () => {
                         // scenario: Alice grants Bob access to RecordsRead records with a specific protocolPath.
                         //           Bob uses it to read a record in that protocolPath.
-                        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 RecordsRead
-                        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
@@ -1370,42 +1357,42 @@ export function testRecordsReadHandler() {
                             }
                         });
                         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 recordsReadWithoutGrant = yield RecordsRead.create({
+                        const recordsReadWithoutGrant = await RecordsRead.create({
                             filter: {
                                 recordId: recordsWrite.message.recordId,
                             },
                             signer: Jws.createSigner(bob),
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
-                        const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
+                        const recordsReadWithoutGrantReply = await dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
                         expect(recordsReadWithoutGrantReply.status.code).toBe(200);
-                    }));
-                    it('rejects reads of records in a different protocolPath than is specified in the grant', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    it('rejects reads of records in a different protocolPath than is specified in the grant', async () => {
                         // scenario: Alice grants Bob access to RecordsRead records with a specific protocolPath.
                         //           Bob tries and fails to invoke the grant in order to read a record outside of the protocolPath.
-                        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 RecordsRead
-                        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
@@ -1417,145 +1404,144 @@ export function testRecordsReadHandler() {
                             }
                         });
                         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 recordsReadWithoutGrant = yield RecordsRead.create({
+                        const recordsReadWithoutGrant = await RecordsRead.create({
                             filter: {
                                 recordId: recordsWrite.message.recordId,
                             },
                             signer: Jws.createSigner(bob),
                             permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                         });
-                        const recordsReadWithoutGrantReply = yield dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
+                        const recordsReadWithoutGrantReply = await dwn.processMessage(alice.did, recordsReadWithoutGrant.message);
                         expect(recordsReadWithoutGrantReply.status.code).toBe(401);
                         expect(recordsReadWithoutGrantReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolPathMismatch);
-                    }));
+                    });
                 });
             });
-            it('should return 404 RecordRead if data does not exist', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const recordsRead = yield RecordsRead.create({
+            it('should return 404 RecordRead if data does not exist', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const recordsRead = await RecordsRead.create({
                     filter: {
                         recordId: `non-existent-record-id`,
                     },
                     signer: Jws.createSigner(alice)
                 });
-                const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                 expect(readReply.status.code).toBe(404);
-            }));
-            it('should return 404 RecordRead if data has been deleted', () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should return 404 RecordRead if data has been deleted', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // insert public data
-                const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice, published: true });
-                const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice, published: true });
+                const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // ensure data is inserted
-                const queryData = yield TestDataGenerator.generateRecordsQuery({
+                const queryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: message.recordId }
                 });
-                const reply = yield dwn.processMessage(alice.did, queryData.message);
+                const reply = await dwn.processMessage(alice.did, queryData.message);
                 expect(reply.status.code).toBe(200);
-                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(reply.entries?.length).toBe(1);
                 // RecordsDelete
-                const recordsDelete = yield RecordsDelete.create({
+                const recordsDelete = await RecordsDelete.create({
                     recordId: message.recordId,
                     signer: Jws.createSigner(alice)
                 });
-                const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                const deleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                 expect(deleteReply.status.code).toBe(202);
                 // RecordsRead
-                const recordsRead = yield RecordsRead.create({
+                const recordsRead = await RecordsRead.create({
                     filter: {
                         recordId: message.recordId,
                     },
                     signer: Jws.createSigner(alice)
                 });
-                const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                 expect(readReply.status.code).toBe(404);
-            }));
-            it('should return 404 underlying data store cannot locate the data when data is above threshold', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should return 404 underlying data store cannot locate the data when data is above threshold', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 sinon.stub(dataStore, 'get').resolves(undefined);
                 // insert data larger than the allowed amount in encodedData
-                const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({
+                const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1)
                 });
-                const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // testing RecordsRead
-                const recordsRead = yield RecordsRead.create({
+                const recordsRead = await RecordsRead.create({
                     filter: {
                         recordId: message.recordId,
                     },
                     signer: Jws.createSigner(alice)
                 });
-                const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                 expect(readReply.status.code).toBe(404);
-            }));
+            });
             describe('data from encodedData', () => {
-                it('should not get data from DataStore if encodedData exists', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                it('should not get data from DataStore if encodedData exists', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     //since the data is at the threshold it will be returned from the messageStore in the `encodedData` field.
-                    const { message, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({
+                    const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded)
                     });
-                    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 recordRead = yield RecordsRead.create({
+                    const recordRead = await RecordsRead.create({
                         filter: {
                             recordId: message.recordId,
                         },
                         signer: Jws.createSigner(alice)
                     });
                     const dataStoreGet = sinon.spy(dataStore, 'get');
-                    const recordsReadResponse = yield dwn.processMessage(alice.did, recordRead.message);
+                    const recordsReadResponse = await dwn.processMessage(alice.did, recordRead.message);
                     expect(recordsReadResponse.status.code).toBe(200);
                     expect(recordsReadResponse.entry.recordsWrite).toBeDefined();
                     expect(recordsReadResponse.entry.data).toBeDefined();
                     sinon.assert.notCalled(dataStoreGet);
-                    const readData = yield DataStream.toBytes(recordsReadResponse.entry.data);
+                    const readData = await DataStream.toBytes(recordsReadResponse.entry.data);
                     expect(readData).toEqual(dataBytes);
-                }));
-                it('should get data from DataStore if encodedData does not exist', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should get data from DataStore if encodedData does not exist', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     //since the data is over the threshold it will not be returned from the messageStore in the `encodedData` field.
-                    const { message, dataStream, dataBytes } = yield TestDataGenerator.generateRecordsWrite({
+                    const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1)
                     });
-                    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 recordRead = yield RecordsRead.create({
+                    const recordRead = await RecordsRead.create({
                         filter: {
                             recordId: message.recordId,
                         },
                         signer: Jws.createSigner(alice)
                     });
                     const dataStoreGet = sinon.spy(dataStore, 'get');
-                    const recordsReadResponse = yield dwn.processMessage(alice.did, recordRead.message);
+                    const recordsReadResponse = await dwn.processMessage(alice.did, recordRead.message);
                     expect(recordsReadResponse.status.code).toBe(200);
                     expect(recordsReadResponse.entry.recordsWrite).toBeDefined();
                     expect(recordsReadResponse.entry.data).toBeDefined();
                     sinon.assert.calledOnce(dataStoreGet);
-                    const readData = yield DataStream.toBytes(recordsReadResponse.entry.data);
+                    const readData = await DataStream.toBytes(recordsReadResponse.entry.data);
                     expect(readData).toEqual(dataBytes);
-                }));
+                });
             });
             describe('encryption scenarios', () => {
-                it('should be able to decrypt flat-space schema-contained record with a correct derived key', () => __awaiter(this, void 0, void 0, function* () {
+                it('should be able to decrypt flat-space schema-contained record with a correct derived key', async () => {
                     // scenario: Alice writes into her own DWN an encrypted record and she is able to decrypt it
-                    const alice = yield TestDataGenerator.generatePersona();
+                    const alice = await TestDataGenerator.generatePersona();
                     TestStubGenerator.stubDidResolver(didResolver, [alice]);
                     // encrypt Alice's record
                     const originalData = TestDataGenerator.randomBytes(1000);
                     const dataEncryptionInitializationVector = TestDataGenerator.randomBytes(12);
                     const dataEncryptionKey = TestDataGenerator.randomBytes(32);
-                    const { ciphertext: encryptedDataBytes, tag: authenticationTag } = yield Encryption.aeadEncrypt(ContentEncryptionAlgorithm.A256GCM, dataEncryptionKey, dataEncryptionInitializationVector, originalData);
+                    const { ciphertext: encryptedDataBytes, tag: authenticationTag } = await Encryption.aeadEncrypt(ContentEncryptionAlgorithm.A256GCM, dataEncryptionKey, dataEncryptionInitializationVector, originalData);
                     // TODO: #450 - Should not require a root key to specify the derivation scheme (https://github.com/enboxorg/enbox/issues/450)
                     const rootPrivateKeyWithSchemasScheme = {
                         rootKeyId: alice.keyId,
@@ -1564,16 +1550,16 @@ export function testRecordsReadHandler() {
                     };
                     const schema = 'https://some-schema.com';
                     const schemaDerivationPath = Records.constructKeyDerivationPathUsingSchemasScheme(schema);
-                    const schemaDerivedPrivateKey = yield HdKey.derivePrivateKey(rootPrivateKeyWithSchemasScheme, schemaDerivationPath);
-                    const schemaDerivedPublicKey = yield HdKey.derivePublicKey(rootPrivateKeyWithSchemasScheme, schemaDerivationPath);
+                    const schemaDerivedPrivateKey = await HdKey.derivePrivateKey(rootPrivateKeyWithSchemasScheme, schemaDerivationPath);
+                    const schemaDerivedPublicKey = await HdKey.derivePublicKey(rootPrivateKeyWithSchemasScheme, schemaDerivationPath);
                     const rootPrivateKeyWithDataFormatsScheme = {
                         rootKeyId: alice.keyId,
                         derivationScheme: KeyDerivationScheme.DataFormats,
                         derivedPrivateKey: alice.encryptionKeyPair.privateJwk
                     };
                     const dataFormat = 'some/format';
-                    const dataFormatDerivationPath = Records.constructKeyDerivationPathUsingDataFormatsScheme(schema, dataFormat);
-                    const dataFormatDerivedPublicKey = yield HdKey.derivePublicKey(rootPrivateKeyWithDataFormatsScheme, dataFormatDerivationPath);
+                    const dataFormatDerivationPath = Records.constructKeyDerivationPathUsingDataFormatsScheme(dataFormat);
+                    const dataFormatDerivedPublicKey = await HdKey.derivePublicKey(rootPrivateKeyWithDataFormatsScheme, dataFormatDerivationPath);
                     const encryptionInput = {
                         initializationVector: dataEncryptionInitializationVector,
                         key: dataEncryptionKey,
@@ -1589,53 +1575,53 @@ export function testRecordsReadHandler() {
                                 derivationScheme: KeyDerivationScheme.DataFormats
                             }]
                     };
-                    const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({
+                    const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         schema,
                         dataFormat,
                         data: encryptedDataBytes,
                         encryptionInput
                     });
-                    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 recordsRead = yield RecordsRead.create({
+                    const recordsRead = await RecordsRead.create({
                         filter: {
                             recordId: message.recordId,
                         },
                         signer: Jws.createSigner(alice)
                     });
                     // test able to derive correct key using `schemas` scheme from root key to decrypt the message
-                    const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                    const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                     expect(readReply.status.code).toBe(200);
                     const recordsWriteMessage = readReply.entry.recordsWrite;
                     const cipherStream = readReply.entry.data;
-                    const plaintextDataStream = yield Records.decrypt(recordsWriteMessage, schemaDerivedPrivateKey, cipherStream);
-                    const plaintextBytes = yield DataStream.toBytes(plaintextDataStream);
+                    const plaintextDataStream = await Records.decrypt(recordsWriteMessage, schemaDerivedPrivateKey, cipherStream);
+                    const plaintextBytes = await DataStream.toBytes(plaintextDataStream);
                     expect(ArrayUtility.byteArraysEqual(plaintextBytes, originalData)).toBe(true);
                     // test able to derive correct key using `dataFormat` scheme from root key to decrypt the message
-                    const readReply2 = yield dwn.processMessage(alice.did, recordsRead.message); // send the same read message to get a new cipher stream
+                    const readReply2 = await dwn.processMessage(alice.did, recordsRead.message); // send the same read message to get a new cipher stream
                     expect(readReply2.status.code).toBe(200);
                     const cipherStream2 = readReply2.entry.data;
-                    const plaintextDataStream2 = yield Records.decrypt(recordsWriteMessage, rootPrivateKeyWithDataFormatsScheme, cipherStream2);
-                    const plaintextBytes2 = yield DataStream.toBytes(plaintextDataStream2);
+                    const plaintextDataStream2 = await Records.decrypt(recordsWriteMessage, rootPrivateKeyWithDataFormatsScheme, cipherStream2);
+                    const plaintextBytes2 = await DataStream.toBytes(plaintextDataStream2);
                     expect(ArrayUtility.byteArraysEqual(plaintextBytes2, originalData)).toBe(true);
-                    // test unable to decrypt the message if dataFormat-derived key is derived without taking `schema` as input to derivation path
-                    const readReply3 = yield dwn.processMessage(alice.did, recordsRead.message); // process the same read message to get a new cipher stream
+                    // test unable to decrypt the message if dataFormat-derived key uses an incorrect data format in derivation path
+                    const readReply3 = await dwn.processMessage(alice.did, recordsRead.message); // process the same read message to get a new cipher stream
                     expect(readReply3.status.code).toBe(200);
                     const cipherStream3 = readReply3.entry.data;
-                    const invalidDerivationPath = [KeyDerivationScheme.DataFormats, message.descriptor.dataFormat];
-                    const inValidDescendantPrivateKey = yield HdKey.derivePrivateKey(rootPrivateKeyWithDataFormatsScheme, invalidDerivationPath);
-                    yield expect(Records.decrypt(recordsWriteMessage, inValidDescendantPrivateKey, cipherStream3)).rejects.toThrow(DwnErrorCode.RecordsInvalidAncestorKeyDerivationSegment);
-                }));
-                it('should be able to decrypt flat-space schema-less record with the correct derived key', () => __awaiter(this, void 0, void 0, function* () {
+                    const invalidDerivationPath = [KeyDerivationScheme.DataFormats, 'wrong/format'];
+                    const inValidDescendantPrivateKey = await HdKey.derivePrivateKey(rootPrivateKeyWithDataFormatsScheme, invalidDerivationPath);
+                    await expect(Records.decrypt(recordsWriteMessage, inValidDescendantPrivateKey, cipherStream3)).rejects.toThrow(DwnErrorCode.RecordsInvalidAncestorKeyDerivationSegment);
+                });
+                it('should be able to decrypt flat-space schema-less record with the correct derived key', async () => {
                     // scenario: Alice writes into her own DWN an encrypted record and she is able to decrypt it
-                    const alice = yield TestDataGenerator.generatePersona();
+                    const alice = await TestDataGenerator.generatePersona();
                     TestStubGenerator.stubDidResolver(didResolver, [alice]);
                     // encrypt Alice's record
                     const originalData = TestDataGenerator.randomBytes(1000);
                     const dataEncryptionInitializationVector = TestDataGenerator.randomBytes(12);
                     const dataEncryptionKey = TestDataGenerator.randomBytes(32);
-                    const { ciphertext: encryptedDataBytes, tag: authenticationTag } = yield Encryption.aeadEncrypt(ContentEncryptionAlgorithm.A256GCM, dataEncryptionKey, dataEncryptionInitializationVector, originalData);
+                    const { ciphertext: encryptedDataBytes, tag: authenticationTag } = await Encryption.aeadEncrypt(ContentEncryptionAlgorithm.A256GCM, dataEncryptionKey, dataEncryptionInitializationVector, originalData);
                     // TODO: #450 - Should not require a root key to specify the derivation scheme (https://github.com/enboxorg/enbox/issues/450)
                     const rootPrivateKeyWithDataFormatsScheme = {
                         rootKeyId: alice.keyId,
@@ -1643,8 +1629,8 @@ export function testRecordsReadHandler() {
                         derivedPrivateKey: alice.encryptionKeyPair.privateJwk
                     };
                     const dataFormat = `image/jpg`;
-                    const dataFormatDerivationPath = Records.constructKeyDerivationPathUsingDataFormatsScheme(undefined, dataFormat);
-                    const dataFormatDerivedPublicKey = yield HdKey.derivePublicKey(rootPrivateKeyWithDataFormatsScheme, dataFormatDerivationPath);
+                    const dataFormatDerivationPath = Records.constructKeyDerivationPathUsingDataFormatsScheme(dataFormat);
+                    const dataFormatDerivedPublicKey = await HdKey.derivePublicKey(rootPrivateKeyWithDataFormatsScheme, dataFormatDerivationPath);
                     const encryptionInput = {
                         initializationVector: dataEncryptionInitializationVector,
                         key: dataEncryptionKey,
@@ -1655,67 +1641,67 @@ export function testRecordsReadHandler() {
                                 derivationScheme: KeyDerivationScheme.DataFormats
                             }]
                     };
-                    const recordsWrite = yield RecordsWrite.create({
+                    const recordsWrite = await RecordsWrite.create({
                         signer: Jws.createSigner(alice),
                         dataFormat,
                         data: encryptedDataBytes,
                         encryptionInput
                     });
                     const dataStream = DataStream.fromBytes(encryptedDataBytes);
-                    const writeReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
+                    const writeReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
                     expect(writeReply.status.code).toBe(202);
-                    const recordsRead = yield RecordsRead.create({
+                    const recordsRead = await RecordsRead.create({
                         filter: {
                             recordId: recordsWrite.message.recordId,
                         },
                         signer: Jws.createSigner(alice)
                     });
                     // test able to derive correct key using `dataFormat` scheme from root key to decrypt the message
-                    const readReply = yield dwn.processMessage(alice.did, recordsRead.message); // send the same read message to get a new cipher stream
+                    const readReply = await dwn.processMessage(alice.did, recordsRead.message); // send the same read message to get a new cipher stream
                     expect(readReply.status.code).toBe(200);
                     const cipherStream = readReply.entry.data;
                     const recordsWriteMessage = readReply.entry.recordsWrite;
-                    const plaintextDataStream = yield Records.decrypt(recordsWriteMessage, rootPrivateKeyWithDataFormatsScheme, cipherStream);
-                    const plaintextBytes = yield DataStream.toBytes(plaintextDataStream);
+                    const plaintextDataStream = await Records.decrypt(recordsWriteMessage, rootPrivateKeyWithDataFormatsScheme, cipherStream);
+                    const plaintextBytes = await DataStream.toBytes(plaintextDataStream);
                     expect(ArrayUtility.byteArraysEqual(plaintextBytes, originalData)).toBe(true);
-                }));
-                it('should only be able to decrypt record with a correct derived private key  - `protocol-context` derivation scheme', () => __awaiter(this, void 0, void 0, function* () {
+                });
+                it('should only be able to decrypt record with a correct derived private key  - `protocol-context` derivation scheme', async () => {
                     // scenario: Bob initiated an encrypted chat thread with Alice,
                     // bob is able to decrypt subsequent messages from Alice using the `protocol-context` derived private key
                     // creating Alice and Bob persona and setting up a stub DID resolver
-                    const alice = yield TestDataGenerator.generatePersona();
-                    const bob = yield TestDataGenerator.generatePersona();
+                    const alice = await TestDataGenerator.generatePersona();
+                    const bob = await TestDataGenerator.generatePersona();
                     TestStubGenerator.stubDidResolver(didResolver, [alice, bob]);
                     // Alice configures chat protocol with encryption
                     const protocolDefinition = chatProtocolDefinition;
-                    const protocolDefinitionForAlice = yield Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, alice.keyId, alice.encryptionKeyPair.privateJwk);
-                    const protocolsConfigureForAlice = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolDefinitionForAlice = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, alice.keyId, alice.encryptionKeyPair.privateJwk);
+                    const protocolsConfigureForAlice = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: protocolDefinitionForAlice
                     });
-                    const protocolsConfigureForAliceReply = yield dwn.processMessage(alice.did, protocolsConfigureForAlice.message);
+                    const protocolsConfigureForAliceReply = await dwn.processMessage(alice.did, protocolsConfigureForAlice.message);
                     expect(protocolsConfigureForAliceReply.status.code).toBe(202);
                     // Bob configures chat protocol with encryption
-                    const protocolDefinitionForBob = yield Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, bob.keyId, bob.encryptionKeyPair.privateJwk);
-                    const protocolsConfigureForBob = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolDefinitionForBob = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, bob.keyId, bob.encryptionKeyPair.privateJwk);
+                    const protocolsConfigureForBob = await TestDataGenerator.generateProtocolsConfigure({
                         author: bob,
                         protocolDefinition: protocolDefinitionForBob
                     });
-                    const protocolsConfigureReply = yield dwn.processMessage(bob.did, protocolsConfigureForBob.message);
+                    const protocolsConfigureReply = await dwn.processMessage(bob.did, protocolsConfigureForBob.message);
                     expect(protocolsConfigureReply.status.code).toBe(202);
                     // Bob queries for Alice's chat protocol definition
-                    const protocolsQuery = yield ProtocolsQuery.create({
+                    const protocolsQuery = await ProtocolsQuery.create({
                         filter: { protocol: chatProtocolDefinition.protocol }
                     });
-                    const protocolsQueryReply = yield dwn.processMessage(alice.did, protocolsQuery.message);
+                    const protocolsQueryReply = await dwn.processMessage(alice.did, protocolsQuery.message);
                     const protocolsConfigureMessageReceived = protocolsQueryReply.entries[0];
                     // Bob verifies that the chat protocol definition is authored by Alice
-                    yield authenticate(protocolsConfigureMessageReceived.authorization, didResolver);
-                    const protocolsConfigureFetched = yield ProtocolsConfigure.parse(protocolsConfigureMessageReceived);
+                    await authenticate(protocolsConfigureMessageReceived.authorization, didResolver);
+                    const protocolsConfigureFetched = await ProtocolsConfigure.parse(protocolsConfigureMessageReceived);
                     expect(protocolsConfigureFetched.author).toBe(alice.did);
                     // Bob creates an initiating a chat thread RecordsWrite
                     const plaintextMessageToAlice = TestDataGenerator.randomBytes(100);
-                    const { message: threadMessage, dataStream, recordsWrite, encryptedDataBytes, encryptionInput } = yield TestDataGenerator.generateProtocolEncryptedRecordsWrite({
+                    const { message: threadMessage, dataStream, recordsWrite, encryptedDataBytes, encryptionInput } = await TestDataGenerator.generateProtocolEncryptedRecordsWrite({
                         plaintextBytes: plaintextMessageToAlice,
                         author: bob,
                         protocolDefinition: protocolsConfigureForAlice.message.descriptor.definition,
@@ -1724,11 +1710,11 @@ export function testRecordsReadHandler() {
                         encryptSymmetricKeyWithProtocolContextDerivedKey: true
                     });
                     // Bob writes the encrypted chat thread to Alice's DWN
-                    const bobToAliceWriteReply = yield dwn.processMessage(alice.did, threadMessage, { dataStream });
+                    const bobToAliceWriteReply = await dwn.processMessage(alice.did, threadMessage, { dataStream });
                     expect(bobToAliceWriteReply.status.code).toBe(202);
                     // Bob also needs to write the same encrypted chat thread to his own DWN
                     // Opportunity here to create a much nicer utility method for this entire block
-                    const bobToBobRecordsWrite = yield RecordsWrite.createFrom({
+                    const bobToBobRecordsWrite = await RecordsWrite.createFrom({
                         recordsWriteMessage: recordsWrite.message,
                         messageTimestamp: recordsWrite.message.descriptor.messageTimestamp
                     });
@@ -1738,7 +1724,7 @@ export function testRecordsReadHandler() {
                         derivedPrivateKey: bob.encryptionKeyPair.privateJwk
                     };
                     const protocolPathDerivationPath = Records.constructKeyDerivationPathUsingProtocolPathScheme(recordsWrite.message.descriptor);
-                    const protocolPathDerivedPublicJwkForBobsDwn = yield HdKey.derivePublicKey(bobRootPrivateKey, protocolPathDerivationPath);
+                    const protocolPathDerivedPublicJwkForBobsDwn = await HdKey.derivePublicKey(bobRootPrivateKey, protocolPathDerivationPath);
                     const protocolPathDerivedKeyEncryptionInputForBobsDwn = {
                         publicKeyId: bob.keyId, // reusing signing key for encryption purely as a convenience
                         publicKey: protocolPathDerivedPublicJwkForBobsDwn,
@@ -1747,27 +1733,27 @@ export function testRecordsReadHandler() {
                     const encryptionInputForBobsDwn = encryptionInput;
                     const indexOfKeyEncryptionInputToReplace = encryptionInputForBobsDwn.keyEncryptionInputs.findIndex(input => input.derivationScheme === KeyDerivationScheme.ProtocolPath);
                     encryptionInputForBobsDwn.keyEncryptionInputs[indexOfKeyEncryptionInputToReplace] = protocolPathDerivedKeyEncryptionInputForBobsDwn;
-                    yield bobToBobRecordsWrite.encryptSymmetricEncryptionKey(encryptionInputForBobsDwn);
-                    yield bobToBobRecordsWrite.sign({ signer: Jws.createSigner(bob) });
+                    await bobToBobRecordsWrite.encryptSymmetricEncryptionKey(encryptionInputForBobsDwn);
+                    await bobToBobRecordsWrite.sign({ signer: Jws.createSigner(bob) });
                     const dataStreamForBobsDwn = DataStream.fromBytes(encryptedDataBytes);
-                    const bobToBobWriteReply = yield dwn.processMessage(bob.did, bobToBobRecordsWrite.message, { dataStream: dataStreamForBobsDwn });
+                    const bobToBobWriteReply = await dwn.processMessage(bob.did, bobToBobRecordsWrite.message, { dataStream: dataStreamForBobsDwn });
                     expect(bobToBobWriteReply.status.code).toBe(202);
                     // NOTE: we know Alice is able to decrypt the message using protocol-path derived key through other tests, so we won't verify it again
                     // test that anyone with the protocol-context derived private key is able to decrypt the message
-                    const recordsRead = yield RecordsRead.create({
+                    const recordsRead = await RecordsRead.create({
                         filter: {
                             recordId: threadMessage.recordId,
                         },
                         signer: Jws.createSigner(alice)
                     });
-                    const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                    const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                     expect(readReply.status.code).toBe(200);
                     const fetchedRecordsWrite = readReply.entry.recordsWrite;
                     const cipherStream = readReply.entry.data;
                     const derivationPathFromReadContext = Records.constructKeyDerivationPathUsingProtocolContextScheme(fetchedRecordsWrite.contextId);
-                    const protocolContextDerivedPrivateJwk = yield HdKey.derivePrivateKey(bobRootPrivateKey, derivationPathFromReadContext);
-                    const plaintextDataStream = yield Records.decrypt(fetchedRecordsWrite, protocolContextDerivedPrivateJwk, cipherStream);
-                    const plaintextBytes = yield DataStream.toBytes(plaintextDataStream);
+                    const protocolContextDerivedPrivateJwk = await HdKey.derivePrivateKey(bobRootPrivateKey, derivationPathFromReadContext);
+                    const plaintextDataStream = await Records.decrypt(fetchedRecordsWrite, protocolContextDerivedPrivateJwk, cipherStream);
+                    const plaintextBytes = await DataStream.toBytes(plaintextDataStream);
                     expect(ArrayUtility.byteArraysEqual(plaintextBytes, plaintextMessageToAlice)).toBe(true);
                     // verify that Alice is able to send an encrypted message using the protocol-context derived public key and Bob is able to decrypt it
                     // NOTE: we will skip verification of Bob's protocol configuration because we have test the such scenario above as well as in other tests
@@ -1775,7 +1761,7 @@ export function testRecordsReadHandler() {
                     const protocolContextDerivedPublicJwkReturned = matchingRecipient.header.derivedPublicKey;
                     const protocolContextDerivingRootKeyIdReturned = matchingRecipient.header.kid;
                     const plaintextMessageToBob = TestDataGenerator.randomBytes(100);
-                    const recordsWriteToBob = yield TestDataGenerator.generateProtocolEncryptedRecordsWrite({
+                    const recordsWriteToBob = await TestDataGenerator.generateProtocolEncryptedRecordsWrite({
                         plaintextBytes: plaintextMessageToBob,
                         author: alice,
                         protocolDefinition: protocolsConfigureForBob.message.descriptor.definition,
@@ -1787,57 +1773,56 @@ export function testRecordsReadHandler() {
                         encryptSymmetricKeyWithProtocolContextDerivedKey: true
                     });
                     // Alice sends the message to Bob
-                    const aliceWriteReply = yield dwn.processMessage(bob.did, recordsWriteToBob.message, { dataStream: recordsWriteToBob.dataStream });
+                    const aliceWriteReply = await dwn.processMessage(bob.did, recordsWriteToBob.message, { dataStream: recordsWriteToBob.dataStream });
                     expect(aliceWriteReply.status.code).toBe(202);
                     // test that Bob is able to read and decrypt Alice's message
-                    const recordsReadByBob = yield RecordsRead.create({
+                    const recordsReadByBob = await RecordsRead.create({
                         filter: {
                             recordId: recordsWriteToBob.message.recordId,
                         },
                         signer: Jws.createSigner(bob)
                     });
-                    const readByBobReply = yield dwn.processMessage(bob.did, recordsReadByBob.message);
+                    const readByBobReply = await dwn.processMessage(bob.did, recordsReadByBob.message);
                     expect(readByBobReply.status.code).toBe(200);
                     const fetchedRecordsWrite2 = readByBobReply.entry.recordsWrite;
                     const cipherStream2 = readByBobReply.entry.data;
-                    const plaintextDataStream2 = yield Records.decrypt(fetchedRecordsWrite2, protocolContextDerivedPrivateJwk, cipherStream2);
-                    const plaintextBytes2 = yield DataStream.toBytes(plaintextDataStream2);
+                    const plaintextDataStream2 = await Records.decrypt(fetchedRecordsWrite2, protocolContextDerivedPrivateJwk, cipherStream2);
+                    const plaintextBytes2 = await DataStream.toBytes(plaintextDataStream2);
                     expect(ArrayUtility.byteArraysEqual(plaintextBytes2, plaintextMessageToBob)).toBe(true);
-                }));
-                it('should only be able to decrypt record with a correct derived private key  - `protocols` derivation scheme', () => __awaiter(this, void 0, void 0, function* () {
+                });
+                it('should only be able to decrypt record with a correct derived private key  - `protocols` derivation scheme', async () => {
                     // scenario: Bob writes into Alice's DWN an encrypted "email", alice is able to decrypt it
-                    var _a;
                     // creating Alice and Bob persona and setting up a stub DID resolver
-                    const alice = yield TestDataGenerator.generatePersona();
-                    const bob = yield TestDataGenerator.generatePersona();
+                    const alice = await TestDataGenerator.generatePersona();
+                    const bob = await TestDataGenerator.generatePersona();
                     TestStubGenerator.stubDidResolver(didResolver, [alice, bob]);
                     // Alice configures email protocol with encryption
                     const protocolDefinition = emailProtocolDefinition;
-                    const encryptedProtocolDefinition = yield Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, alice.keyId, alice.encryptionKeyPair.privateJwk);
-                    const protocolsConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const encryptedProtocolDefinition = await Protocols.deriveAndInjectPublicEncryptionKeys(protocolDefinition, alice.keyId, alice.encryptionKeyPair.privateJwk);
+                    const protocolsConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: encryptedProtocolDefinition
                     });
-                    const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigure.message);
+                    const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfigure.message);
                     expect(protocolsConfigureReply.status.code).toBe(202);
                     // Bob queries for Alice's email protocol definition
-                    const protocolsQuery = yield ProtocolsQuery.create({
+                    const protocolsQuery = await ProtocolsQuery.create({
                         filter: { protocol: emailProtocolDefinition.protocol }
                     });
-                    const protocolsQueryReply = yield dwn.processMessage(alice.did, protocolsQuery.message);
+                    const protocolsQueryReply = await dwn.processMessage(alice.did, protocolsQuery.message);
                     const protocolsConfigureMessageReceived = protocolsQueryReply.entries[0];
                     // Bob verifies that the email protocol definition is authored by Alice
-                    yield authenticate(protocolsConfigureMessageReceived.authorization, didResolver);
-                    const protocolsConfigureFetched = yield ProtocolsConfigure.parse(protocolsConfigureMessageReceived);
+                    await authenticate(protocolsConfigureMessageReceived.authorization, didResolver);
+                    const protocolsConfigureFetched = await ProtocolsConfigure.parse(protocolsConfigureMessageReceived);
                     expect(protocolsConfigureFetched.author).toBe(alice.did);
                     // Bob encrypts his email to Alice with a randomly generated symmetric key
                     const bobMessageBytes = TestDataGenerator.randomBytes(100);
                     const dataEncryptionInitializationVector = TestDataGenerator.randomBytes(12);
                     const dataEncryptionKey = TestDataGenerator.randomBytes(32);
-                    const { ciphertext: bobMessageEncryptedBytes, tag: authenticationTag } = yield Encryption.aeadEncrypt(ContentEncryptionAlgorithm.A256GCM, dataEncryptionKey, dataEncryptionInitializationVector, bobMessageBytes);
+                    const { ciphertext: bobMessageEncryptedBytes, tag: authenticationTag } = await Encryption.aeadEncrypt(ContentEncryptionAlgorithm.A256GCM, dataEncryptionKey, dataEncryptionInitializationVector, bobMessageBytes);
                     // Bob generates an encrypted RecordsWrite,
                     // the public encryption key designated by Alice is used to encrypt the symmetric key Bob generated above
-                    const publicJwk = (_a = protocolsConfigureFetched.message.descriptor.definition.structure.email.$encryption) === null || _a === void 0 ? void 0 : _a.publicKeyJwk;
+                    const publicJwk = protocolsConfigureFetched.message.descriptor.definition.structure.email.$encryption?.publicKeyJwk;
                     expect(publicJwk).toBeDefined();
                     const encryptionInput = {
                         initializationVector: dataEncryptionInitializationVector,
@@ -1849,7 +1834,7 @@ export function testRecordsReadHandler() {
                                 derivationScheme: KeyDerivationScheme.ProtocolPath
                             }]
                     };
-                    const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({
+                    const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({
                         author: bob,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'email', // this comes from `types` in protocol definition
@@ -1859,17 +1844,17 @@ export function testRecordsReadHandler() {
                         encryptionInput
                     });
                     // Bob writes the encrypted email to Alice's DWN
-                    const bobWriteReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                    const bobWriteReply = await dwn.processMessage(alice.did, message, { dataStream });
                     expect(bobWriteReply.status.code).toBe(202);
                     // Alice reads the encrypted email
                     // assume Alice already made query to get the `recordId` of the email
-                    const recordsRead = yield RecordsRead.create({
+                    const recordsRead = await RecordsRead.create({
                         filter: {
                             recordId: message.recordId,
                         },
                         signer: Jws.createSigner(alice)
                     });
-                    const readReply = yield dwn.processMessage(alice.did, recordsRead.message);
+                    const readReply = await dwn.processMessage(alice.did, recordsRead.message);
                     expect(readReply.status.code).toBe(200);
                     // test that Alice is able decrypt the encrypted email from Bob using the root key
                     const rootPrivateKey = {
@@ -1879,43 +1864,43 @@ export function testRecordsReadHandler() {
                     };
                     const fetchedRecordsWrite = readReply.entry.recordsWrite;
                     const cipherStream = readReply.entry.data;
-                    const plaintextDataStream = yield Records.decrypt(fetchedRecordsWrite, rootPrivateKey, cipherStream);
-                    const plaintextBytes = yield DataStream.toBytes(plaintextDataStream);
+                    const plaintextDataStream = await Records.decrypt(fetchedRecordsWrite, rootPrivateKey, cipherStream);
+                    const plaintextBytes = await DataStream.toBytes(plaintextDataStream);
                     expect(ArrayUtility.byteArraysEqual(plaintextBytes, bobMessageBytes)).toBe(true);
                     // test that a correct derived key is able decrypt the encrypted email from Bob
-                    const readReply2 = yield dwn.processMessage(alice.did, recordsRead.message);
+                    const readReply2 = await dwn.processMessage(alice.did, recordsRead.message);
                     expect(readReply2.status.code).toBe(200);
                     const relativeDescendantDerivationPath = Records.constructKeyDerivationPath(KeyDerivationScheme.ProtocolPath, fetchedRecordsWrite);
-                    const derivedPrivateKey = yield HdKey.derivePrivateKey(rootPrivateKey, relativeDescendantDerivationPath);
+                    const derivedPrivateKey = await HdKey.derivePrivateKey(rootPrivateKey, relativeDescendantDerivationPath);
                     const fetchedRecordsWrite2 = readReply2.entry.recordsWrite;
                     const cipherStream2 = readReply2.entry.data;
-                    const plaintextDataStream2 = yield Records.decrypt(fetchedRecordsWrite2, derivedPrivateKey, cipherStream2);
-                    const plaintextBytes2 = yield DataStream.toBytes(plaintextDataStream2);
+                    const plaintextDataStream2 = await Records.decrypt(fetchedRecordsWrite2, derivedPrivateKey, cipherStream2);
+                    const plaintextBytes2 = await DataStream.toBytes(plaintextDataStream2);
                     expect(ArrayUtility.byteArraysEqual(plaintextBytes2, bobMessageBytes)).toBe(true);
                     // test unable to decrypt the message if derived key has an unexpected path
                     const invalidDerivationPath = [KeyDerivationScheme.ProtocolPath, protocolDefinition.protocol, 'invalidContextId'];
-                    const inValidDescendantPrivateKey = yield HdKey.derivePrivateKey(rootPrivateKey, invalidDerivationPath);
-                    yield expect(Records.decrypt(fetchedRecordsWrite, inValidDescendantPrivateKey, cipherStream)).rejects.toThrow(DwnErrorCode.RecordsInvalidAncestorKeyDerivationSegment);
+                    const inValidDescendantPrivateKey = await HdKey.derivePrivateKey(rootPrivateKey, invalidDerivationPath);
+                    await expect(Records.decrypt(fetchedRecordsWrite, inValidDescendantPrivateKey, cipherStream)).rejects.toThrow(DwnErrorCode.RecordsInvalidAncestorKeyDerivationSegment);
                     // test unable to decrypt the message if no derivation scheme used by the message matches the scheme used by the given private key
                     const privateKeyWithMismatchingDerivationScheme = {
                         rootKeyId: alice.keyId,
                         derivationScheme: 'scheme-that-is-not-protocol-context',
                         derivedPrivateKey: alice.encryptionKeyPair.privateJwk
                     };
-                    yield expect(Records.decrypt(fetchedRecordsWrite, privateKeyWithMismatchingDerivationScheme, cipherStream)).rejects.toThrow(DwnErrorCode.RecordsDecryptNoMatchingKeyEncryptedFound);
+                    await expect(Records.decrypt(fetchedRecordsWrite, privateKeyWithMismatchingDerivationScheme, cipherStream)).rejects.toThrow(DwnErrorCode.RecordsDecryptNoMatchingKeyEncryptedFound);
                     // test unable to decrypt the message if public key ID does not match the derived private key
                     const privateKeyWithMismatchingKeyId = {
                         rootKeyId: 'mismatchingKeyId',
                         derivationScheme: KeyDerivationScheme.ProtocolPath,
                         derivedPrivateKey: alice.encryptionKeyPair.privateJwk
                     };
-                    yield expect(Records.decrypt(fetchedRecordsWrite, privateKeyWithMismatchingKeyId, cipherStream)).rejects.toThrow(DwnErrorCode.RecordsDecryptNoMatchingKeyEncryptedFound);
-                }));
+                    await expect(Records.decrypt(fetchedRecordsWrite, privateKeyWithMismatchingKeyId, cipherStream)).rejects.toThrow(DwnErrorCode.RecordsDecryptNoMatchingKeyEncryptedFound);
+                });
             });
         });
-        it('should return 401 if signature check fails', () => __awaiter(this, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const recordsRead = yield RecordsRead.create({
+        it('should return 401 if signature check fails', async () => {
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const recordsRead = await RecordsRead.create({
                 filter: {
                     recordId: 'any-id',
                 },
@@ -1923,17 +1908,17 @@ export function testRecordsReadHandler() {
             });
             // setting up a stub did resolver & message store
             // intentionally not supplying the public key so a different public key is generated to simulate invalid signature
-            const mismatchingPersona = yield TestDataGenerator.generatePersona({ did: alice.did, keyId: alice.keyId });
+            const mismatchingPersona = await TestDataGenerator.generatePersona({ did: alice.did, keyId: alice.keyId });
             const didResolver = TestStubGenerator.createDidResolverStub(mismatchingPersona);
             const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
             const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
             const recordsReadHandler = new RecordsReadHandler(didResolver, messageStoreStub, dataStoreStub);
-            const reply = yield recordsReadHandler.handle({ tenant: alice.did, message: recordsRead.message });
+            const reply = await recordsReadHandler.handle({ tenant: alice.did, message: recordsRead.message });
             expect(reply.status.code).toBe(401);
-        }));
-        it('should return 400 if fail parsing the message', () => __awaiter(this, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const recordsRead = yield RecordsRead.create({
+        });
+        it('should return 400 if fail parsing the message', async () => {
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const recordsRead = await RecordsRead.create({
                 filter: {
                     recordId: 'any-id',
                 },
@@ -1945,9 +1930,9 @@ export function testRecordsReadHandler() {
             const recordsReadHandler = new RecordsReadHandler(didResolver, messageStoreStub, dataStoreStub);
             // stub the `parse()` function to throw an error
             sinon.stub(RecordsRead, 'parse').throws('anyError');
-            const reply = yield recordsReadHandler.handle({ tenant: alice.did, message: recordsRead.message });
+            const reply = await recordsReadHandler.handle({ tenant: alice.did, message: recordsRead.message });
             expect(reply.status.code).toBe(400);
-        }));
+        });
     });
 }
 //# sourceMappingURL=records-read.spec.js.map