@enbox/dwn-sdk-js 0.0.6 → 0.0.8

package/dist/esm/tests/features/permissions.spec.js

@@ -1,12 +1,4 @@
-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 minimalProtocolDefinition from '../vectors/protocol-definitions/minimal.json' with { type: 'json' };
 import sinon from 'sinon';
 import { DataStream } from '../../src/utils/data-stream.js';
 import { Dwn } from '../../src/dwn.js';
@@ -16,7 +8,7 @@ import { PermissionsProtocol } from '../../src/protocols/permissions.js';
 import { RecordsRead } from '../../src/interfaces/records-read.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 { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import { DidKey, UniversalResolver } from '@enbox/dids';
@@ -28,37 +20,37 @@ export function testPermissions() {
         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* () {
+            await messageStore.clear();
+            await dataStore.clear();
+            await resumableTaskStore.clear();
+            await stateIndex.clear();
+        });
+        afterAll(async () => {
             sinon.restore();
-            yield dwn.close();
-        }));
-        it('should include record tags using the createRequest, createGrant and createRevocation if provided', () => __awaiter(this, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
+            await dwn.close();
+        });
+        it('should include record tags using the createRequest, createGrant and createRevocation if provided', async () => {
+            const alice = await TestDataGenerator.generateDidKeyPersona();
             const testProtocol = 'https://example.com/protocol/test';
             // createRequest with a protocol
-            const requestWrite = yield PermissionsProtocol.createRequest({
+            const requestWrite = await PermissionsProtocol.createRequest({
                 signer: Jws.createSigner(alice),
                 description: 'Requesting to write',
                 delegated: false,
@@ -70,7 +62,7 @@ export function testPermissions() {
             });
             expect(requestWrite.recordsWrite.message.descriptor.tags).toEqual({ protocol: testProtocol });
             // createGrant with a protocol
-            const grantWrite = yield PermissionsProtocol.createGrant({
+            const grantWrite = await PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 description: 'Allow Bob to write',
@@ -83,18 +75,18 @@ export function testPermissions() {
             });
             expect(grantWrite.recordsWrite.message.descriptor.tags).toEqual({ protocol: testProtocol });
             // createRevocation with a protocol derived from the grant
-            const revokeWrite = yield PermissionsProtocol.createRevocation({
+            const revokeWrite = await PermissionsProtocol.createRevocation({
                 signer: Jws.createSigner(alice),
-                grant: yield PermissionGrant.parse(grantWrite.dataEncodedMessage),
+                grant: PermissionGrant.parse(grantWrite.dataEncodedMessage),
                 dateRevoked: Time.getCurrentTimestamp()
             });
             expect(revokeWrite.recordsWrite.message.descriptor.tags).toEqual({ protocol: testProtocol });
-        }));
-        it('should normalize the protocol URL in the scope of a Request, Grant, and Revocation', () => __awaiter(this, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
+        });
+        it('should normalize the protocol URL in the scope of a Request, Grant, and Revocation', async () => {
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
             // createRequest with a protocol that will be normalized to `http://any-protocol`
-            const requestWrite = yield PermissionsProtocol.createRequest({
+            const requestWrite = await PermissionsProtocol.createRequest({
                 signer: Jws.createSigner(bob),
                 description: 'Requesting to write',
                 delegated: false,
@@ -106,7 +98,7 @@ export function testPermissions() {
             });
             expect(requestWrite.recordsWrite.message.descriptor.tags).toEqual({ protocol: 'http://any-protocol' });
             // createRequest with a protocol that is already normalized to `https://any-protocol`
-            const requestWrite2 = yield PermissionsProtocol.createRequest({
+            const requestWrite2 = await PermissionsProtocol.createRequest({
                 signer: Jws.createSigner(bob),
                 description: 'Requesting to write',
                 delegated: false,
@@ -118,7 +110,7 @@ export function testPermissions() {
             });
             expect(requestWrite2.recordsWrite.message.descriptor.tags).toEqual({ protocol: 'https://any-protocol' });
             // createGrant with a protocol that will be normalized to `http://any-protocol`
-            const grantWrite = yield PermissionsProtocol.createGrant({
+            const grantWrite = await PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 description: 'Allow Bob to write',
@@ -131,7 +123,7 @@ export function testPermissions() {
             });
             expect(grantWrite.recordsWrite.message.descriptor.tags).toEqual({ protocol: 'http://any-protocol' });
             // createGrant with a protocol that is already normalized to `https://any-protocol`
-            const grantWrite2 = yield PermissionsProtocol.createGrant({
+            const grantWrite2 = await PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 description: 'Allow Bob to write',
@@ -143,13 +135,13 @@ export function testPermissions() {
                 }
             });
             expect(grantWrite2.recordsWrite.message.descriptor.tags).toEqual({ protocol: 'https://any-protocol' });
-        }));
-        it('should derive the grantId and protocol from the grant record when creating a revocation', () => __awaiter(this, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
+        });
+        it('should derive the grantId and protocol from the grant record when creating a revocation', async () => {
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
             const grantProtocol = 'https://example.com/protocol/test';
             // alice creates a grant for bob
-            const grantWrite = yield PermissionsProtocol.createGrant({
+            const grantWrite = await PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 description: 'Allow Bob to write',
@@ -160,22 +152,22 @@ export function testPermissions() {
                     protocol: grantProtocol,
                 }
             });
-            const grantWriteReply = yield dwn.processMessage(alice.did, grantWrite.recordsWrite.message, {
+            const grantWriteReply = await dwn.processMessage(alice.did, grantWrite.recordsWrite.message, {
                 dataStream: DataStream.fromBytes(grantWrite.permissionGrantBytes)
             });
             expect(grantWriteReply.status.code).toBe(202);
             // derive the grantId and protocol from the grant record
-            const revokeWrite = yield PermissionsProtocol.createRevocation({
+            const revokeWrite = await PermissionsProtocol.createRevocation({
                 signer: Jws.createSigner(alice),
-                grant: yield PermissionGrant.parse(grantWrite.dataEncodedMessage),
+                grant: PermissionGrant.parse(grantWrite.dataEncodedMessage),
                 dateRevoked: Time.getCurrentTimestamp()
             });
             // check that the protocol is in the revocation record's tags
             expect(revokeWrite.recordsWrite.message.descriptor.tags).toEqual({ protocol: grantProtocol });
             // check that the revocation's parentId is the grant's recordId
             expect(revokeWrite.recordsWrite.message.descriptor.parentId).toBe(grantWrite.recordsWrite.message.recordId);
-        }));
-        it('should support permission management through use of Request, Grants, and Revocations', () => __awaiter(this, void 0, void 0, function* () {
+        });
+        it('should support permission management through use of Request, Grants, and Revocations', async () => {
             // scenario:
             // 1. Verify anyone (Bob) can send a permission request to Alice
             // 2. Alice queries her DWN for new permission requests
@@ -186,25 +178,24 @@ export function testPermissions() {
             // 7. Verify that non-owner cannot revoke the grant
             // 8. Alice revokes the permission grant for Bob
             // 9. Verify that any third-party can fetch the revocation status of the permission grant
-            var _a, _b, _c, _d, _e;
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
             // 1. Verify anyone (Bob) can send a permission request to Alice
             const permissionScope = {
                 interface: DwnInterfaceName.Records,
                 method: DwnMethodName.Write,
                 protocol: `any-protocol`
             };
-            const requestToAlice = yield PermissionsProtocol.createRequest({
+            const requestToAlice = await PermissionsProtocol.createRequest({
                 signer: Jws.createSigner(bob),
                 description: `Requesting to write to Alice's DWN`,
                 delegated: false,
                 scope: permissionScope
             });
-            const requestWriteReply = yield dwn.processMessage(alice.did, requestToAlice.recordsWrite.message, { dataStream: DataStream.fromBytes(requestToAlice.permissionRequestBytes) });
+            const requestWriteReply = await dwn.processMessage(alice.did, requestToAlice.recordsWrite.message, { dataStream: DataStream.fromBytes(requestToAlice.permissionRequestBytes) });
             expect(requestWriteReply.status.code).toBe(202);
             // 2. Alice queries her DWN for new permission requests
-            const requestQuery = yield RecordsQuery.create({
+            const requestQuery = await RecordsQuery.create({
                 signer: Jws.createSigner(alice),
                 filter: {
                     protocolPath: PermissionsProtocol.requestPath,
@@ -212,35 +203,35 @@ export function testPermissions() {
                     dateUpdated: { from: Time.createOffsetTimestamp({ seconds: -1 * 60 * 60 * 24 }) } // last 24 hours
                 }
             });
-            const requestQueryReply = yield dwn.processMessage(alice.did, requestQuery.message);
-            const requestFromBob = (_a = requestQueryReply.entries) === null || _a === void 0 ? void 0 : _a[0];
+            const requestQueryReply = await dwn.processMessage(alice.did, requestQuery.message);
+            const requestFromBob = requestQueryReply.entries?.[0];
             expect(requestQueryReply.status.code).toBe(200);
-            expect((_b = requestQueryReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+            expect(requestQueryReply.entries?.length).toBe(1);
             expect(requestFromBob.recordId).toBe(requestToAlice.recordsWrite.message.recordId);
             // 3. Verify a non-owner cannot create a grant for Bob in Alice's DWN
             const decodedRequest = PermissionsProtocol.parseRequest(requestFromBob.encodedData);
-            const unauthorizedGrantWrite = yield PermissionsProtocol.createGrant({
+            const unauthorizedGrantWrite = await PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(bob),
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 description: 'Allow Bob to write',
                 grantedTo: bob.did,
                 scope: decodedRequest.scope
             });
-            const unauthorizedGrantWriteReply = yield dwn.processMessage(alice.did, unauthorizedGrantWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(unauthorizedGrantWrite.permissionGrantBytes) });
+            const unauthorizedGrantWriteReply = await dwn.processMessage(alice.did, unauthorizedGrantWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(unauthorizedGrantWrite.permissionGrantBytes) });
             expect(unauthorizedGrantWriteReply.status.code).toBe(401);
             expect(unauthorizedGrantWriteReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
             // 4. Alice creates a permission grant for Bob in her DWN
-            const grantWrite = yield PermissionsProtocol.createGrant({
+            const grantWrite = await PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 description: 'Allow Bob to write',
                 grantedTo: bob.did,
                 scope: decodedRequest.scope
             });
-            const grantWriteReply = yield dwn.processMessage(alice.did, grantWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(grantWrite.permissionGrantBytes) });
+            const grantWriteReply = await dwn.processMessage(alice.did, grantWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(grantWrite.permissionGrantBytes) });
             expect(grantWriteReply.status.code).toBe(202);
             // 5. Verify that Bob can query the permission grant from Alice's DWN (even though Alice can also send it directly to Bob)
-            const grantQuery = yield RecordsQuery.create({
+            const grantQuery = await RecordsQuery.create({
                 signer: Jws.createSigner(bob),
                 filter: {
                     protocolPath: PermissionsProtocol.grantPath,
@@ -248,46 +239,46 @@ export function testPermissions() {
                     dateUpdated: { from: Time.createOffsetTimestamp({ seconds: -1 * 60 * 60 * 24 }) } // last 24 hours
                 }
             });
-            const grantQueryReply = yield dwn.processMessage(alice.did, grantQuery.message);
-            const grantFromBob = (_c = grantQueryReply.entries) === null || _c === void 0 ? void 0 : _c[0];
+            const grantQueryReply = await dwn.processMessage(alice.did, grantQuery.message);
+            const grantFromBob = grantQueryReply.entries?.[0];
             expect(grantQueryReply.status.code).toBe(200);
-            expect((_d = grantQueryReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(1);
+            expect(grantQueryReply.entries?.length).toBe(1);
             expect(grantFromBob.recordId).toBe(grantWrite.recordsWrite.message.recordId);
             // 6. Verify that any third-party can fetch revocation of the grant and find it is still active (not revoked)
-            const revocationRead = yield RecordsRead.create({
+            const revocationRead = await RecordsRead.create({
                 signer: Jws.createSigner(bob),
                 filter: {
                     contextId: grantWrite.recordsWrite.message.contextId,
                     protocolPath: PermissionsProtocol.revocationPath
                 }
             });
-            const revocationReadReply = yield dwn.processMessage(alice.did, revocationRead.message);
+            const revocationReadReply = await dwn.processMessage(alice.did, revocationRead.message);
             expect(revocationReadReply.status.code).toBe(404);
             // 7. Verify that non-owner cannot revoke the grant
-            const unauthorizedRevokeWrite = yield PermissionsProtocol.createRevocation({
+            const unauthorizedRevokeWrite = await PermissionsProtocol.createRevocation({
                 signer: Jws.createSigner(bob),
-                grant: yield PermissionGrant.parse(grantWrite.dataEncodedMessage),
+                grant: PermissionGrant.parse(grantWrite.dataEncodedMessage),
                 dateRevoked: Time.getCurrentTimestamp(),
             });
-            const unauthorizedRevokeWriteReply = yield dwn.processMessage(alice.did, unauthorizedRevokeWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(unauthorizedRevokeWrite.permissionRevocationBytes) });
+            const unauthorizedRevokeWriteReply = await dwn.processMessage(alice.did, unauthorizedRevokeWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(unauthorizedRevokeWrite.permissionRevocationBytes) });
             expect(unauthorizedRevokeWriteReply.status.code).toBe(401);
             expect(unauthorizedGrantWriteReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
             // 8. Alice revokes the permission grant for Bob
-            const revokeWrite = yield PermissionsProtocol.createRevocation({
+            const revokeWrite = await PermissionsProtocol.createRevocation({
                 signer: Jws.createSigner(alice),
-                grant: yield PermissionGrant.parse(grantWrite.dataEncodedMessage),
+                grant: PermissionGrant.parse(grantWrite.dataEncodedMessage),
                 dateRevoked: Time.getCurrentTimestamp(),
             });
-            const revokeWriteReply = yield dwn.processMessage(alice.did, revokeWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(revokeWrite.permissionRevocationBytes) });
+            const revokeWriteReply = await dwn.processMessage(alice.did, revokeWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(revokeWrite.permissionRevocationBytes) });
             expect(revokeWriteReply.status.code).toBe(202);
             // 9. Verify that any third-party can fetch the revocation status of the permission grant
-            const revocationReadReply2 = yield dwn.processMessage(alice.did, revocationRead.message);
+            const revocationReadReply2 = await dwn.processMessage(alice.did, revocationRead.message);
             expect(revocationReadReply2.status.code).toBe(200);
-            expect((_e = revocationReadReply2.entry.recordsWrite) === null || _e === void 0 ? void 0 : _e.recordId).toBe(revokeWrite.recordsWrite.message.recordId);
-        }));
-        it('should fail if a RecordsPermissionScope in a Request or Grant record is created without a protocol', () => __awaiter(this, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
+            expect(revocationReadReply2.entry.recordsWrite?.recordId).toBe(revokeWrite.recordsWrite.message.recordId);
+        });
+        it('should fail if a RecordsPermissionScope in a Request or Grant record is created without a protocol', async () => {
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
             const permissionScope = {
                 interface: DwnInterfaceName.Records,
                 method: DwnMethodName.Write
@@ -298,7 +289,7 @@ export function testPermissions() {
                 delegated: false,
                 scope: permissionScope // explicity as any to test the validation
             });
-            yield expect(requestWrite).rejects.toThrow(DwnErrorCode.PermissionsProtocolCreateRequestRecordsScopeMissingProtocol);
+            await expect(requestWrite).rejects.toThrow(DwnErrorCode.PermissionsProtocolCreateRequestRecordsScopeMissingProtocol);
             const grantWrite = PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -306,30 +297,30 @@ export function testPermissions() {
                 grantedTo: bob.did,
                 scope: permissionScope // explicity as any to test the validation
             });
-            yield expect(grantWrite).rejects.toThrow(DwnErrorCode.PermissionsProtocolCreateGrantRecordsScopeMissingProtocol);
-        }));
-        it('should fail if an invalid protocolPath is used during Permissions schema validation', () => __awaiter(this, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const { message, dataBytes } = yield TestDataGenerator.generateRecordsWrite({
+            await expect(grantWrite).rejects.toThrow(DwnErrorCode.PermissionsProtocolCreateGrantRecordsScopeMissingProtocol);
+        });
+        it('should fail if an invalid protocolPath is used during Permissions schema validation', async () => {
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const { message, dataBytes } = await TestDataGenerator.generateRecordsWrite({
                 author: alice,
                 protocol: PermissionsProtocol.uri,
                 protocolPath: 'invalid/path',
                 data: Encoder.stringToBytes(JSON.stringify({}))
             });
             expect(() => PermissionsProtocol.validateSchema(message, dataBytes)).toThrow(DwnErrorCode.PermissionsProtocolValidateSchemaUnexpectedRecord);
-        }));
-        it('performs additional validation to the tagged protocol in a Revocation message ensuring it matches the Grant it is revoking', () => __awaiter(this, void 0, void 0, function* () {
+        });
+        it('performs additional validation to the tagged protocol in a Revocation message ensuring it matches the Grant it is revoking', async () => {
             // scenario:
             //  Alice creates a grant scoped to a protocol.
             //  Alice then tries to revoke the grant without a protocol set, it should fail.
             //  Alice then tries to revoke the grant with an invalid protocol, it should fail.
             //  Alice finally tries to revoke the grant with a valid protocol, it should succeed.
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
             const grantProtocol = 'https://example.com/protocol/test';
             const invalidProtocol = 'https://example.com/protocol/invalid';
             // alice creates a grant for bob
-            const grantWrite = yield PermissionsProtocol.createGrant({
+            const grantWrite = await PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 description: 'Allow Bob to write',
@@ -340,13 +331,13 @@ export function testPermissions() {
                     protocol: grantProtocol,
                 }
             });
-            const grantWriteReply = yield dwn.processMessage(alice.did, grantWrite.recordsWrite.message, {
+            const grantWriteReply = await dwn.processMessage(alice.did, grantWrite.recordsWrite.message, {
                 dataStream: DataStream.fromBytes(grantWrite.permissionGrantBytes)
             });
             expect(grantWriteReply.status.code).toBe(202);
             // attempt to revoke the grant without a protocol set
             const permissionRevocationBytes = Encoder.objectToBytes({ description: 'Revoking the grant' });
-            const revokeWithoutProtocolRecordsWrite = yield RecordsWrite.create({
+            const revokeWithoutProtocolRecordsWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(alice),
                 parentContextId: grantWrite.dataEncodedMessage.recordId,
                 protocol: PermissionsProtocol.uri,
@@ -354,14 +345,14 @@ export function testPermissions() {
                 dataFormat: 'application/json',
                 data: permissionRevocationBytes,
             });
-            const revokeWriteWithoutProtocolReply = yield dwn.processMessage(alice.did, revokeWithoutProtocolRecordsWrite.message, {
+            const revokeWriteWithoutProtocolReply = await dwn.processMessage(alice.did, revokeWithoutProtocolRecordsWrite.message, {
                 dataStream: DataStream.fromBytes(permissionRevocationBytes)
             });
             expect(revokeWriteWithoutProtocolReply.status.code).toBe(400);
             expect(revokeWriteWithoutProtocolReply.status.detail).toContain(DwnErrorCode.PermissionsProtocolValidateRevocationProtocolTagMismatch);
             expect(revokeWriteWithoutProtocolReply.status.detail).toContain(`Revocation protocol undefined does not match grant protocol ${grantProtocol}`);
             // revoke the grant with an invalid protocol
-            const revokeWriteWithMissMatchedProtocol = yield RecordsWrite.create({
+            const revokeWriteWithMissMatchedProtocol = await RecordsWrite.create({
                 signer: Jws.createSigner(alice),
                 parentContextId: grantWrite.dataEncodedMessage.recordId,
                 protocol: PermissionsProtocol.uri,
@@ -370,14 +361,14 @@ export function testPermissions() {
                 data: permissionRevocationBytes,
                 tags: { protocol: invalidProtocol }
             });
-            const revokeWriteWithMissMatchedProtocolReply = yield dwn.processMessage(alice.did, revokeWriteWithMissMatchedProtocol.message, {
+            const revokeWriteWithMissMatchedProtocolReply = await dwn.processMessage(alice.did, revokeWriteWithMissMatchedProtocol.message, {
                 dataStream: DataStream.fromBytes(permissionRevocationBytes)
             });
             expect(revokeWriteWithMissMatchedProtocolReply.status.code).toBe(400);
             expect(revokeWriteWithMissMatchedProtocolReply.status.detail).toContain(DwnErrorCode.PermissionsProtocolValidateRevocationProtocolTagMismatch);
             expect(revokeWriteWithMissMatchedProtocolReply.status.detail).toContain(`Revocation protocol ${invalidProtocol} does not match grant protocol ${grantProtocol}`);
             // revoke the grant with a valid protocol
-            const revokeWrite = yield RecordsWrite.create({
+            const revokeWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(alice),
                 parentContextId: grantWrite.dataEncodedMessage.recordId,
                 protocol: PermissionsProtocol.uri,
@@ -386,18 +377,18 @@ export function testPermissions() {
                 data: permissionRevocationBytes,
                 tags: { protocol: grantProtocol }
             });
-            const revokeWriteReply = yield dwn.processMessage(alice.did, revokeWrite.message, {
+            const revokeWriteReply = await dwn.processMessage(alice.did, revokeWrite.message, {
                 dataStream: DataStream.fromBytes(permissionRevocationBytes)
             });
             expect(revokeWriteReply.status.code).toBe(202);
-        }));
+        });
         // These set of tets are primarily to ensure SchemaValidation passes for the various permission request and grant messages and their scopes
         describe('ensure loaded scope properties for permission requests are processed', () => {
-            it('MessagesRead', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            it('MessagesRead', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // create a permission grant with protocol
-                const messagesReadPermissions = yield PermissionsProtocol.createGrant({
+                const messagesReadPermissions = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -408,16 +399,16 @@ export function testPermissions() {
                         protocol: 'https://example.com/protocol/test',
                     }
                 });
-                const messagesReadPermissionsReply = yield dwn.processMessage(alice.did, messagesReadPermissions.recordsWrite.message, {
+                const messagesReadPermissionsReply = await dwn.processMessage(alice.did, messagesReadPermissions.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(messagesReadPermissions.permissionGrantBytes)
                 });
                 expect(messagesReadPermissionsReply.status.code).toBe(202);
-            }));
-            it('MessagesSubscribe', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('MessagesSubscribe', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // create a permission grant with protocol
-                const messagesSubscribePermissions = yield PermissionsProtocol.createGrant({
+                const messagesSubscribePermissions = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -428,16 +419,16 @@ export function testPermissions() {
                         protocol: 'https://example.com/protocol/test',
                     }
                 });
-                const messagesSubscribePermissionsReply = yield dwn.processMessage(alice.did, messagesSubscribePermissions.recordsWrite.message, {
+                const messagesSubscribePermissionsReply = await dwn.processMessage(alice.did, messagesSubscribePermissions.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(messagesSubscribePermissions.permissionGrantBytes)
                 });
                 expect(messagesSubscribePermissionsReply.status.code).toBe(202);
-            }));
-            it('RecordsDelete', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('RecordsDelete', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // create a permission grant with protocol and contextId
-                const withContextId = yield PermissionsProtocol.createGrant({
+                const withContextId = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -449,12 +440,12 @@ export function testPermissions() {
                         contextId: 'test-context'
                     }
                 });
-                const withContextIdReply = yield dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
+                const withContextIdReply = await dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withContextId.permissionGrantBytes)
                 });
                 expect(withContextIdReply.status.code).toBe(202);
                 // create a permission request with protocol and protocolPath
-                const withProtocolPath = yield PermissionsProtocol.createGrant({
+                const withProtocolPath = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -466,16 +457,16 @@ export function testPermissions() {
                         protocolPath: 'foo/bar'
                     }
                 });
-                const withProtocolPathReply = yield dwn.processMessage(alice.did, withProtocolPath.recordsWrite.message, {
+                const withProtocolPathReply = await dwn.processMessage(alice.did, withProtocolPath.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withProtocolPath.permissionGrantBytes)
                 });
                 expect(withProtocolPathReply.status.code).toBe(202);
-            }));
-            it('RecordsQuery', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('RecordsQuery', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // create a permission grant with protocol and contextId scope
-                const withContextId = yield PermissionsProtocol.createGrant({
+                const withContextId = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -488,12 +479,12 @@ export function testPermissions() {
                         contextId: 'test-context'
                     }
                 });
-                const withContextIdReply = yield dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
+                const withContextIdReply = await dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withContextId.permissionGrantBytes)
                 });
                 expect(withContextIdReply.status.code).toBe(202);
                 // create a permission request with protocol and protocolPath scope
-                const withProtocolPath = yield PermissionsProtocol.createRequest({
+                const withProtocolPath = await PermissionsProtocol.createRequest({
                     signer: Jws.createSigner(bob),
                     description: 'Requesting to query from Alice foo/bar',
                     delegated: true,
@@ -504,16 +495,16 @@ export function testPermissions() {
                         protocolPath: 'foo/bar'
                     }
                 });
-                const withProtocolPathReply = yield dwn.processMessage(bob.did, withProtocolPath.recordsWrite.message, {
+                const withProtocolPathReply = await dwn.processMessage(bob.did, withProtocolPath.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withProtocolPath.permissionRequestBytes)
                 });
                 expect(withProtocolPathReply.status.code).toBe(202);
-            }));
-            it('RecordsRead', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('RecordsRead', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // create a permission grant with protocol and contextId scope
-                const withContextId = yield PermissionsProtocol.createGrant({
+                const withContextId = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -526,12 +517,12 @@ export function testPermissions() {
                         contextId: 'test-context'
                     }
                 });
-                const withContextIdReply = yield dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
+                const withContextIdReply = await dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withContextId.permissionGrantBytes)
                 });
                 expect(withContextIdReply.status.code).toBe(202);
                 // create a permission request with protocol and protocolPath scope
-                const withProtocolPath = yield PermissionsProtocol.createGrant({
+                const withProtocolPath = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -544,16 +535,16 @@ export function testPermissions() {
                         protocolPath: 'foo/bar'
                     }
                 });
-                const withProtocolPathReply = yield dwn.processMessage(alice.did, withProtocolPath.recordsWrite.message, {
+                const withProtocolPathReply = await dwn.processMessage(alice.did, withProtocolPath.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withProtocolPath.permissionGrantBytes)
                 });
                 expect(withProtocolPathReply.status.code).toBe(202);
-            }));
-            it('RecordsSubscribe', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('RecordsSubscribe', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // create a permission grant with protocol and contextId scope
-                const withContextId = yield PermissionsProtocol.createGrant({
+                const withContextId = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -566,12 +557,12 @@ export function testPermissions() {
                         contextId: 'test-context'
                     }
                 });
-                const withContextIdReply = yield dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
+                const withContextIdReply = await dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withContextId.permissionGrantBytes)
                 });
                 expect(withContextIdReply.status.code).toBe(202);
                 // create a permission request with protocol and protocolPath scope
-                const withProtocolPath = yield PermissionsProtocol.createGrant({
+                const withProtocolPath = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -584,16 +575,16 @@ export function testPermissions() {
                         protocolPath: 'foo/bar'
                     }
                 });
-                const withProtocolPathReply = yield dwn.processMessage(alice.did, withProtocolPath.recordsWrite.message, {
+                const withProtocolPathReply = await dwn.processMessage(alice.did, withProtocolPath.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withProtocolPath.permissionGrantBytes)
                 });
                 expect(withProtocolPathReply.status.code).toBe(202);
-            }));
-            it('RecordsWrite', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('RecordsWrite', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // create a permission grant with protocol and contextId scope
-                const withContextId = yield PermissionsProtocol.createGrant({
+                const withContextId = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -606,12 +597,12 @@ export function testPermissions() {
                         contextId: 'test-context'
                     }
                 });
-                const withContextIdReply = yield dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
+                const withContextIdReply = await dwn.processMessage(alice.did, withContextId.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withContextId.permissionGrantBytes)
                 });
                 expect(withContextIdReply.status.code).toBe(202);
                 // create a permission request with protocol and protocolPath scope
-                const withProtocolPath = yield PermissionsProtocol.createGrant({
+                const withProtocolPath = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -624,16 +615,16 @@ export function testPermissions() {
                         protocolPath: 'foo/bar'
                     }
                 });
-                const withProtocolPathReply = yield dwn.processMessage(alice.did, withProtocolPath.recordsWrite.message, {
+                const withProtocolPathReply = await dwn.processMessage(alice.did, withProtocolPath.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(withProtocolPath.permissionGrantBytes)
                 });
                 expect(withProtocolPathReply.status.code).toBe(202);
-            }));
-            it('ProtocolsQuery', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('ProtocolsQuery', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // create a permission grant with protocol query that is unrestricted
-                const protocolQueryPermissions = yield PermissionsProtocol.createGrant({
+                const protocolQueryPermissions = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     grantedTo: bob.did,
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -643,54 +634,54 @@ export function testPermissions() {
                         method: DwnMethodName.Query,
                     }
                 });
-                const protocolQueryPermissionsReply = yield dwn.processMessage(alice.did, protocolQueryPermissions.recordsWrite.message, {
+                const protocolQueryPermissionsReply = await dwn.processMessage(alice.did, protocolQueryPermissions.recordsWrite.message, {
                     dataStream: DataStream.fromBytes(protocolQueryPermissions.permissionGrantBytes)
                 });
                 expect(protocolQueryPermissionsReply.status.code).toBe(202);
-            }));
+            });
         });
         describe('validateScopeAndTags', () => {
-            it('should be called for a Request or Grant record', () => __awaiter(this, void 0, void 0, function* () {
+            it('should be called for a Request or Grant record', async () => {
                 // spy on `validateScope`
                 const validateScopeSpy = sinon.spy(PermissionsProtocol, 'validateScopeAndTags');
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 const permissionScope = {
                     interface: DwnInterfaceName.Records,
                     method: DwnMethodName.Write,
                     protocol: 'https://example.com/protocol/test'
                 };
                 // create a request
-                const requestToAlice = yield PermissionsProtocol.createRequest({
+                const requestToAlice = await PermissionsProtocol.createRequest({
                     signer: Jws.createSigner(bob),
                     description: `Requesting to write to Alice's DWN`,
                     delegated: false,
                     scope: permissionScope
                 });
-                const requestToAliceReply = yield dwn.processMessage(alice.did, requestToAlice.recordsWrite.message, { dataStream: DataStream.fromBytes(requestToAlice.permissionRequestBytes) });
+                const requestToAliceReply = await dwn.processMessage(alice.did, requestToAlice.recordsWrite.message, { dataStream: DataStream.fromBytes(requestToAlice.permissionRequestBytes) });
                 expect(requestToAliceReply.status.code).toBe(202);
                 expect(validateScopeSpy.calledOnce).toBe(true);
                 // create a grant
-                const grantedToBob = yield PermissionsProtocol.createGrant({
+                const grantedToBob = await PermissionsProtocol.createGrant({
                     signer: Jws.createSigner(alice),
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                     description: 'Allow Bob to write',
                     grantedTo: bob.did,
                     scope: permissionScope
                 });
-                const grantWriteReply = yield dwn.processMessage(alice.did, grantedToBob.recordsWrite.message, { dataStream: DataStream.fromBytes(grantedToBob.permissionGrantBytes) });
+                const grantWriteReply = await dwn.processMessage(alice.did, grantedToBob.recordsWrite.message, { dataStream: DataStream.fromBytes(grantedToBob.permissionGrantBytes) });
                 expect(grantWriteReply.status.code).toBe(202);
                 expect(validateScopeSpy.calledTwice).toBe(true); // called twice, once for the request and once for the grant
-            }));
-            it('should throw if the scope is a RecordsPermissionScope and a protocol tag is not defined on the Request and Grant record', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should throw if the scope is a RecordsPermissionScope and a protocol tag is not defined on the Request and Grant record', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const permissionScope = {
                     interface: DwnInterfaceName.Records,
                     method: DwnMethodName.Write,
                     protocol: 'https://example.com/protocol/test'
                 };
                 // create a permission request without a protocol tag
-                const requestWrite = yield TestDataGenerator.generateRecordsWrite({
+                const requestWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: PermissionsProtocol.uri,
                     protocolPath: PermissionsProtocol.requestPath,
@@ -699,7 +690,7 @@ export function testPermissions() {
                 });
                 expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, requestWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeMissingProtocolTag);
                 // create a permission grant without a protocol tag
-                const grantRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                const grantRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: PermissionsProtocol.uri,
                     protocolPath: PermissionsProtocol.grantPath,
@@ -707,16 +698,16 @@ export function testPermissions() {
                     tags: { someTag: 'someValue' } // not a protocol tag
                 });
                 expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, grantRecordsWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeMissingProtocolTag);
-            }));
-            it('should throw if the scope is a RecordsPermissionScope and the Request and Grant record has no tags', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should throw if the scope is a RecordsPermissionScope and the Request and Grant record has no tags', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const permissionScope = {
                     interface: DwnInterfaceName.Records,
                     method: DwnMethodName.Write,
                     protocol: 'https://example.com/protocol/test'
                 };
                 // create a permission request without a protocol tag
-                const requestWrite = yield TestDataGenerator.generateRecordsWrite({
+                const requestWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: PermissionsProtocol.uri,
                     protocolPath: PermissionsProtocol.requestPath,
@@ -724,16 +715,16 @@ export function testPermissions() {
                 });
                 expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, requestWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeMissingProtocolTag);
                 // create a permission grant without a protocol tag
-                const grantRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                const grantRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: PermissionsProtocol.uri,
                     protocolPath: PermissionsProtocol.grantPath,
                     data: Encoder.stringToBytes(JSON.stringify({})),
                 });
                 expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, grantRecordsWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeMissingProtocolTag);
-            }));
-            it('should throw if the protocol tag in the Request and Grant record does not match the protocol defined in the scope', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should throw if the protocol tag in the Request and Grant record does not match the protocol defined in the scope', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // create a permission scope to test against
                 const permissionScope = {
                     interface: DwnInterfaceName.Records,
@@ -741,7 +732,7 @@ export function testPermissions() {
                     protocol: 'https://example.com/protocol/test'
                 };
                 // create a permission request with a protocol tag that does not match the scope
-                const requestWrite = yield TestDataGenerator.generateRecordsWrite({
+                const requestWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: PermissionsProtocol.uri,
                     protocolPath: PermissionsProtocol.requestPath,
@@ -750,7 +741,7 @@ export function testPermissions() {
                 });
                 expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, requestWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeProtocolMismatch);
                 // create a permission grant with a protocol tag that does not match the scope
-                const grantRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                const grantRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: PermissionsProtocol.uri,
                     protocolPath: PermissionsProtocol.grantPath,
@@ -758,9 +749,9 @@ export function testPermissions() {
                     tags: { protocol: 'https://example.com/protocol/invalid' }
                 });
                 expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, grantRecordsWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeProtocolMismatch);
-            }));
-            it('should throw if protocolPath and contextId are both defined in the scope for a Request and Grant record', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should throw if protocolPath and contextId are both defined in the scope for a Request and Grant record', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const permissionScope = {
                     interface: DwnInterfaceName.Records,
                     method: DwnMethodName.Write,
@@ -769,7 +760,7 @@ export function testPermissions() {
                     contextId: 'test-context'
                 };
                 // create a permission request with a scope that has both protocolPath and contextId
-                const requestRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                const requestRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: PermissionsProtocol.uri,
                     protocolPath: PermissionsProtocol.requestPath,
@@ -778,7 +769,7 @@ export function testPermissions() {
                 });
                 expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, requestRecordsWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeContextIdProhibitedProperties);
                 // create a permission grant with a scope that has both protocolPath and contextId
-                const grantRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                const grantRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: PermissionsProtocol.uri,
                     protocolPath: PermissionsProtocol.grantPath,
@@ -786,7 +777,281 @@ export function testPermissions() {
                     tags: { protocol: 'https://example.com/protocol/test' }
                 });
                 expect(() => PermissionsProtocol['validateScopeAndTags'](permissionScope, grantRecordsWrite.message)).toThrow(DwnErrorCode.PermissionsProtocolValidateScopeContextIdProhibitedProperties);
-            }));
+            });
+        });
+        describe('revocation cleanup', () => {
+            it('should delete grant-authorized messages created at or after the revocation timestamp', async () => {
+                // scenario:
+                // 1. Alice installs a protocol and grants Bob write access
+                // 2. Bob writes a record using the grant with a future timestamp
+                // 3. Alice revokes the grant (the revocation's messageTimestamp is auto-set to "now")
+                // 4. The record Bob wrote with a future dateCreated (>= revocation messageTimestamp) should be deleted
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const protocolDefinition = minimalProtocolDefinition;
+                // Alice installs the protocol
+                const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
+                    author: alice,
+                    protocolDefinition,
+                });
+                const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
+                expect(protocolsConfigureReply.status.code).toBe(202);
+                // Alice grants Bob write permission
+                const permissionGrant = await PermissionsProtocol.createGrant({
+                    signer: Jws.createSigner(alice),
+                    grantedTo: bob.did,
+                    dateExpires: Time.createOffsetTimestamp({ seconds: 60 * 60 * 24 }),
+                    scope: {
+                        interface: DwnInterfaceName.Records,
+                        method: DwnMethodName.Write,
+                        protocol: protocolDefinition.protocol,
+                    }
+                });
+                const grantWriteReply = await dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: DataStream.fromBytes(permissionGrant.permissionGrantBytes) });
+                expect(grantWriteReply.status.code).toBe(202);
+                // Bob writes a record using the grant with a future timestamp (guaranteed >= any revocation messageTimestamp)
+                const futureTimestamp = Time.createOffsetTimestamp({ seconds: 60 });
+                const { recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
+                    author: bob,
+                    protocol: protocolDefinition.protocol,
+                    protocolPath: 'foo',
+                    permissionGrantId: permissionGrant.recordsWrite.message.recordId,
+                    dateCreated: futureTimestamp,
+                    messageTimestamp: futureTimestamp,
+                });
+                const writeReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
+                expect(writeReply.status.code).toBe(202);
+                // Verify the record exists before revocation
+                const queryBefore = await RecordsQuery.create({
+                    signer: Jws.createSigner(alice),
+                    filter: { protocol: protocolDefinition.protocol },
+                });
+                const queryBeforeReply = await dwn.processMessage(alice.did, queryBefore.message);
+                expect(queryBeforeReply.status.code).toBe(200);
+                expect(queryBeforeReply.entries.length).toBe(1);
+                // Alice revokes the grant (messageTimestamp is auto-set to current time, which is before futureTimestamp)
+                const revokeWrite = await PermissionsProtocol.createRevocation({
+                    signer: Jws.createSigner(alice),
+                    grant: PermissionGrant.parse(permissionGrant.dataEncodedMessage),
+                });
+                const revokeReply = await dwn.processMessage(alice.did, revokeWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(revokeWrite.permissionRevocationBytes) });
+                expect(revokeReply.status.code).toBe(202);
+                // The grant-authorized record should have been deleted by revocation cleanup
+                const queryAfter = await RecordsQuery.create({
+                    signer: Jws.createSigner(alice),
+                    filter: { protocol: protocolDefinition.protocol },
+                });
+                const queryAfterReply = await dwn.processMessage(alice.did, queryAfter.message);
+                expect(queryAfterReply.status.code).toBe(200);
+                expect(queryAfterReply.entries.length).toBe(0);
+            });
+            it('should not delete grant-authorized messages created before the revocation timestamp', async () => {
+                // scenario:
+                // 1. Alice installs a protocol and grants Bob write access
+                // 2. Bob writes a record using the grant (dateCreated is "now")
+                // 3. Alice revokes the grant (messageTimestamp is auto-set to a slightly later "now")
+                // 4. The record Bob wrote before the revocation should NOT be deleted
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const protocolDefinition = minimalProtocolDefinition;
+                // Alice installs the protocol
+                const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
+                    author: alice,
+                    protocolDefinition,
+                });
+                const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
+                expect(protocolsConfigureReply.status.code).toBe(202);
+                // Alice grants Bob write permission
+                const permissionGrant = await PermissionsProtocol.createGrant({
+                    signer: Jws.createSigner(alice),
+                    grantedTo: bob.did,
+                    dateExpires: Time.createOffsetTimestamp({ seconds: 60 * 60 * 24 }),
+                    scope: {
+                        interface: DwnInterfaceName.Records,
+                        method: DwnMethodName.Write,
+                        protocol: protocolDefinition.protocol,
+                    }
+                });
+                const grantWriteReply = await dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: DataStream.fromBytes(permissionGrant.permissionGrantBytes) });
+                expect(grantWriteReply.status.code).toBe(202);
+                // Bob writes a record using the grant (dateCreated defaults to current time)
+                const { recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
+                    author: bob,
+                    protocol: protocolDefinition.protocol,
+                    protocolPath: 'foo',
+                    permissionGrantId: permissionGrant.recordsWrite.message.recordId,
+                });
+                const writeReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
+                expect(writeReply.status.code).toBe(202);
+                // Alice revokes the grant (messageTimestamp is auto-set slightly after the record's dateCreated)
+                const revokeWrite = await PermissionsProtocol.createRevocation({
+                    signer: Jws.createSigner(alice),
+                    grant: PermissionGrant.parse(permissionGrant.dataEncodedMessage),
+                });
+                const revokeReply = await dwn.processMessage(alice.did, revokeWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(revokeWrite.permissionRevocationBytes) });
+                expect(revokeReply.status.code).toBe(202);
+                // The record Bob wrote before the revocation should still exist
+                const queryAfter = await RecordsQuery.create({
+                    signer: Jws.createSigner(alice),
+                    filter: { protocol: protocolDefinition.protocol },
+                });
+                const queryAfterReply = await dwn.processMessage(alice.did, queryAfter.message);
+                expect(queryAfterReply.status.code).toBe(200);
+                expect(queryAfterReply.entries.length).toBe(1);
+            });
+            it('should delete data from the data store for large records when revoking a grant', async () => {
+                // scenario:
+                // 1. Alice installs a protocol and grants Bob write access
+                // 2. Bob writes a record with data larger than maxDataSizeAllowedToBeEncoded (30KB)
+                // 3. Alice revokes the grant
+                // 4. Both the message and the data blob should be deleted
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const protocolDefinition = minimalProtocolDefinition;
+                // Alice installs the protocol
+                const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
+                    author: alice,
+                    protocolDefinition,
+                });
+                const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
+                expect(protocolsConfigureReply.status.code).toBe(202);
+                // Alice grants Bob write permission
+                const permissionGrant = await PermissionsProtocol.createGrant({
+                    signer: Jws.createSigner(alice),
+                    grantedTo: bob.did,
+                    dateExpires: Time.createOffsetTimestamp({ seconds: 60 * 60 * 24 }),
+                    scope: {
+                        interface: DwnInterfaceName.Records,
+                        method: DwnMethodName.Write,
+                        protocol: protocolDefinition.protocol,
+                    }
+                });
+                const grantWriteReply = await dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: DataStream.fromBytes(permissionGrant.permissionGrantBytes) });
+                expect(grantWriteReply.status.code).toBe(202);
+                // Bob writes a record with large data (> 30KB) using the grant, with a future timestamp
+                const futureTimestamp = Time.createOffsetTimestamp({ seconds: 60 });
+                const largeData = TestDataGenerator.randomBytes(40_000);
+                const { recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
+                    author: bob,
+                    protocol: protocolDefinition.protocol,
+                    protocolPath: 'foo',
+                    data: largeData,
+                    permissionGrantId: permissionGrant.recordsWrite.message.recordId,
+                    dateCreated: futureTimestamp,
+                    messageTimestamp: futureTimestamp,
+                });
+                const writeReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
+                expect(writeReply.status.code).toBe(202);
+                // Verify the data exists in the data store before revocation
+                const dataResult = await dataStore.get(alice.did, recordsWrite.message.recordId, recordsWrite.message.descriptor.dataCid);
+                expect(dataResult).toBeDefined();
+                // Alice revokes the grant
+                const revokeWrite = await PermissionsProtocol.createRevocation({
+                    signer: Jws.createSigner(alice),
+                    grant: PermissionGrant.parse(permissionGrant.dataEncodedMessage),
+                });
+                const revokeReply = await dwn.processMessage(alice.did, revokeWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(revokeWrite.permissionRevocationBytes) });
+                expect(revokeReply.status.code).toBe(202);
+                // The record should be deleted from the message store
+                const queryAfter = await RecordsQuery.create({
+                    signer: Jws.createSigner(alice),
+                    filter: { protocol: protocolDefinition.protocol },
+                });
+                const queryAfterReply = await dwn.processMessage(alice.did, queryAfter.message);
+                expect(queryAfterReply.status.code).toBe(200);
+                expect(queryAfterReply.entries.length).toBe(0);
+                // The data blob should also be deleted from the data store
+                const dataResultAfter = await dataStore.get(alice.did, recordsWrite.message.recordId, recordsWrite.message.descriptor.dataCid);
+                expect(dataResultAfter).toBeUndefined();
+            });
+            it('should delete multiple grant-authorized messages when revoking a grant', async () => {
+                // scenario:
+                // 1. Alice installs a protocol and grants Bob write access
+                // 2. Bob writes three records: one at current time, two with future timestamps
+                // 3. Alice revokes the grant (at current time, between the first and future records)
+                // 4. The current-time record survives; the two future records are deleted
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const protocolDefinition = minimalProtocolDefinition;
+                // Alice installs the protocol
+                const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
+                    author: alice,
+                    protocolDefinition,
+                });
+                const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
+                expect(protocolsConfigureReply.status.code).toBe(202);
+                // Alice grants Bob write permission
+                const permissionGrant = await PermissionsProtocol.createGrant({
+                    signer: Jws.createSigner(alice),
+                    grantedTo: bob.did,
+                    dateExpires: Time.createOffsetTimestamp({ seconds: 60 * 60 * 24 }),
+                    scope: {
+                        interface: DwnInterfaceName.Records,
+                        method: DwnMethodName.Write,
+                        protocol: protocolDefinition.protocol,
+                    }
+                });
+                const grantWriteReply = await dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: DataStream.fromBytes(permissionGrant.permissionGrantBytes) });
+                expect(grantWriteReply.status.code).toBe(202);
+                // Timestamps: future records will be deleted, current-time record will survive
+                const futureTimestamp = Time.createOffsetTimestamp({ seconds: 60 });
+                const farFutureTimestamp = Time.createOffsetTimestamp({ seconds: 120 });
+                // Bob writes record 1 (current time — should survive)
+                const write1 = await TestDataGenerator.generateRecordsWrite({
+                    author: bob,
+                    protocol: protocolDefinition.protocol,
+                    protocolPath: 'foo',
+                    permissionGrantId: permissionGrant.recordsWrite.message.recordId,
+                });
+                const write1Reply = await dwn.processMessage(alice.did, write1.recordsWrite.message, { dataStream: write1.dataStream });
+                expect(write1Reply.status.code).toBe(202);
+                // Bob writes record 2 (future — should be deleted)
+                const write2 = await TestDataGenerator.generateRecordsWrite({
+                    author: bob,
+                    protocol: protocolDefinition.protocol,
+                    protocolPath: 'foo',
+                    permissionGrantId: permissionGrant.recordsWrite.message.recordId,
+                    dateCreated: futureTimestamp,
+                    messageTimestamp: futureTimestamp,
+                });
+                const write2Reply = await dwn.processMessage(alice.did, write2.recordsWrite.message, { dataStream: write2.dataStream });
+                expect(write2Reply.status.code).toBe(202);
+                // Bob writes record 3 (far future — should be deleted)
+                const write3 = await TestDataGenerator.generateRecordsWrite({
+                    author: bob,
+                    protocol: protocolDefinition.protocol,
+                    protocolPath: 'foo',
+                    permissionGrantId: permissionGrant.recordsWrite.message.recordId,
+                    dateCreated: farFutureTimestamp,
+                    messageTimestamp: farFutureTimestamp,
+                });
+                const write3Reply = await dwn.processMessage(alice.did, write3.recordsWrite.message, { dataStream: write3.dataStream });
+                expect(write3Reply.status.code).toBe(202);
+                // Verify all 3 records exist before revocation
+                const queryBefore = await RecordsQuery.create({
+                    signer: Jws.createSigner(alice),
+                    filter: { protocol: protocolDefinition.protocol },
+                });
+                const queryBeforeReply = await dwn.processMessage(alice.did, queryBefore.message);
+                expect(queryBeforeReply.status.code).toBe(200);
+                expect(queryBeforeReply.entries.length).toBe(3);
+                // Alice revokes the grant (messageTimestamp is "now", between record 1 and records 2/3)
+                const revokeWrite = await PermissionsProtocol.createRevocation({
+                    signer: Jws.createSigner(alice),
+                    grant: PermissionGrant.parse(permissionGrant.dataEncodedMessage),
+                });
+                const revokeReply = await dwn.processMessage(alice.did, revokeWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(revokeWrite.permissionRevocationBytes) });
+                expect(revokeReply.status.code).toBe(202);
+                // Only the record written at current time should remain
+                const queryAfter = await RecordsQuery.create({
+                    signer: Jws.createSigner(alice),
+                    filter: { protocol: protocolDefinition.protocol },
+                });
+                const queryAfterReply = await dwn.processMessage(alice.did, queryAfter.message);
+                expect(queryAfterReply.status.code).toBe(200);
+                expect(queryAfterReply.entries.length).toBe(1);
+                expect(queryAfterReply.entries[0].recordId).toBe(write1.recordsWrite.message.recordId);
+            });
         });
     });
 }