@enbox/dwn-sdk-js 0.0.6 → 0.0.8

package/dist/esm/tests/features/author-delegated-grant.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 emailProtocolDefinition from '../vectors/protocol-definitions/email.json' with { type: 'json' };
 import messageProtocolDefinition from '../vectors/protocol-definitions/message.json' with { type: 'json' };
 import sinon from 'sinon';
@@ -20,7 +11,7 @@ import { PermissionGrant } from '../../src/protocols/permission-grant.js';
 import { Poller } from '../utils/poller.js';
 import { RecordsWrite } from '../../src/interfaces/records-write.js';
 import { TestDataGenerator } from '../utils/test-data-generator.js';
-import { TestEventStream } from '../test-event-stream.js';
+import { TestEventLog } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
 import { Time } from '../../src/utils/time.js';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
@@ -33,41 +24,41 @@ export function testAuthorDelegatedGrant() {
         let dataStore;
         let resumableTaskStore;
         let stateIndex;
-        let eventStream;
+        let eventLog;
         let dwn;
         // important to follow the `before` and `after` pattern to initialize and clean the stores in tests
         // so that different test suites can reuse the same backend store for testing
-        beforeAll(() => __awaiter(this, void 0, void 0, function* () {
+        beforeAll(async () => {
             didResolver = new UniversalResolver({ didResolvers: [DidKey] });
             const stores = TestStores.get();
             messageStore = stores.messageStore;
             dataStore = stores.dataStore;
             resumableTaskStore = stores.resumableTaskStore;
             stateIndex = stores.stateIndex;
-            eventStream = TestEventStream.get();
-            dwn = yield Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
-        }));
-        beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+            eventLog = TestEventLog.get();
+            dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventLog, resumableTaskStore });
+        });
+        beforeEach(async () => {
             sinon.restore(); // wipe all previous stubs/spies/mocks/fakes
             // clean up before each test rather than after so that a test does not depend on other tests to do the clean up
-            yield messageStore.clear();
-            yield dataStore.clear();
-            yield resumableTaskStore.clear();
-            yield stateIndex.clear();
-        }));
-        afterAll(() => __awaiter(this, void 0, void 0, function* () {
-            yield dwn.close();
-        }));
+            await messageStore.clear();
+            await dataStore.clear();
+            await resumableTaskStore.clear();
+            await stateIndex.clear();
+        });
+        afterAll(async () => {
+            await dwn.close();
+        });
         describe('ProtocolsConfigure', () => {
-            it('should allow author-delegated grant to configure protocols', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            it('should allow author-delegated grant to configure protocols', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // Alice grants Bob ability to configure any protocol, bob will use it to configure the email protocol
                 const scope = {
                     interface: DwnInterfaceName.Protocols,
                     method: DwnMethodName.Configure,
                 };
-                const grantToBob = yield PermissionsProtocol.createGrant({
+                const grantToBob = await PermissionsProtocol.createGrant({
                     delegated: true, // this is a delegated grant
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                     description: 'Allow Bob to configure the email protocol',
@@ -76,22 +67,22 @@ export function testAuthorDelegatedGrant() {
                     signer: Jws.createSigner(alice)
                 });
                 // Bob attempts to configure a protocol
-                const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                     delegatedGrant: grantToBob.dataEncodedMessage,
                     author: bob,
                     protocolDefinition: emailProtocolDefinition,
                 });
                 // Bob should be able to configure a protocol on behalf of alice
-                const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                const protocolConfigureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                 expect(protocolConfigureReply.status.code).toBe(202);
                 // verify the protocol configure message was processed
-                const protocolsQuery = yield TestDataGenerator.generateProtocolsQuery({
+                const protocolsQuery = await TestDataGenerator.generateProtocolsQuery({
                     author: alice,
                     filter: { protocol: emailProtocolDefinition.protocol }
                 });
-                const { status, entries } = yield dwn.processMessage(alice.did, protocolsQuery.message);
+                const { status, entries } = await dwn.processMessage(alice.did, protocolsQuery.message);
                 expect(status.code).toBe(200);
-                expect(entries === null || entries === void 0 ? void 0 : entries.length).toBe(1);
+                expect(entries?.length).toBe(1);
                 const fetchedProtocolConfigure = entries[0];
                 expect(fetchedProtocolConfigure.descriptor.definition).toEqual(emailProtocolDefinition);
                 // author should be alice
@@ -99,17 +90,17 @@ export function testAuthorDelegatedGrant() {
                 expect(author).toBe(alice.did);
                 const signer = Message.getSigner(fetchedProtocolConfigure);
                 expect(signer).toBe(bob.did);
-            }));
-            it('should allow author-delegated grant to configure a specific protocol', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should allow author-delegated grant to configure a specific protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // Alice grants Bob to configure the email protocol
                 const scope = {
                     interface: DwnInterfaceName.Protocols,
                     method: DwnMethodName.Configure,
                     protocol: emailProtocolDefinition.protocol,
                 };
-                const grantToBob = yield PermissionsProtocol.createGrant({
+                const grantToBob = await PermissionsProtocol.createGrant({
                     delegated: true, // this is a delegated grant
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                     description: 'Allow Bob to configure the email protocol',
@@ -118,22 +109,22 @@ export function testAuthorDelegatedGrant() {
                     signer: Jws.createSigner(alice)
                 });
                 // Bob attempts to configure a protocol
-                const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                     delegatedGrant: grantToBob.dataEncodedMessage,
                     author: bob,
                     protocolDefinition: emailProtocolDefinition,
                 });
                 // Bob should be able to configure a protocol on behalf of alice
-                const protocolConfigureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                const protocolConfigureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                 expect(protocolConfigureReply.status.code).toBe(202);
                 // verify the protocol configure message was processed
-                const protocolsQuery = yield TestDataGenerator.generateProtocolsQuery({
+                const protocolsQuery = await TestDataGenerator.generateProtocolsQuery({
                     author: alice,
                     filter: { protocol: emailProtocolDefinition.protocol }
                 });
-                const { status, entries } = yield dwn.processMessage(alice.did, protocolsQuery.message);
+                const { status, entries } = await dwn.processMessage(alice.did, protocolsQuery.message);
                 expect(status.code).toBe(200);
-                expect(entries === null || entries === void 0 ? void 0 : entries.length).toBe(1);
+                expect(entries?.length).toBe(1);
                 const fetchedProtocolConfigure = entries[0];
                 expect(fetchedProtocolConfigure.descriptor.definition).toEqual(emailProtocolDefinition);
                 // author should be alice
@@ -142,28 +133,31 @@ export function testAuthorDelegatedGrant() {
                 const signer = Message.getSigner(fetchedProtocolConfigure);
                 expect(signer).toBe(bob.did);
                 // verify that bob cannot configure a different protocol
-                const otherProtocolDefinition = Object.assign(Object.assign({}, emailProtocolDefinition), { protocol: 'https://example.com/protocol/otherProtocol' });
-                const otherProtocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                const otherProtocolDefinition = {
+                    ...emailProtocolDefinition,
+                    protocol: 'https://example.com/protocol/otherProtocol'
+                };
+                const otherProtocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                     delegatedGrant: grantToBob.dataEncodedMessage,
                     author: bob,
                     protocolDefinition: otherProtocolDefinition,
                 });
-                const otherProtocolConfigureReply = yield dwn.processMessage(alice.did, otherProtocolConfigure.message);
+                const otherProtocolConfigureReply = await dwn.processMessage(alice.did, otherProtocolConfigure.message);
                 expect(otherProtocolConfigureReply.status.code).toBe(401);
                 expect(otherProtocolConfigureReply.status.detail).toContain(DwnErrorCode.ProtocolsGrantAuthorizationScopeProtocolMismatch);
-            }));
+            });
         });
         describe('RecordsWrite.parse()', () => {
-            it('should throw if a message invokes a author-delegated grant (ID) but the author-delegated grant is not given', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generatePersona();
-                const bob = yield TestDataGenerator.generatePersona();
+            it('should throw if a message invokes a author-delegated grant (ID) but the author-delegated grant is not given', async () => {
+                const alice = await TestDataGenerator.generatePersona();
+                const bob = await TestDataGenerator.generatePersona();
                 // Alice grants Bob to write as her for the chat protocol
                 const scope = {
                     interface: DwnInterfaceName.Records,
                     method: DwnMethodName.Write,
                     protocol: 'chat'
                 };
-                const grantToBob = yield PermissionsProtocol.createGrant({
+                const grantToBob = await PermissionsProtocol.createGrant({
                     delegated: true, // this is a delegated grant
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                     description: 'Allow Bob to write as me in chat protocol',
@@ -172,26 +166,28 @@ export function testAuthorDelegatedGrant() {
                     signer: Jws.createSigner(alice)
                 });
                 // Bob creates a chat message invoking the delegated grant (ID) but does not include the author-delegated grant (we remove it below)
-                const recordsWrite = yield RecordsWrite.create({
+                const recordsWrite = await RecordsWrite.create({
                     signer: Jws.createSigner(bob),
                     delegatedGrant: grantToBob.dataEncodedMessage,
+                    protocol: 'http://test-protocol.xyz',
+                    protocolPath: 'testRecord',
                     dataFormat: 'application/octet-stream',
                     data: TestDataGenerator.randomBytes(10),
                 });
                 delete recordsWrite.message.authorization.authorDelegatedGrant; // intentionally remove `authorDelegatedGrant`
                 const parsePromise = RecordsWrite.parse(recordsWrite.message);
-                yield expect(parsePromise).rejects.toThrow(DwnErrorCode.RecordsAuthorDelegatedGrantAndIdExistenceMismatch);
-            }));
-            it('should throw if a message includes an author-delegated grant but does not reference it in author signature', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generatePersona();
-                const bob = yield TestDataGenerator.generatePersona();
+                await expect(parsePromise).rejects.toThrow(DwnErrorCode.RecordsAuthorDelegatedGrantAndIdExistenceMismatch);
+            });
+            it('should throw if a message includes an author-delegated grant but does not reference it in author signature', async () => {
+                const alice = await TestDataGenerator.generatePersona();
+                const bob = await TestDataGenerator.generatePersona();
                 // Alice grants Bob to write as her for the chat protocol
                 const scope = {
                     interface: DwnInterfaceName.Records,
                     method: DwnMethodName.Write,
                     protocol: 'chat'
                 };
-                const grantToBob = yield PermissionsProtocol.createGrant({
+                const grantToBob = await PermissionsProtocol.createGrant({
                     delegated: true, // this is a delegated grant
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                     description: 'Allow Bob to write as me in chat protocol',
@@ -201,39 +197,40 @@ export function testAuthorDelegatedGrant() {
                 });
                 // Bob attempts to sign as Alice by including an author-delegated grant
                 // but does not reference the grant ID in author signature (we remove it below)
-                const recordsWrite = yield RecordsWrite.create({
+                const recordsWrite = await RecordsWrite.create({
                     signer: Jws.createSigner(bob),
                     delegatedGrant: grantToBob.dataEncodedMessage,
+                    protocol: 'http://test-protocol.xyz',
+                    protocolPath: 'testRecord',
                     dataFormat: 'application/octet-stream',
                     data: TestDataGenerator.randomBytes(10),
                 });
-                const authorSignaturePayloadCopy = Object.assign({}, recordsWrite.signaturePayload);
+                const authorSignaturePayloadCopy = { ...recordsWrite.signaturePayload };
                 delete authorSignaturePayloadCopy.delegatedGrantId; // intentionally remove `delegatedGrantId` in author signature
                 recordsWrite.message.authorization.signature.payload = Encoder.stringToBase64Url(JSON.stringify(authorSignaturePayloadCopy));
                 const parsePromise = RecordsWrite.parse(recordsWrite.message);
-                yield expect(parsePromise).rejects.toThrow(DwnErrorCode.RecordsAuthorDelegatedGrantAndIdExistenceMismatch);
-            }));
+                await expect(parsePromise).rejects.toThrow(DwnErrorCode.RecordsAuthorDelegatedGrantAndIdExistenceMismatch);
+            });
         });
-        it('should only allow correct entity invoking an author-delegated grant to write', () => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+        it('should only allow correct entity invoking an author-delegated grant to write', async () => {
             // scenario:
             // 1. Alice creates a delegated grant for Device X and Device Y,
             // 2. Device X and Y can both use their grants to write a message to Bob's DWN as Alice
             // 3. Messages written by device X and Y should be considered to have been authored by Alice
             // 4. Carol should not be able to write a message as Alice using Device X's delegated grant
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceY = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const carol = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
+            const deviceY = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const carol = await TestDataGenerator.generateDidKeyPersona();
             // Bob has the message protocol installed
             const protocolDefinition = messageProtocolDefinition;
             const protocol = protocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolConfigureReply.status.code).toBe(202);
             // Alice creates a delegated grant for device X and device Y
             const scope = {
@@ -241,14 +238,14 @@ export function testAuthorDelegatedGrant() {
                 method: DwnMethodName.Write,
                 protocol
             };
-            const deviceXGrant = yield PermissionsProtocol.createGrant({
+            const deviceXGrant = await PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
                 scope: scope,
                 signer: Jws.createSigner(alice)
             });
-            const deviceYGrant = yield PermissionsProtocol.createGrant({
+            const deviceYGrant = await PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceY.did,
@@ -258,7 +255,7 @@ export function testAuthorDelegatedGrant() {
             // generate a `RecordsWrite` message from device X and write to Bob's DWN
             const deviceXData = new TextEncoder().encode('message from device X');
             const deviceXDataStream = DataStream.fromBytes(deviceXData);
-            const messageByDeviceX = yield RecordsWrite.create({
+            const messageByDeviceX = await RecordsWrite.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: deviceXGrant.dataEncodedMessage,
                 protocol,
@@ -267,42 +264,42 @@ export function testAuthorDelegatedGrant() {
                 dataFormat: protocolDefinition.types.message.dataFormats[0],
                 data: deviceXData
             });
-            const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
+            const deviceXWriteReply = await dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
             expect(deviceXWriteReply.status.code).toBe(202);
             // verify the message by device X got written to Bob's DWN, AND Alice is the logical author
-            const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQueryByBob = await TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
-            const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
+            const bobRecordsQueryReply = await dwn.processMessage(bob.did, recordsQueryByBob.message);
             expect(bobRecordsQueryReply.status.code).toBe(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+            expect(bobRecordsQueryReply.entries?.length).toBe(1);
             const fetchedDeviceXWriteEntry = bobRecordsQueryReply.entries[0];
             expect(fetchedDeviceXWriteEntry.encodedData).toBe(base64url.baseEncode(deviceXData));
-            const fetchedDeviceXWrite = yield RecordsWrite.parse(fetchedDeviceXWriteEntry);
+            const fetchedDeviceXWrite = await RecordsWrite.parse(fetchedDeviceXWriteEntry);
             expect(fetchedDeviceXWrite.author).toBe(alice.did);
             // generate a new message by device Y updating the existing record device X created, and write to Bob's DWN
             const deviceYData = new TextEncoder().encode('message from device Y');
             const deviceYDataStream = DataStream.fromBytes(deviceYData);
-            const messageByDeviceY = yield RecordsWrite.createFrom({
+            const messageByDeviceY = await RecordsWrite.createFrom({
                 recordsWriteMessage: fetchedDeviceXWrite.message,
                 data: deviceYData,
                 signer: Jws.createSigner(deviceY),
                 delegatedGrant: deviceYGrant.dataEncodedMessage,
             });
-            const deviceYWriteReply = yield dwn.processMessage(bob.did, messageByDeviceY.message, { dataStream: deviceYDataStream });
+            const deviceYWriteReply = await dwn.processMessage(bob.did, messageByDeviceY.message, { dataStream: deviceYDataStream });
             expect(deviceYWriteReply.status.code).toBe(202);
             // verify the message by device Y got written to Bob's DWN, AND Alice is the logical author
-            const bobRecordsQueryReply2 = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
+            const bobRecordsQueryReply2 = await dwn.processMessage(bob.did, recordsQueryByBob.message);
             expect(bobRecordsQueryReply2.status.code).toBe(200);
-            expect((_b = bobRecordsQueryReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+            expect(bobRecordsQueryReply2.entries?.length).toBe(1);
             const fetchedDeviceYWriteEntry = bobRecordsQueryReply2.entries[0];
             expect(fetchedDeviceYWriteEntry.encodedData).toBe(base64url.baseEncode(deviceYData));
-            const fetchedDeviceYWrite = yield RecordsWrite.parse(fetchedDeviceYWriteEntry);
+            const fetchedDeviceYWrite = await RecordsWrite.parse(fetchedDeviceYWriteEntry);
             expect(fetchedDeviceYWrite.author).toBe(alice.did);
             // Verify that Carol cannot write a chat message as Alice by invoking the Device X's grant
             const messageByCarolAsAlice = new TextEncoder().encode('Message from Carol pretending to be Alice');
-            const writeByCarolAsAlice = yield RecordsWrite.create({
+            const writeByCarolAsAlice = await RecordsWrite.create({
                 signer: Jws.createSigner(carol),
                 delegatedGrant: deviceXGrant.dataEncodedMessage,
                 protocol,
@@ -311,40 +308,39 @@ export function testAuthorDelegatedGrant() {
                 dataFormat: protocolDefinition.types.message.dataFormats[0],
                 data: messageByCarolAsAlice
             });
-            const carolWriteReply = yield dwn.processMessage(carol.did, writeByCarolAsAlice.message, { dataStream: DataStream.fromBytes(messageByCarolAsAlice) });
+            const carolWriteReply = await dwn.processMessage(carol.did, writeByCarolAsAlice.message, { dataStream: DataStream.fromBytes(messageByCarolAsAlice) });
             expect(carolWriteReply.status.code).toBe(400);
             expect(carolWriteReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantGrantedToAndOwnerSignatureMismatch);
-        }));
-        it('should only allow correct entity invoking an author-delegated grant to read and query ', () => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+        });
+        it('should only allow correct entity invoking an author-delegated grant to read and query ', async () => {
             // scenario:
             // 1. Alice creates read and query delegated grants for device X,
             // 2. Bob starts a chat thread with Alice on his DWN
             // 3. device X should be able to read the chat thread
             // 4. Carol should not be able to read the chat thread using device X's delegated grant
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const carol = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const carol = await TestDataGenerator.generateDidKeyPersona();
             // Bob has the chat protocol installed
             const protocolDefinition = threadRoleProtocolDefinition;
             const protocol = threadRoleProtocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolsConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // Bob starts a chat thread
-            const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+            const threadRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'thread',
             });
-            const threadRoleReply = yield dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+            const threadRoleReply = await dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
             expect(threadRoleReply.status.code).toBe(202);
             // Bob adds Alice as a participant in the thread
-            const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
+            const participantRoleRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 recipient: alice.did,
                 protocol: protocolDefinition.protocol,
@@ -352,19 +348,19 @@ export function testAuthorDelegatedGrant() {
                 parentContextId: threadRecord.message.contextId,
                 data: new TextEncoder().encode('Alice is my friend'),
             });
-            const participantRoleReply = yield dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
+            const participantRoleReply = await dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
             expect(participantRoleReply.status.code).toBe(202);
             // Bob writes a chat message in the thread
-            const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+            const chatRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'thread/chat',
                 parentContextId: threadRecord.message.contextId,
             });
-            const chatRecordReply = yield dwn.processMessage(bob.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+            const chatRecordReply = await dwn.processMessage(bob.did, chatRecord.message, { dataStream: chatRecord.dataStream });
             expect(chatRecordReply.status.code).toBe(202);
             // Alice creates a delegated query grant for device X to act as Alice.
-            const queryGrantForDeviceX = yield PermissionsProtocol.createGrant({
+            const queryGrantForDeviceX = await PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -376,7 +372,7 @@ export function testAuthorDelegatedGrant() {
                 signer: Jws.createSigner(alice)
             });
             // Alice creates a delegated read grant for device X to act as Alice.
-            const readGrantForDeviceX = yield PermissionsProtocol.createGrant({
+            const readGrantForDeviceX = await PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -388,15 +384,15 @@ export function testAuthorDelegatedGrant() {
                 signer: Jws.createSigner(alice)
             });
             // sanity verify Bob himself is able to query for the chat thread from Bob's DWN
-            const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQueryByBob = await TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
-            const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
+            const bobRecordsQueryReply = await dwn.processMessage(bob.did, recordsQueryByBob.message);
             expect(bobRecordsQueryReply.status.code).toBe(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(3);
+            expect(bobRecordsQueryReply.entries?.length).toBe(3);
             // sanity verify Alice herself is able to query for the chat message from Bob's DWN
-            const recordsQueryByAlice = yield RecordsQuery.create({
+            const recordsQueryByAlice = await RecordsQuery.create({
                 signer: Jws.createSigner(alice),
                 protocolRole: 'thread/participant',
                 filter: {
@@ -405,11 +401,11 @@ export function testAuthorDelegatedGrant() {
                     protocolPath: 'thread/chat'
                 }
             });
-            const aliceRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByAlice.message);
+            const aliceRecordsQueryReply = await dwn.processMessage(bob.did, recordsQueryByAlice.message);
             expect(aliceRecordsQueryReply.status.code).toBe(200);
-            expect((_b = aliceRecordsQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+            expect(aliceRecordsQueryReply.entries?.length).toBe(1);
             // verify device X is able to query for the chat message from Bob's DWN
-            const recordsQueryByDeviceX = yield RecordsQuery.create({
+            const recordsQueryByDeviceX = await RecordsQuery.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: queryGrantForDeviceX.dataEncodedMessage,
                 protocolRole: 'thread/participant',
@@ -419,11 +415,11 @@ export function testAuthorDelegatedGrant() {
                     protocolPath: 'thread/chat'
                 }
             });
-            const deviceXRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByDeviceX.message);
+            const deviceXRecordsQueryReply = await dwn.processMessage(bob.did, recordsQueryByDeviceX.message);
             expect(deviceXRecordsQueryReply.status.code).toBe(200);
-            expect((_c = deviceXRecordsQueryReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
+            expect(deviceXRecordsQueryReply.entries?.length).toBe(1);
             // verify device X is able to read the chat message from Bob's DWN
-            const recordsReadByDeviceX = yield RecordsRead.create({
+            const recordsReadByDeviceX = await RecordsRead.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: readGrantForDeviceX.dataEncodedMessage,
                 protocolRole: 'thread/participant',
@@ -431,11 +427,11 @@ export function testAuthorDelegatedGrant() {
                     recordId: chatRecord.message.recordId
                 }
             });
-            const deviceXRecordsReadReply = yield dwn.processMessage(bob.did, recordsReadByDeviceX.message);
+            const deviceXRecordsReadReply = await dwn.processMessage(bob.did, recordsReadByDeviceX.message);
             expect(deviceXRecordsReadReply.status.code).toBe(200);
-            expect((_d = deviceXRecordsReadReply.entry.recordsWrite) === null || _d === void 0 ? void 0 : _d.recordId).toBe(chatRecord.message.recordId);
+            expect(deviceXRecordsReadReply.entry.recordsWrite?.recordId).toBe(chatRecord.message.recordId);
             // Verify that Carol cannot query as Alice by invoking the delegated grant granted to Device X
-            const recordsQueryByCarol = yield RecordsQuery.create({
+            const recordsQueryByCarol = await RecordsQuery.create({
                 signer: Jws.createSigner(carol),
                 delegatedGrant: readGrantForDeviceX.dataEncodedMessage,
                 protocolRole: 'thread/participant',
@@ -445,11 +441,11 @@ export function testAuthorDelegatedGrant() {
                     protocolPath: 'thread/chat'
                 }
             });
-            const recordsQueryByCarolReply = yield dwn.processMessage(bob.did, recordsQueryByCarol.message);
+            const recordsQueryByCarolReply = await dwn.processMessage(bob.did, recordsQueryByCarol.message);
             expect(recordsQueryByCarolReply.status.code).toBe(400);
             expect(recordsQueryByCarolReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantGrantedToAndOwnerSignatureMismatch);
             // Verify that Carol cannot read as Alice by invoking the delegated grant granted to Device X
-            const recordsReadByCarol = yield RecordsRead.create({
+            const recordsReadByCarol = await RecordsRead.create({
                 signer: Jws.createSigner(carol),
                 delegatedGrant: readGrantForDeviceX.dataEncodedMessage,
                 protocolRole: 'thread/participant',
@@ -457,11 +453,11 @@ export function testAuthorDelegatedGrant() {
                     recordId: chatRecord.message.recordId
                 }
             });
-            const recordsReadByCarolReply = yield dwn.processMessage(bob.did, recordsReadByCarol.message);
+            const recordsReadByCarolReply = await dwn.processMessage(bob.did, recordsReadByCarol.message);
             expect(recordsReadByCarolReply.status.code).toBe(400);
             expect(recordsQueryByCarolReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantGrantedToAndOwnerSignatureMismatch);
-        }));
-        it('should only allow correct entity invoking an author-delegated grant to subscribe', () => __awaiter(this, void 0, void 0, function* () {
+        });
+        it('should only allow correct entity invoking an author-delegated grant to subscribe', async () => {
             // scenario:
             // 1. Bob installs a chat protocol and creates a thread, adding Alice as a participant.
             // 2. Alice a creates subscribe delegated grant for device X,
@@ -471,30 +467,29 @@ export function testAuthorDelegatedGrant() {
             // 6. The subscription should have received the chat messages.
             // 7. Bob deletes one of the chat messages.
             // 8. The subscription should have received the delete event.
-            var _a;
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const carol = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const carol = await TestDataGenerator.generateDidKeyPersona();
             // Bob has the chat protocol installed
             const protocolDefinition = threadRoleProtocolDefinition;
             const protocol = threadRoleProtocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolsConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // Bob starts a chat thread
-            const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+            const threadRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'thread',
             });
-            const threadRoleReply = yield dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+            const threadRoleReply = await dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
             expect(threadRoleReply.status.code).toBe(202);
             // Bob adds Alice as a participant in the thread
-            const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
+            const participantRoleRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 recipient: alice.did,
                 protocol: protocolDefinition.protocol,
@@ -502,10 +497,10 @@ export function testAuthorDelegatedGrant() {
                 parentContextId: threadRecord.message.contextId,
                 data: new TextEncoder().encode('Alice is my friend'),
             });
-            const participantRoleReply = yield dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
+            const participantRoleReply = await dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
             expect(participantRoleReply.status.code).toBe(202);
             // Alice creates a delegated subscribe grant for device X to act as Alice.
-            const subscribeGrantForDeviceX = yield PermissionsProtocol.createGrant({
+            const subscribeGrantForDeviceX = await PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -518,8 +513,11 @@ export function testAuthorDelegatedGrant() {
             });
             // Create a handler to set or delete the chat record ID in the subscription set depending on the interface method
             const subscriptionChatRecords = new Set();
-            const captureChatRecords = (event) => __awaiter(this, void 0, void 0, function* () {
-                const { message } = event;
+            const captureChatRecords = async (msg) => {
+                if (msg.type !== 'event') {
+                    return;
+                }
+                const { message } = msg.event;
                 if (message.descriptor.method === DwnMethodName.Delete) {
                     const recordId = message.descriptor.recordId;
                     subscriptionChatRecords.delete(recordId);
@@ -528,9 +526,9 @@ export function testAuthorDelegatedGrant() {
                     const recordId = message.recordId;
                     subscriptionChatRecords.add(recordId);
                 }
-            });
+            };
             // control: verify that device X cannot subscribe to the chat thread without the delegated grant
-            const recordsSubscribeByDeviceXWithoutGrant = yield RecordsSubscribe.create({
+            const recordsSubscribeByDeviceXWithoutGrant = await RecordsSubscribe.create({
                 signer: Jws.createSigner(deviceX),
                 protocolRole: 'thread/participant',
                 filter: {
@@ -539,10 +537,10 @@ export function testAuthorDelegatedGrant() {
                     protocolPath: 'thread/chat'
                 }
             });
-            const recordsSubscribeByDeviceXWithoutGrantReply = yield dwn.processMessage(bob.did, recordsSubscribeByDeviceXWithoutGrant.message);
+            const recordsSubscribeByDeviceXWithoutGrantReply = await dwn.processMessage(bob.did, recordsSubscribeByDeviceXWithoutGrant.message);
             expect(recordsSubscribeByDeviceXWithoutGrantReply.status.code).toBe(401, 'device X without grant subscribe');
             // control: verify that Carol cannot subscribe as Alice by invoking the delegated grant granted to Device X
-            const recordsSubscribeByCarol = yield RecordsSubscribe.create({
+            const recordsSubscribeByCarol = await RecordsSubscribe.create({
                 signer: Jws.createSigner(carol),
                 delegatedGrant: subscribeGrantForDeviceX.dataEncodedMessage,
                 protocolRole: 'thread/participant',
@@ -552,11 +550,11 @@ export function testAuthorDelegatedGrant() {
                     protocolPath: 'thread/chat'
                 }
             });
-            const recordsSubscribeByCarolReply = yield dwn.processMessage(bob.did, recordsSubscribeByCarol.message);
+            const recordsSubscribeByCarolReply = await dwn.processMessage(bob.did, recordsSubscribeByCarol.message);
             expect(recordsSubscribeByCarolReply.status.code).toBe(400, 'carol subscribe');
             expect(recordsSubscribeByCarolReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantGrantedToAndOwnerSignatureMismatch);
             // verify device X is able to subscribe the chat message from Bob's DWN using the delegated grant
-            const recordsSubscribeByDeviceX = yield RecordsSubscribe.create({
+            const recordsSubscribeByDeviceX = await RecordsSubscribe.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: subscribeGrantForDeviceX.dataEncodedMessage,
                 protocolRole: 'thread/participant',
@@ -566,84 +564,83 @@ export function testAuthorDelegatedGrant() {
                     protocolPath: 'thread/chat'
                 }
             });
-            const recordsSubscribeByDeviceXReply = yield dwn.processMessage(bob.did, recordsSubscribeByDeviceX.message, {
+            const recordsSubscribeByDeviceXReply = await dwn.processMessage(bob.did, recordsSubscribeByDeviceX.message, {
                 subscriptionHandler: captureChatRecords
             });
             expect(recordsSubscribeByDeviceXReply.status.code).toBe(200, 'subscribe');
             // Bob writes chat messages in the thread
-            const chatRecord1 = yield TestDataGenerator.generateRecordsWrite({
+            const chatRecord1 = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'thread/chat',
                 parentContextId: threadRecord.message.contextId,
             });
-            const chatRecord1Reply = yield dwn.processMessage(bob.did, chatRecord1.message, { dataStream: chatRecord1.dataStream });
+            const chatRecord1Reply = await dwn.processMessage(bob.did, chatRecord1.message, { dataStream: chatRecord1.dataStream });
             expect(chatRecord1Reply.status.code).toBe(202);
-            const chatRecord2 = yield TestDataGenerator.generateRecordsWrite({
+            const chatRecord2 = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'thread/chat',
                 parentContextId: threadRecord.message.contextId,
             });
-            const chatRecord2Reply = yield dwn.processMessage(bob.did, chatRecord2.message, { dataStream: chatRecord2.dataStream });
+            const chatRecord2Reply = await dwn.processMessage(bob.did, chatRecord2.message, { dataStream: chatRecord2.dataStream });
             expect(chatRecord2Reply.status.code).toBe(202);
-            yield Poller.pollUntilSuccessOrTimeout(() => __awaiter(this, void 0, void 0, function* () {
+            await Poller.pollUntilSuccessOrTimeout(async () => {
                 expect(subscriptionChatRecords.size).toBe(2);
                 expect([...subscriptionChatRecords]).toEqual(expect.arrayContaining([chatRecord1.message.recordId, chatRecord2.message.recordId]));
-            }));
-            yield ((_a = recordsSubscribeByDeviceXReply.subscription) === null || _a === void 0 ? void 0 : _a.close());
-        }));
-        it('should only allow correct entity invoking an author-delegated grant to delete', () => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            });
+            await recordsSubscribeByDeviceXReply.subscription?.close();
+        });
+        it('should only allow correct entity invoking an author-delegated grant to delete', async () => {
             // scenario:
             // 1. Bob installs the chat protocol on his DWN and makes Alice an admin
             // 2. Bob starts a chat thread with Carol on his DWN
             // 3. Alice creates a delegated grant for Device X to act as her
             // 4. Carol should not be able to delete a chat message as Alice using Device X's delegated grant
             // 5. Device X should be able to delete a chat message as Alice
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const carol = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const carol = await TestDataGenerator.generateDidKeyPersona();
             // Bob has the chat protocol installed
             const protocolDefinition = threadRoleProtocolDefinition;
             const protocol = threadRoleProtocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolsConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // Bob adds Alice as an admin
-            const globalAdminRecord = yield TestDataGenerator.generateRecordsWrite({
+            const globalAdminRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 recipient: alice.did,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'globalAdmin',
                 data: new TextEncoder().encode('I trust Alice to manage my chat thread'),
             });
-            const globalAdminRecordReply = yield dwn.processMessage(bob.did, globalAdminRecord.message, { dataStream: globalAdminRecord.dataStream });
+            const globalAdminRecordReply = await dwn.processMessage(bob.did, globalAdminRecord.message, { dataStream: globalAdminRecord.dataStream });
             expect(globalAdminRecordReply.status.code).toBe(202);
             // Bob starts a chat thread
-            const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+            const threadRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'thread',
             });
-            const threadRoleReply = yield dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+            const threadRoleReply = await dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
             expect(threadRoleReply.status.code).toBe(202);
             // Bob adds Carol as a participant in the thread
-            const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
+            const participantRoleRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 recipient: carol.did,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'thread/participant',
                 parentContextId: threadRecord.message.contextId
             });
-            const participantRoleReply = yield dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
+            const participantRoleReply = await dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
             expect(participantRoleReply.status.code).toBe(202);
             // Carol writes a chat message in the thread
-            const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+            const chatRecord = await TestDataGenerator.generateRecordsWrite({
                 author: carol,
                 protocolRole: 'thread/participant',
                 protocol: protocolDefinition.protocol,
@@ -651,10 +648,10 @@ export function testAuthorDelegatedGrant() {
                 parentContextId: threadRecord.message.contextId,
                 data: new TextEncoder().encode('A rude message'),
             });
-            const chatRecordReply = yield dwn.processMessage(bob.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+            const chatRecordReply = await dwn.processMessage(bob.did, chatRecord.message, { dataStream: chatRecord.dataStream });
             expect(chatRecordReply.status.code).toBe(202);
             // Alice creates a delegated delete grant for device X to act as Alice.
-            const deleteGrantForDeviceX = yield PermissionsProtocol.createGrant({
+            const deleteGrantForDeviceX = await PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -666,54 +663,53 @@ export function testAuthorDelegatedGrant() {
                 signer: Jws.createSigner(alice)
             });
             // verify Carol is not able to delete Carol's chat message from Bob's DWN
-            const recordsDeleteByCarol = yield RecordsDelete.create({
+            const recordsDeleteByCarol = await RecordsDelete.create({
                 signer: Jws.createSigner(carol),
                 delegatedGrant: deleteGrantForDeviceX.dataEncodedMessage,
                 protocolRole: 'thread/participant',
                 recordId: chatRecord.message.recordId
             });
-            const carolRecordsDeleteReply = yield dwn.processMessage(bob.did, recordsDeleteByCarol.message);
+            const carolRecordsDeleteReply = await dwn.processMessage(bob.did, recordsDeleteByCarol.message);
             expect(carolRecordsDeleteReply.status.code).toBe(400);
             // sanity verify the chat message is still in Bob's DWN
-            const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQueryByBob = await TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocolPath: 'thread/chat' }
             });
-            const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
+            const bobRecordsQueryReply = await dwn.processMessage(bob.did, recordsQueryByBob.message);
             expect(bobRecordsQueryReply.status.code).toBe(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+            expect(bobRecordsQueryReply.entries?.length).toBe(1);
             // verify device X is able to delete Carol's chat message from Bob's DWN
-            const recordsDeleteByDeviceX = yield RecordsDelete.create({
+            const recordsDeleteByDeviceX = await RecordsDelete.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: deleteGrantForDeviceX.dataEncodedMessage,
                 protocolRole: 'globalAdmin',
                 recordId: chatRecord.message.recordId
             });
-            const deviceXRecordsDeleteReply = yield dwn.processMessage(bob.did, recordsDeleteByDeviceX.message);
+            const deviceXRecordsDeleteReply = await dwn.processMessage(bob.did, recordsDeleteByDeviceX.message);
             expect(deviceXRecordsDeleteReply.status.code).toBe(202);
             // sanity verify the chat message is no longer queryable from Bob's DWN
-            const bobRecordsQueryReply2 = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
+            const bobRecordsQueryReply2 = await dwn.processMessage(bob.did, recordsQueryByBob.message);
             expect(bobRecordsQueryReply2.status.code).toBe(200);
-            expect((_b = bobRecordsQueryReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
-        }));
-        it('should not allow entity using a non-delegated grant as an author-delegated grant to invoke write', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            expect(bobRecordsQueryReply2.entries?.length).toBe(0);
+        });
+        it('should not allow entity using a non-delegated grant as an author-delegated grant to invoke write', async () => {
             // scenario:
             // 1. Bob has the message protocol installed
             // 2. Alice creates a non-delegated grant for device X
             // 3. Verify that device X cannot write a `RecordsWrite` message to Bob's DWN as Alice using the non-delegated grant
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Bob has the message protocol installed
             const protocolDefinition = messageProtocolDefinition;
             const protocol = protocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolConfigureReply.status.code).toBe(202);
             // 2. Alice creates a non-delegated grant for device X
             const scope = {
@@ -721,7 +717,7 @@ export function testAuthorDelegatedGrant() {
                 method: DwnMethodName.Write,
                 protocol
             };
-            const deviceXGrant = yield PermissionsProtocol.createGrant({
+            const deviceXGrant = await PermissionsProtocol.createGrant({
                 // delegated   : true, // intentionally commented out to show that this is not a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -731,7 +727,7 @@ export function testAuthorDelegatedGrant() {
             // 3. Verify that device X cannot write a `RecordsWrite` message to Bob's DWN as Alice using the non-delegated grant
             const deviceXData = new TextEncoder().encode('message from device X');
             const deviceXDataStream = DataStream.fromBytes(deviceXData);
-            const messageByDeviceX = yield RecordsWrite.create({
+            const messageByDeviceX = await RecordsWrite.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: deviceXGrant.dataEncodedMessage,
                 protocol,
@@ -740,48 +736,48 @@ export function testAuthorDelegatedGrant() {
                 dataFormat: protocolDefinition.types.message.dataFormats[0],
                 data: deviceXData
             });
-            const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
+            const deviceXWriteReply = await dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
             expect(deviceXWriteReply.status.code).toBe(400);
             expect(deviceXWriteReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantNotADelegatedGrant);
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
-            const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQueryByBob = await TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
-            const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
+            const bobRecordsQueryReply = await dwn.processMessage(bob.did, recordsQueryByBob.message);
             expect(bobRecordsQueryReply.status.code).toBe(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
-        }));
-        it('should not allow entity using a non-delegated grant as an author-delegated grant to invoke read', () => __awaiter(this, void 0, void 0, function* () {
+            expect(bobRecordsQueryReply.entries?.length).toBe(0);
+        });
+        it('should not allow entity using a non-delegated grant as an author-delegated grant to invoke read', async () => {
             // scenario:
             // 1. Bob has the message protocol installed
             // 2. Alice writes a message to Bob's DWN
             // 3. Alice creates a non-delegated read grant for device X
             // 4. Verify that device X cannot read the message from Bob's DWN as Alice using the non-delegated grant
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Bob has the message protocol installed
             const protocolDefinition = messageProtocolDefinition;
             const protocol = protocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolConfigureReply.status.code).toBe(202);
             // 2. Alice writes a message to Bob's DWN
-            const messageByAlice = yield TestDataGenerator.generateRecordsWrite({
+            const messageByAlice = await TestDataGenerator.generateRecordsWrite({
                 author: alice,
                 protocol,
                 protocolPath: 'message',
                 schema: protocolDefinition.types.message.schema,
                 dataFormat: protocolDefinition.types.message.dataFormats[0],
             });
-            const aliceWriteReply = yield dwn.processMessage(bob.did, messageByAlice.message, { dataStream: messageByAlice.dataStream });
+            const aliceWriteReply = await dwn.processMessage(bob.did, messageByAlice.message, { dataStream: messageByAlice.dataStream });
             expect(aliceWriteReply.status.code).toBe(202);
             // 3. Alice creates a non-delegated read grant for device X
-            const deviceXGrant = yield PermissionsProtocol.createGrant({
+            const deviceXGrant = await PermissionsProtocol.createGrant({
                 // delegated   : true, // intentionally commented out to show that this is not a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -793,36 +789,36 @@ export function testAuthorDelegatedGrant() {
                 signer: Jws.createSigner(alice)
             });
             // 4. Verify that device X cannot read the message from Bob's DWN as Alice using the non-delegated grant
-            const recordsReadByDeviceX = yield RecordsRead.create({
+            const recordsReadByDeviceX = await RecordsRead.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: deviceXGrant.dataEncodedMessage,
                 filter: {
                     recordId: messageByAlice.message.recordId
                 }
             });
-            const deviceXReadReply = yield dwn.processMessage(bob.did, recordsReadByDeviceX.message);
+            const deviceXReadReply = await dwn.processMessage(bob.did, recordsReadByDeviceX.message);
             expect(deviceXReadReply.status.code).toBe(400);
             expect(deviceXReadReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantNotADelegatedGrant);
-        }));
-        it('should not allow entity using a non-delegated grant as an author-delegated grant to invoke query', () => __awaiter(this, void 0, void 0, function* () {
+        });
+        it('should not allow entity using a non-delegated grant as an author-delegated grant to invoke query', async () => {
             // scenario:
             // 1. Bob has the message protocol installed
             // 2. Alice creates a non-delegated query grant for device X
             // 3. Verify that device X cannot query Bob's DWN as Alice using the non-delegated grant
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Bob has the message protocol installed
             const protocolDefinition = messageProtocolDefinition;
             const protocol = protocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolConfigureReply.status.code).toBe(202);
             // 2. Alice creates a non-delegated query grant for device X
-            const deviceXGrant = yield PermissionsProtocol.createGrant({
+            const deviceXGrant = await PermissionsProtocol.createGrant({
                 // delegated   : true, // intentionally commented out to show that this is not a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -834,7 +830,7 @@ export function testAuthorDelegatedGrant() {
                 signer: Jws.createSigner(alice)
             });
             // 3. Verify that device X cannot query Bob's DWN as Alice using the non-delegated grant
-            const recordsQueryByDeviceX = yield RecordsQuery.create({
+            const recordsQueryByDeviceX = await RecordsQuery.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: deviceXGrant.dataEncodedMessage,
                 filter: {
@@ -842,42 +838,41 @@ export function testAuthorDelegatedGrant() {
                     protocolPath: 'message'
                 }
             });
-            const deviceXQueryReply = yield dwn.processMessage(bob.did, recordsQueryByDeviceX.message);
+            const deviceXQueryReply = await dwn.processMessage(bob.did, recordsQueryByDeviceX.message);
             expect(deviceXQueryReply.status.code).toBe(400);
             expect(deviceXQueryReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantNotADelegatedGrant);
-        }));
-        it('should not allow entity using a non-delegated grant as an author-delegated grant to invoke delete', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+        });
+        it('should not allow entity using a non-delegated grant as an author-delegated grant to invoke delete', async () => {
             // scenario:
             // 1. Bob has the message protocol installed
             // 2. Alice writes a message to Bob's DWN
             // 3. Alice creates a non-delegated delete grant for device X
             // 4. Verify that device X cannot delete the message from Bob's DWN as Alice using the non-delegated grant
             // 5. Sanity verify the message still exists in Bob's DWN
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Bob has the message protocol installed
             const protocolDefinition = messageProtocolDefinition;
             const protocol = protocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolConfigureReply.status.code).toBe(202);
             // 2. Alice writes a message to Bob's DWN
-            const messageByAlice = yield TestDataGenerator.generateRecordsWrite({
+            const messageByAlice = await TestDataGenerator.generateRecordsWrite({
                 author: alice,
                 protocol,
                 protocolPath: 'message',
                 schema: protocolDefinition.types.message.schema,
                 dataFormat: protocolDefinition.types.message.dataFormats[0],
             });
-            const aliceWriteReply = yield dwn.processMessage(bob.did, messageByAlice.message, { dataStream: messageByAlice.dataStream });
+            const aliceWriteReply = await dwn.processMessage(bob.did, messageByAlice.message, { dataStream: messageByAlice.dataStream });
             expect(aliceWriteReply.status.code).toBe(202);
             // 3. Alice creates a non-delegated delete grant for device X
-            const deviceXGrant = yield PermissionsProtocol.createGrant({
+            const deviceXGrant = await PermissionsProtocol.createGrant({
                 // delegated   : true, // intentionally commented out to show that this is not a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -889,39 +884,39 @@ export function testAuthorDelegatedGrant() {
                 signer: Jws.createSigner(alice)
             });
             // 4. Verify that device X cannot delete the message from Bob's DWN as Alice using the non-delegated grant
-            const recordsDeleteByDeviceX = yield RecordsDelete.create({
+            const recordsDeleteByDeviceX = await RecordsDelete.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: deviceXGrant.dataEncodedMessage,
                 recordId: messageByAlice.message.recordId
             });
-            const deviceXDeleteReply = yield dwn.processMessage(bob.did, recordsDeleteByDeviceX.message);
+            const deviceXDeleteReply = await dwn.processMessage(bob.did, recordsDeleteByDeviceX.message);
             expect(deviceXDeleteReply.status.code).toBe(400);
             expect(deviceXDeleteReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantNotADelegatedGrant);
             // 5. Sanity verify the message still exists in Bob's DWN
-            const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQueryByBob = await TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
-            const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
+            const bobRecordsQueryReply = await dwn.processMessage(bob.did, recordsQueryByBob.message);
             expect(bobRecordsQueryReply.status.code).toBe(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
-        }));
-        it('should fail if author-delegated grant has a mismatching protocol scope - write', () => __awaiter(this, void 0, void 0, function* () {
+            expect(bobRecordsQueryReply.entries?.length).toBe(1);
+        });
+        it('should fail if author-delegated grant has a mismatching protocol scope - write', async () => {
             // scenario:
             // 1. Alice creates a delegated grant for device X to act as her for a protocol that is NOT email protocol
             // 2. Bob has email protocol configured for his DWN that allows anyone to write an email to him
             // 3. Device X attempts to use the delegated grant to write an email to Bob as Alice
             // 4. Bob's DWN should reject Device X's message
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
             // 1. Alice creates a delegated grant for device X to act as her for a protocol that is NOT email protocol
             const scope = {
                 interface: DwnInterfaceName.Records,
                 method: DwnMethodName.Write,
                 protocol: 'random-protocol'
             };
-            const deviceXGrant = yield PermissionsProtocol.createGrant({
+            const deviceXGrant = await PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -931,16 +926,16 @@ export function testAuthorDelegatedGrant() {
             // 2. Bob has email protocol configured for his DWN that allows anyone to write an email to him
             const protocolDefinition = emailProtocolDefinition;
             const protocol = protocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolConfigureReply.status.code).toBe(202);
             // 3. Device X attempts to use the delegated grant to write an email to Bob as Alice
             const deviceXData = new TextEncoder().encode('message from device X');
             const deviceXDataStream = DataStream.fromBytes(deviceXData);
-            const messageByDeviceX = yield RecordsWrite.create({
+            const messageByDeviceX = await RecordsWrite.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: deviceXGrant.dataEncodedMessage,
                 protocol,
@@ -949,38 +944,38 @@ export function testAuthorDelegatedGrant() {
                 dataFormat: protocolDefinition.types.email.dataFormats[0],
                 data: deviceXData
             });
-            const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
+            const deviceXWriteReply = await dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
             expect(deviceXWriteReply.status.code).toBe(401);
             expect(deviceXWriteReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolMismatch);
-        }));
-        it('should fail if author-delegated grant has a mismatching protocol scope - query, subscribe & read', () => __awaiter(this, void 0, void 0, function* () {
+        });
+        it('should fail if author-delegated grant has a mismatching protocol scope - query, subscribe & read', async () => {
             // scenario:
             // 1. Bob starts a chat thread with Alice on his DWN
             // 2. Alice creates a delegated grant for device X to act as her for a protocol that is NOT chat protocol
             // 3. Device X attempts to use the delegated grant to read, query and subscribe to the chat thread and gets rejected by Bob's DWN
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
             // 1. Bob starts a chat thread with Alice on his DWN
             // Bob has the chat protocol installed
             const protocolDefinition = threadRoleProtocolDefinition;
             const protocol = threadRoleProtocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolsConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // Bob starts a chat thread
-            const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+            const threadRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'thread',
             });
-            const threadRoleReply = yield dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+            const threadRoleReply = await dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
             expect(threadRoleReply.status.code).toBe(202);
             // Bob adds Alice as a participant in the thread
-            const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
+            const participantRoleRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 recipient: alice.did,
                 protocol: protocolDefinition.protocol,
@@ -988,20 +983,20 @@ export function testAuthorDelegatedGrant() {
                 parentContextId: threadRecord.message.contextId,
                 data: new TextEncoder().encode('Alice is my friend'),
             });
-            const participantRoleReply = yield dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
+            const participantRoleReply = await dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
             expect(participantRoleReply.status.code).toBe(202);
             // Bob writes a chat message in the thread
-            const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+            const chatRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'thread/chat',
                 parentContextId: threadRecord.message.contextId,
             });
-            const chatRecordReply = yield dwn.processMessage(bob.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+            const chatRecordReply = await dwn.processMessage(bob.did, chatRecord.message, { dataStream: chatRecord.dataStream });
             expect(chatRecordReply.status.code).toBe(202);
             // 2. Alice creates a delegated grant for device X to act as her for a protocol that is NOT chat protocol
             // Alice creates a delegated query grant for device X to act as Alice but not for chat protocol
-            const queryGrantForDeviceX = yield PermissionsProtocol.createGrant({
+            const queryGrantForDeviceX = await PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -1013,7 +1008,7 @@ export function testAuthorDelegatedGrant() {
                 signer: Jws.createSigner(alice)
             });
             // Alice creates a delegated read grant for device X to act as Alice but not for chat protocol
-            const readGrantForDeviceX = yield PermissionsProtocol.createGrant({
+            const readGrantForDeviceX = await PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -1025,7 +1020,7 @@ export function testAuthorDelegatedGrant() {
                 signer: Jws.createSigner(alice)
             });
             // Alice creates a delegated subscribe grant for device X to act as Alice but not for chat protocol
-            const subscribeGrantForDeviceX = yield PermissionsProtocol.createGrant({
+            const subscribeGrantForDeviceX = await PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -1038,7 +1033,7 @@ export function testAuthorDelegatedGrant() {
             });
             // 3. Device X attempts to use the delegated grant to read, query and subscribe to the chat thread and gets rejected by Bob's DWN
             // verify device X querying for the chat message from Bob's DWN fails
-            const recordsQueryByDeviceX = yield RecordsQuery.create({
+            const recordsQueryByDeviceX = await RecordsQuery.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: queryGrantForDeviceX.dataEncodedMessage,
                 protocolRole: 'thread/participant',
@@ -1048,11 +1043,11 @@ export function testAuthorDelegatedGrant() {
                     protocolPath: 'thread/chat'
                 }
             });
-            const deviceXRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByDeviceX.message);
+            const deviceXRecordsQueryReply = await dwn.processMessage(bob.did, recordsQueryByDeviceX.message);
             expect(deviceXRecordsQueryReply.status.code).toBe(401);
             expect(deviceXRecordsQueryReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationQueryOrSubscribeProtocolScopeMismatch);
             // verify device X reading for the chat message from Bob's DWN fails
-            const recordsReadByDeviceX = yield RecordsRead.create({
+            const recordsReadByDeviceX = await RecordsRead.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: readGrantForDeviceX.dataEncodedMessage,
                 protocolRole: 'thread/participant',
@@ -1060,11 +1055,11 @@ export function testAuthorDelegatedGrant() {
                     recordId: chatRecord.message.recordId
                 }
             });
-            const deviceXReadReply = yield dwn.processMessage(bob.did, recordsReadByDeviceX.message);
+            const deviceXReadReply = await dwn.processMessage(bob.did, recordsReadByDeviceX.message);
             expect(deviceXReadReply.status.code).toBe(401);
             expect(deviceXReadReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolMismatch);
             // verify device X subscribing to the chat message from Bob's DWN fails
-            const recordsSubscribeByDeviceX = yield RecordsSubscribe.create({
+            const recordsSubscribeByDeviceX = await RecordsSubscribe.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: subscribeGrantForDeviceX.dataEncodedMessage,
                 protocolRole: 'thread/participant',
@@ -1074,59 +1069,58 @@ export function testAuthorDelegatedGrant() {
                     protocolPath: 'thread/chat'
                 }
             });
-            const deviceXRecordsSubscribeReply = yield dwn.processMessage(bob.did, recordsSubscribeByDeviceX.message);
+            const deviceXRecordsSubscribeReply = await dwn.processMessage(bob.did, recordsSubscribeByDeviceX.message);
             expect(deviceXRecordsSubscribeReply.status.code).toBe(401);
             expect(deviceXRecordsSubscribeReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationQueryOrSubscribeProtocolScopeMismatch);
-        }));
-        it('should fail if author-delegated grant has a mismatching protocol scope - delete', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+        });
+        it('should fail if author-delegated grant has a mismatching protocol scope - delete', async () => {
             // scenario:
             // 1. Bob installs the chat protocol on his DWN and makes Alice an admin
             // 2. Bob starts a chat thread with Carol on his DWN
             // 3. Alice creates a delegated delete grant for Device X to act as her for a protocol that is NOT chat protocol
             // 4. Device X should NOT be able to delete a chat message as Alice
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const carol = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const carol = await TestDataGenerator.generateDidKeyPersona();
             // Bob has the chat protocol installed
             const protocolDefinition = threadRoleProtocolDefinition;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolsConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // Bob adds Alice as an admin
-            const globalAdminRecord = yield TestDataGenerator.generateRecordsWrite({
+            const globalAdminRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 recipient: alice.did,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'globalAdmin',
                 data: new TextEncoder().encode('I trust Alice to manage my chat thread'),
             });
-            const globalAdminRecordReply = yield dwn.processMessage(bob.did, globalAdminRecord.message, { dataStream: globalAdminRecord.dataStream });
+            const globalAdminRecordReply = await dwn.processMessage(bob.did, globalAdminRecord.message, { dataStream: globalAdminRecord.dataStream });
             expect(globalAdminRecordReply.status.code).toBe(202);
             // Bob starts a chat thread
-            const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+            const threadRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'thread',
             });
-            const threadRoleReply = yield dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+            const threadRoleReply = await dwn.processMessage(bob.did, threadRecord.message, { dataStream: threadRecord.dataStream });
             expect(threadRoleReply.status.code).toBe(202);
             // Bob adds Carol as a participant in the thread
-            const participantRoleRecord = yield TestDataGenerator.generateRecordsWrite({
+            const participantRoleRecord = await TestDataGenerator.generateRecordsWrite({
                 author: bob,
                 recipient: carol.did,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'thread/participant',
                 parentContextId: threadRecord.message.contextId
             });
-            const participantRoleReply = yield dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
+            const participantRoleReply = await dwn.processMessage(bob.did, participantRoleRecord.message, { dataStream: participantRoleRecord.dataStream });
             expect(participantRoleReply.status.code).toBe(202);
             // Carol writes a chat message in the thread
-            const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+            const chatRecord = await TestDataGenerator.generateRecordsWrite({
                 author: carol,
                 protocolRole: 'thread/participant',
                 protocol: protocolDefinition.protocol,
@@ -1134,10 +1128,10 @@ export function testAuthorDelegatedGrant() {
                 parentContextId: threadRecord.message.contextId,
                 data: new TextEncoder().encode('A rude message'),
             });
-            const chatRecordReply = yield dwn.processMessage(bob.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+            const chatRecordReply = await dwn.processMessage(bob.did, chatRecord.message, { dataStream: chatRecord.dataStream });
             expect(chatRecordReply.status.code).toBe(202);
             // Alice creates a delegated delete grant for Device X to act as her for a protocol that is NOT chat protocol
-            const delegatedGrantForDeviceX = yield PermissionsProtocol.createGrant({
+            const delegatedGrantForDeviceX = await PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -1149,42 +1143,41 @@ export function testAuthorDelegatedGrant() {
                 signer: Jws.createSigner(alice)
             });
             // verify device X is NOT able to delete Carol's chat message from Bob's DWN
-            const recordsDeleteByDeviceX = yield RecordsDelete.create({
+            const recordsDeleteByDeviceX = await RecordsDelete.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: delegatedGrantForDeviceX.dataEncodedMessage,
                 protocolRole: 'globalAdmin',
                 recordId: chatRecord.message.recordId
             });
-            const deviceXRecordsDeleteReply = yield dwn.processMessage(bob.did, recordsDeleteByDeviceX.message);
+            const deviceXRecordsDeleteReply = await dwn.processMessage(bob.did, recordsDeleteByDeviceX.message);
             expect(deviceXRecordsDeleteReply.status.code).toBe(401);
             expect(deviceXRecordsDeleteReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationDeleteProtocolScopeMismatch);
             // sanity verify the chat message is still in Bob's DWN
-            const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQueryByBob = await TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocolPath: 'thread/chat' }
             });
-            const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
+            const bobRecordsQueryReply = await dwn.processMessage(bob.did, recordsQueryByBob.message);
             expect(bobRecordsQueryReply.status.code).toBe(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
-        }));
-        it('should fail if presented with an author-delegated grant with invalid grantor signature - write', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            expect(bobRecordsQueryReply.entries?.length).toBe(1);
+        });
+        it('should fail if presented with an author-delegated grant with invalid grantor signature - write', async () => {
             // scenario:
             // 1. Bob has the message protocol installed
             // 2. Alice creates a delegated grant for device X to write as Alice, but with invalid signature
             // 3. Verify that device X cannot write a `RecordsWrite` message to Bob's DWN as Alice using the delegated grant with invalid grantor signature
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Bob has the message protocol installed
             const protocolDefinition = messageProtocolDefinition;
             const protocol = protocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolConfigureReply.status.code).toBe(202);
             // 2. Alice creates a delegated grant for device X to write as Alice, but with invalid signature
             const scope = {
@@ -1192,7 +1185,7 @@ export function testAuthorDelegatedGrant() {
                 method: DwnMethodName.Write,
                 protocol
             };
-            const deviceXGrant = yield PermissionsProtocol.createGrant({
+            const deviceXGrant = await PermissionsProtocol.createGrant({
                 delegated: true,
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -1200,11 +1193,11 @@ export function testAuthorDelegatedGrant() {
                 signer: Jws.createSigner(alice)
             });
             const deviceXGrantMessage = deviceXGrant.dataEncodedMessage;
-            deviceXGrantMessage.authorization.signature.signatures[0].signature = yield TestDataGenerator.randomSignatureString();
+            deviceXGrantMessage.authorization.signature.signatures[0].signature = await TestDataGenerator.randomSignatureString();
             // 3. Verify that device X cannot write a `RecordsWrite` message to Bob's DWN as Alice using the delegated grant with invalid grantor signature
             const deviceXData = new TextEncoder().encode('message from device X');
             const deviceXDataStream = DataStream.fromBytes(deviceXData);
-            const messageByDeviceX = yield RecordsWrite.create({
+            const messageByDeviceX = await RecordsWrite.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: deviceXGrantMessage,
                 protocol,
@@ -1213,36 +1206,35 @@ export function testAuthorDelegatedGrant() {
                 dataFormat: protocolDefinition.types.message.dataFormats[0],
                 data: deviceXData
             });
-            const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
+            const deviceXWriteReply = await dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
             expect(deviceXWriteReply.status.code).toBe(401);
             expect(deviceXWriteReply.status.detail).toContain(DwnErrorCode.GeneralJwsVerifierInvalidSignature);
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
-            const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQueryByBob = await TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
-            const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
+            const bobRecordsQueryReply = await dwn.processMessage(bob.did, recordsQueryByBob.message);
             expect(bobRecordsQueryReply.status.code).toBe(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
-        }));
-        it('should fail if the CID of the author-delegated grant and the grant ID in the payload of the message signature is mismatching - write', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            expect(bobRecordsQueryReply.entries?.length).toBe(0);
+        });
+        it('should fail if the CID of the author-delegated grant and the grant ID in the payload of the message signature is mismatching - write', async () => {
             // scenario:
             // 1. Bob has the message protocol installed
             // 2. Alice creates two delegated grants for device X to write as Alice
             // 3. Verify that device X cannot write a `RecordsWrite` message to Bob's DWN as Alice using a mismatching delegated grant ID
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Bob has the message protocol installed
             const protocolDefinition = messageProtocolDefinition;
             const protocol = protocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolConfigureReply.status.code).toBe(202);
             // 2. Alice creates two delegated grants for device X to write as Alice
             const scope = {
@@ -1250,15 +1242,15 @@ export function testAuthorDelegatedGrant() {
                 method: DwnMethodName.Write,
                 protocol
             };
-            const deviceXGrant = yield PermissionsProtocol.createGrant({
+            const deviceXGrant = await PermissionsProtocol.createGrant({
                 delegated: true,
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
                 scope: scope,
                 signer: Jws.createSigner(alice)
             });
-            yield Time.minimalSleep();
-            const deviceXGrant2 = yield PermissionsProtocol.createGrant({
+            await Time.minimalSleep();
+            const deviceXGrant2 = await PermissionsProtocol.createGrant({
                 delegated: true,
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -1268,7 +1260,7 @@ export function testAuthorDelegatedGrant() {
             // 3. Verify that device X cannot write a `RecordsWrite` message to Bob's DWN as Alice using a mismatching delegated grant ID
             const deviceXData = new TextEncoder().encode('message from device X');
             const deviceXDataStream = DataStream.fromBytes(deviceXData);
-            const messageByDeviceX = yield RecordsWrite.create({
+            const messageByDeviceX = await RecordsWrite.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: deviceXGrant.dataEncodedMessage,
                 protocol,
@@ -1278,37 +1270,36 @@ export function testAuthorDelegatedGrant() {
                 data: deviceXData
             });
             messageByDeviceX.message.authorization.authorDelegatedGrant = deviceXGrant2.dataEncodedMessage; // intentionally have a mismatching grant
-            const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
+            const deviceXWriteReply = await dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
             expect(deviceXWriteReply.status.code).toBe(400);
             expect(deviceXWriteReply.status.detail).toContain(DwnErrorCode.RecordsAuthorDelegatedGrantCidMismatch);
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
-            const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQueryByBob = await TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
-            const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
+            const bobRecordsQueryReply = await dwn.processMessage(bob.did, recordsQueryByBob.message);
             expect(bobRecordsQueryReply.status.code).toBe(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
-        }));
-        it('should fail if author-delegated grant is revoked - write', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            expect(bobRecordsQueryReply.entries?.length).toBe(0);
+        });
+        it('should fail if author-delegated grant is revoked - write', async () => {
             // scenario:
             // 1. Bob has the message protocol installed
             // 2. Alice creates a delegated grant for device X to write as Alice
             // 3. Alice revokes the grant
             // 4. Verify that device X cannot write a `RecordsWrite` message to Bob's DWN as Alice using a revoked delegated grant
             // 5. Sanity verify the message by device X did not get written to Bob's DWN
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Bob has the message protocol installed
             const protocolDefinition = messageProtocolDefinition;
             const protocol = protocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolConfigureReply.status.code).toBe(202);
             // 2. Alice creates a delegated grant for device X to write as Alice
             const scope = {
@@ -1316,7 +1307,7 @@ export function testAuthorDelegatedGrant() {
                 method: DwnMethodName.Write,
                 protocol
             };
-            const deviceXGrant = yield PermissionsProtocol.createGrant({
+            const deviceXGrant = await PermissionsProtocol.createGrant({
                 delegated: true,
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: deviceX.did,
@@ -1324,20 +1315,20 @@ export function testAuthorDelegatedGrant() {
                 signer: Jws.createSigner(alice)
             });
             const deviceXGrantDataStream = DataStream.fromBytes(deviceXGrant.permissionGrantBytes);
-            const permissionGrantWriteReply = yield dwn.processMessage(alice.did, deviceXGrant.recordsWrite.message, { dataStream: deviceXGrantDataStream });
+            const permissionGrantWriteReply = await dwn.processMessage(alice.did, deviceXGrant.recordsWrite.message, { dataStream: deviceXGrantDataStream });
             expect(permissionGrantWriteReply.status.code).toBe(202);
             // 3. Alice revokes the grant
-            const permissionRevoke = yield PermissionsProtocol.createRevocation({
+            const permissionRevoke = await PermissionsProtocol.createRevocation({
                 signer: Jws.createSigner(alice),
-                grant: yield PermissionGrant.parse(deviceXGrant.dataEncodedMessage),
+                grant: PermissionGrant.parse(deviceXGrant.dataEncodedMessage),
             });
             const revocationDataStream = DataStream.fromBytes(permissionRevoke.permissionRevocationBytes);
-            const permissionRevokeReply = yield dwn.processMessage(alice.did, permissionRevoke.recordsWrite.message, { dataStream: revocationDataStream });
+            const permissionRevokeReply = await dwn.processMessage(alice.did, permissionRevoke.recordsWrite.message, { dataStream: revocationDataStream });
             expect(permissionRevokeReply.status.code).toBe(202);
             // 3. Verify that device X cannot write a `RecordsWrite` message to Bob's DWN as Alice using a mismatching delegated grant ID
             const deviceXData = new TextEncoder().encode('message from device X');
             const deviceXDataStream = DataStream.fromBytes(deviceXData);
-            const messageByDeviceX = yield RecordsWrite.create({
+            const messageByDeviceX = await RecordsWrite.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: deviceXGrant.dataEncodedMessage,
                 protocol,
@@ -1346,36 +1337,35 @@ export function testAuthorDelegatedGrant() {
                 dataFormat: protocolDefinition.types.message.dataFormats[0],
                 data: deviceXData
             });
-            const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
+            const deviceXWriteReply = await dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
             expect(deviceXWriteReply.status.code).toBe(401);
             expect(deviceXWriteReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationGrantRevoked);
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
-            const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQueryByBob = await TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
-            const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
+            const bobRecordsQueryReply = await dwn.processMessage(bob.did, recordsQueryByBob.message);
             expect(bobRecordsQueryReply.status.code).toBe(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
-        }));
-        it('should fail if author-delegated grant is expired - write', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            expect(bobRecordsQueryReply.entries?.length).toBe(0);
+        });
+        it('should fail if author-delegated grant is expired - write', async () => {
             // scenario:
             // 1. Bob has the message protocol installed
             // 2. Alice creates a delegated grant for device X to write as Alice, but make it expired
             // 3. Verify that device X cannot write a `RecordsWrite` message to Bob's DWN as Alice using an expired delegated grant
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const deviceX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const deviceX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Bob has the message protocol installed
             const protocolDefinition = messageProtocolDefinition;
             const protocol = protocolDefinition.protocol;
-            const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+            const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                 author: bob,
                 protocolDefinition
             });
-            const protocolConfigureReply = yield dwn.processMessage(bob.did, protocolsConfig.message);
+            const protocolConfigureReply = await dwn.processMessage(bob.did, protocolsConfig.message);
             expect(protocolConfigureReply.status.code).toBe(202);
             // 2. Alice creates a delegated grant for device X to write as Alice, but make it expired
             const scope = {
@@ -1383,7 +1373,7 @@ export function testAuthorDelegatedGrant() {
                 method: DwnMethodName.Write,
                 protocol
             };
-            const deviceXGrant = yield PermissionsProtocol.createGrant({
+            const deviceXGrant = await PermissionsProtocol.createGrant({
                 delegated: true,
                 dateExpires: Time.getCurrentTimestamp(), // intentionally set to current time to make it expired immediately
                 grantedTo: deviceX.did,
@@ -1393,7 +1383,7 @@ export function testAuthorDelegatedGrant() {
             // 3. Verify that device X cannot write a `RecordsWrite` message to Bob's DWN as Alice using an expired delegated grant
             const deviceXData = new TextEncoder().encode('message from device X');
             const deviceXDataStream = DataStream.fromBytes(deviceXData);
-            const messageByDeviceX = yield RecordsWrite.create({
+            const messageByDeviceX = await RecordsWrite.create({
                 signer: Jws.createSigner(deviceX),
                 delegatedGrant: deviceXGrant.dataEncodedMessage,
                 protocol,
@@ -1402,18 +1392,18 @@ export function testAuthorDelegatedGrant() {
                 dataFormat: protocolDefinition.types.message.dataFormats[0],
                 data: deviceXData
             });
-            const deviceXWriteReply = yield dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
+            const deviceXWriteReply = await dwn.processMessage(bob.did, messageByDeviceX.message, { dataStream: deviceXDataStream });
             expect(deviceXWriteReply.status.code).toBe(401);
             expect(deviceXWriteReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationGrantExpired);
             // 4. Sanity verify the message by device X did not get written to Bob's DWN
-            const recordsQueryByBob = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQueryByBob = await TestDataGenerator.generateRecordsQuery({
                 author: bob,
                 filter: { protocol }
             });
-            const bobRecordsQueryReply = yield dwn.processMessage(bob.did, recordsQueryByBob.message);
+            const bobRecordsQueryReply = await dwn.processMessage(bob.did, recordsQueryByBob.message);
             expect(bobRecordsQueryReply.status.code).toBe(200);
-            expect((_a = bobRecordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
-        }));
+            expect(bobRecordsQueryReply.entries?.length).toBe(0);
+        });
     });
 }
 //# sourceMappingURL=author-delegated-grant.spec.js.map