@enbox/dwn-sdk-js 0.0.6 → 0.0.8

package/dist/esm/tests/features/owner-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 minimalProtocolDefinition from '../vectors/protocol-definitions/minimal.json' with { type: 'json' };
 import sinon from 'sinon';
 import { DataStream } from '../../src/utils/data-stream.js';
@@ -16,7 +7,7 @@ import { Jws } from '../../src/utils/jws.js';
 import { PermissionGrant } from '../../src/protocols/permission-grant.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';
@@ -29,43 +20,43 @@ export function testOwnerDelegatedGrant() {
         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('RecordsWrite.parse()', () => {
-            it('should throw if a message invokes an owner-delegated grant (ID) but the owner-delegated grant is not given', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generatePersona();
-                const bob = yield TestDataGenerator.generatePersona();
-                const appX = yield TestDataGenerator.generatePersona();
+            it('should throw if a message invokes an owner-delegated grant (ID) but the owner-delegated grant is not given', async () => {
+                const alice = await TestDataGenerator.generatePersona();
+                const bob = await TestDataGenerator.generatePersona();
+                const appX = await TestDataGenerator.generatePersona();
                 // Alice grants App X to write as her for the chat protocol
                 const scope = {
                     interface: DwnInterfaceName.Records,
                     method: DwnMethodName.Write,
                     protocol: 'chat'
                 };
-                const grantToAppX = yield PermissionsProtocol.createGrant({
+                const grantToAppX = await PermissionsProtocol.createGrant({
                     delegated: true, // this is a delegated grant
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                     description: 'Allow App X to write as me in chat protocol',
@@ -74,28 +65,30 @@ export function testOwnerDelegatedGrant() {
                     signer: Jws.createSigner(alice)
                 });
                 // Bob creates a RecordsWrite message
-                const recordsWrite = yield RecordsWrite.create({
+                const recordsWrite = await RecordsWrite.create({
                     signer: Jws.createSigner(bob),
+                    protocol: 'http://test-protocol.xyz',
+                    protocolPath: 'testRecord',
                     dataFormat: 'application/octet-stream',
                     data: TestDataGenerator.randomBytes(10),
                 });
                 // App X signs over Bob's RecordsWrite as DWN owner but does not include the delegated grant (we remove it below)
-                yield recordsWrite.signAsOwnerDelegate(Jws.createSigner(appX), grantToAppX.dataEncodedMessage);
+                await recordsWrite.signAsOwnerDelegate(Jws.createSigner(appX), grantToAppX.dataEncodedMessage);
                 delete recordsWrite.message.authorization.ownerDelegatedGrant; // intentionally remove `ownerDelegatedGrant`
                 const parsePromise = RecordsWrite.parse(recordsWrite.message);
-                yield expect(parsePromise).rejects.toThrow(DwnErrorCode.RecordsOwnerDelegatedGrantAndIdExistenceMismatch);
-            }));
-            it('should throw if a message includes an owner-delegated grant but does not reference it in owner signature', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generatePersona();
-                const bob = yield TestDataGenerator.generatePersona();
-                const appX = yield TestDataGenerator.generatePersona();
+                await expect(parsePromise).rejects.toThrow(DwnErrorCode.RecordsOwnerDelegatedGrantAndIdExistenceMismatch);
+            });
+            it('should throw if a message includes an owner-delegated grant but does not reference it in owner signature', async () => {
+                const alice = await TestDataGenerator.generatePersona();
+                const bob = await TestDataGenerator.generatePersona();
+                const appX = await TestDataGenerator.generatePersona();
                 // Alice grants App X to write as her for the chat protocol
                 const scope = {
                     interface: DwnInterfaceName.Records,
                     method: DwnMethodName.Write,
                     protocol: 'chat'
                 };
-                const grantToAppX = yield PermissionsProtocol.createGrant({
+                const grantToAppX = await PermissionsProtocol.createGrant({
                     delegated: true, // this is a delegated grant
                     dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                     description: 'Allow App X to write as me in chat protocol',
@@ -104,23 +97,24 @@ export function testOwnerDelegatedGrant() {
                     signer: Jws.createSigner(alice)
                 });
                 // Bob creates a RecordsWrite message
-                const recordsWrite = yield RecordsWrite.create({
+                const recordsWrite = await RecordsWrite.create({
                     signer: Jws.createSigner(bob),
+                    protocol: 'http://test-protocol.xyz',
+                    protocolPath: 'testRecord',
                     dataFormat: 'application/octet-stream',
                     data: TestDataGenerator.randomBytes(10),
                 });
                 // App X attempts to sign over Bob's RecordsWrite as the DWN owner by including an owner-delegated grant
                 // but does not reference the grant ID in owner signature (we remove it below)
-                yield recordsWrite.signAsOwnerDelegate(Jws.createSigner(appX), grantToAppX.dataEncodedMessage);
-                const ownerSignaturePayloadCopy = Object.assign({}, recordsWrite.ownerSignaturePayload);
+                await recordsWrite.signAsOwnerDelegate(Jws.createSigner(appX), grantToAppX.dataEncodedMessage);
+                const ownerSignaturePayloadCopy = { ...recordsWrite.ownerSignaturePayload };
                 delete ownerSignaturePayloadCopy.delegatedGrantId; // intentionally remove `delegatedGrantId` in ownerSignature
                 recordsWrite.message.authorization.ownerSignature.payload = Encoder.stringToBase64Url(JSON.stringify(ownerSignaturePayloadCopy));
                 const parsePromise = RecordsWrite.parse(recordsWrite.message);
-                yield expect(parsePromise).rejects.toThrow(DwnErrorCode.RecordsOwnerDelegatedGrantAndIdExistenceMismatch);
-            }));
+                await expect(parsePromise).rejects.toThrow(DwnErrorCode.RecordsOwnerDelegatedGrantAndIdExistenceMismatch);
+            });
         });
-        it('should only allow correct entity invoking an owner-delegated grant to write', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+        it('should only allow correct entity invoking an owner-delegated grant to write', async () => {
             // scenario:
             // 1. Alice installs a protocol
             // 2. Alice creates a delegated grant for app X to write in the protocol
@@ -129,18 +123,18 @@ export function testOwnerDelegatedGrant() {
             // 5. Verify that App Y cannot write Bob's message in Alice's DWN by invoking the delegated grant for App X.
             // 6. Verify that App X can successfully write Bob's message in Alice's DWN by invoking an owner-delegated grant
             // 7. Sanity verify the RecordsWrite written by App X
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const appX = yield TestDataGenerator.generateDidKeyPersona();
-            const appY = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const appX = await TestDataGenerator.generateDidKeyPersona();
+            const appY = await TestDataGenerator.generateDidKeyPersona();
             // 1. Alice installs a protocol
             const protocolDefinition = minimalProtocolDefinition;
             const protocol = minimalProtocolDefinition.protocol;
-            const protocolsConfig = yield ProtocolsConfigure.create({
+            const protocolsConfig = await ProtocolsConfigure.create({
                 signer: Jws.createSigner(alice),
                 definition: protocolDefinition
             });
-            const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // 2. Alice creates a delegated grant for app X to write in the protocol
             const scope = {
@@ -148,7 +142,7 @@ export function testOwnerDelegatedGrant() {
                 method: DwnMethodName.Write,
                 protocol
             };
-            const appXGrant = yield PermissionsProtocol.createGrant({
+            const appXGrant = await PermissionsProtocol.createGrant({
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: appX.did,
@@ -157,7 +151,7 @@ export function testOwnerDelegatedGrant() {
             });
             // 3. A third party (Bob) authors a RecordsWrite
             const bobRecordsWriteBytes = new TextEncoder().encode('message from Bob');
-            const bobRecordsWrite = yield RecordsWrite.create({
+            const bobRecordsWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(bob),
                 protocol,
                 protocolPath: 'foo', // this comes from `types` in protocol definition
@@ -165,51 +159,50 @@ export function testOwnerDelegatedGrant() {
                 data: bobRecordsWriteBytes
             });
             // 4. Sanity test that Bob's RecordsWrite cannot be written to Alice's DWN by itself
-            const unauthorizedRecordsWriteReply = yield dwn.processMessage(alice.did, bobRecordsWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
+            const unauthorizedRecordsWriteReply = await dwn.processMessage(alice.did, bobRecordsWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
             expect(unauthorizedRecordsWriteReply.status.code).toBe(401);
             // 5. Verify that App Y cannot write Bob's message in Alice's DWN by invoking the delegated grant for App X.
-            const appYAugmentedWrite = yield RecordsWrite.parse(bobRecordsWrite.message);
-            yield appYAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appY), appXGrant.dataEncodedMessage);
-            const appYWriteReply = yield dwn.processMessage(alice.did, appYAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
+            const appYAugmentedWrite = await RecordsWrite.parse(bobRecordsWrite.message);
+            await appYAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appY), appXGrant.dataEncodedMessage);
+            const appYWriteReply = await dwn.processMessage(alice.did, appYAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
             expect(appYWriteReply.status.code).toBe(400);
             expect(appYWriteReply.status.detail).toContain(DwnErrorCode.RecordsOwnerDelegatedGrantGrantedToAndOwnerSignatureMismatch);
             // 6. Verify that App X can successfully write Bob's message in Alice's DWN by invoking an owner-delegated grant
-            const appXAugmentedWrite = yield RecordsWrite.parse(bobRecordsWrite.message);
-            yield appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrant.dataEncodedMessage);
-            const appXWriteReply = yield dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
+            const appXAugmentedWrite = await RecordsWrite.parse(bobRecordsWrite.message);
+            await appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrant.dataEncodedMessage);
+            const appXWriteReply = await dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
             expect(appXWriteReply.status.code).toBe(202);
             // 7. Sanity verify the RecordsWrite written by App X
-            const recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQuery = await TestDataGenerator.generateRecordsQuery({
                 author: alice,
                 filter: { protocol }
             });
-            const recordsQueryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+            const recordsQueryReply = await dwn.processMessage(alice.did, recordsQuery.message);
             expect(recordsQueryReply.status.code).toBe(200);
-            expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+            expect(recordsQueryReply.entries?.length).toBe(1);
             const fetchedEntry = recordsQueryReply.entries[0];
             expect(fetchedEntry.encodedData).toBe(Encoder.bytesToBase64Url(bobRecordsWriteBytes));
-            const fetchedRecordsWrite = yield RecordsWrite.parse(fetchedEntry);
+            const fetchedRecordsWrite = await RecordsWrite.parse(fetchedEntry);
             expect(fetchedRecordsWrite.author).toBe(bob.did);
-        }));
-        it('should not allow entity using a non-delegated grant as an owner-delegated grant to invoke write', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+        });
+        it('should not allow entity using a non-delegated grant as an owner-delegated grant to invoke write', async () => {
             // scenario:
             // 1. Alice installs a protocol
             // 2. Alice creates a non-delegated grant for app X to write in the protocol
             // 3. A third party (Bob) authors a RecordsWrite
             // 4. Verify that App X cannot write Bob's message in Alice's DWN by invoking an non-delegated grant
             // 5. Sanity verify the RecordsWrite is not written by App X
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const appX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const appX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Alice installs a protocol
             const protocolDefinition = minimalProtocolDefinition;
             const protocol = minimalProtocolDefinition.protocol;
-            const protocolsConfig = yield ProtocolsConfigure.create({
+            const protocolsConfig = await ProtocolsConfigure.create({
                 signer: Jws.createSigner(alice),
                 definition: protocolDefinition
             });
-            const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // 2. Alice creates a non-delegated grant for app X to write in the protocol
             const scope = {
@@ -217,7 +210,7 @@ export function testOwnerDelegatedGrant() {
                 method: DwnMethodName.Write,
                 protocol
             };
-            const appXGrant = yield PermissionsProtocol.createGrant({
+            const appXGrant = await PermissionsProtocol.createGrant({
                 // delegated   : true, // intentionally commented out to show that this is not a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: appX.did,
@@ -226,7 +219,7 @@ export function testOwnerDelegatedGrant() {
             });
             // 3. A third party (Bob) authors a RecordsWrite
             const bobRecordsWriteBytes = new TextEncoder().encode('message from Bob');
-            const bobRecordsWrite = yield RecordsWrite.create({
+            const bobRecordsWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(bob),
                 protocol,
                 protocolPath: 'foo', // this comes from `types` in protocol definition
@@ -234,22 +227,21 @@ export function testOwnerDelegatedGrant() {
                 data: bobRecordsWriteBytes
             });
             // 4. Verify that App X cannot write Bob's message in Alice's DWN by invoking an non-delegated grant
-            const appXAugmentedWrite = yield RecordsWrite.parse(bobRecordsWrite.message);
-            yield appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrant.dataEncodedMessage);
-            const appXWriteReply = yield dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
+            const appXAugmentedWrite = await RecordsWrite.parse(bobRecordsWrite.message);
+            await appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrant.dataEncodedMessage);
+            const appXWriteReply = await dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
             expect(appXWriteReply.status.code).toBe(400);
             expect(appXWriteReply.status.detail).toContain(DwnErrorCode.RecordsOwnerDelegatedGrantNotADelegatedGrant);
             // 5. Sanity verify the RecordsWrite is not written by App X
-            const recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQuery = await TestDataGenerator.generateRecordsQuery({
                 author: alice,
                 filter: { protocol }
             });
-            const recordsQueryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+            const recordsQueryReply = await dwn.processMessage(alice.did, recordsQuery.message);
             expect(recordsQueryReply.status.code).toBe(200);
-            expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
-        }));
-        it('should fail if owner-delegated grant invoked for write has a mismatching interface method or protocol scope', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            expect(recordsQueryReply.entries?.length).toBe(0);
+        });
+        it('should fail if owner-delegated grant invoked for write has a mismatching interface method or protocol scope', async () => {
             // scenario:
             // 1. Alice installs a protocol
             // 2. Alice creates a delegated grant for app X to read in the protocol
@@ -258,17 +250,17 @@ export function testOwnerDelegatedGrant() {
             // 5. Verify that App X cannot write Bob's message in Alice's DWN by invoking a delegated grant for RecordsRead
             // 6. Verify that App X cannot write Bob's message in Alice's DWN by invoking a delegated grant for writing in another random protocol
             // 7. Sanity verify the RecordsWrite is not written by App X
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const appX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const appX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Alice installs a protocol
             const protocolDefinition = minimalProtocolDefinition;
             const protocol = minimalProtocolDefinition.protocol;
-            const protocolsConfig = yield ProtocolsConfigure.create({
+            const protocolsConfig = await ProtocolsConfigure.create({
                 signer: Jws.createSigner(alice),
                 definition: protocolDefinition
             });
-            const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // 2. Alice creates a delegated grant for app X to read in the protocol
             const readScope = {
@@ -276,7 +268,7 @@ export function testOwnerDelegatedGrant() {
                 method: DwnMethodName.Read,
                 protocol
             };
-            const appXGrantToRead = yield PermissionsProtocol.createGrant({
+            const appXGrantToRead = await PermissionsProtocol.createGrant({
                 delegated: true,
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: appX.did,
@@ -289,7 +281,7 @@ export function testOwnerDelegatedGrant() {
                 method: DwnMethodName.Write,
                 protocol: `random-protocol`
             };
-            const appXGrantToWriteInRandomProtocol = yield PermissionsProtocol.createGrant({
+            const appXGrantToWriteInRandomProtocol = await PermissionsProtocol.createGrant({
                 delegated: true,
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: appX.did,
@@ -298,7 +290,7 @@ export function testOwnerDelegatedGrant() {
             });
             // 4. A third party (Bob) authors a RecordsWrite
             const bobRecordsWriteBytes = new TextEncoder().encode('message from Bob');
-            const bobRecordsWrite = yield RecordsWrite.create({
+            const bobRecordsWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(bob),
                 protocol,
                 protocolPath: 'foo', // this comes from `types` in protocol definition
@@ -306,45 +298,44 @@ export function testOwnerDelegatedGrant() {
                 data: bobRecordsWriteBytes
             });
             // 5. Verify that App X cannot write Bob's message in Alice's DWN by invoking a delegated grant for RecordsRead
-            const appXAugmentedWrite = yield RecordsWrite.parse(bobRecordsWrite.message);
-            yield appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrantToRead.dataEncodedMessage);
-            const appXWriteReply = yield dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
+            const appXAugmentedWrite = await RecordsWrite.parse(bobRecordsWrite.message);
+            await appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrantToRead.dataEncodedMessage);
+            const appXWriteReply = await dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
             expect(appXWriteReply.status.code).toBe(401);
             expect(appXWriteReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationMethodMismatch);
             // 6. Verify that App X cannot write Bob's message in Alice's DWN by invoking a delegated grant for writing in another random protocol
-            const appXAugmentedWrite2 = yield RecordsWrite.parse(bobRecordsWrite.message);
-            yield appXAugmentedWrite2.signAsOwnerDelegate(Jws.createSigner(appX), appXGrantToWriteInRandomProtocol.dataEncodedMessage);
-            const appXWriteReply2 = yield dwn.processMessage(alice.did, appXAugmentedWrite2.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
+            const appXAugmentedWrite2 = await RecordsWrite.parse(bobRecordsWrite.message);
+            await appXAugmentedWrite2.signAsOwnerDelegate(Jws.createSigner(appX), appXGrantToWriteInRandomProtocol.dataEncodedMessage);
+            const appXWriteReply2 = await dwn.processMessage(alice.did, appXAugmentedWrite2.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
             expect(appXWriteReply2.status.code).toBe(401);
             expect(appXWriteReply2.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationScopeProtocolMismatch);
             // 7. Sanity verify the RecordsWrite is not written by App X
-            const recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQuery = await TestDataGenerator.generateRecordsQuery({
                 author: alice,
                 filter: { protocol }
             });
-            const recordsQueryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+            const recordsQueryReply = await dwn.processMessage(alice.did, recordsQuery.message);
             expect(recordsQueryReply.status.code).toBe(200);
-            expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
-        }));
-        it('should fail RecordsWrite if presented with an owner-delegated grant with invalid grantor signature', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            expect(recordsQueryReply.entries?.length).toBe(0);
+        });
+        it('should fail RecordsWrite if presented with an owner-delegated grant with invalid grantor signature', async () => {
             // scenario:
             // 1. Alice installs a protocol
             // 2. Alice creates a delegated grant for App X to write as Alice, but with invalid signature
             // 3. A third party (Bob) authors a RecordsWrite
             // 4. Verify that App X cannot write Bob's message in Alice's DWN by invoking an owner-delegated grant with invalid signature
             // 5. Sanity verify the RecordsWrite is not written by App X
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const appX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const appX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Alice installs a protocol
             const protocolDefinition = minimalProtocolDefinition;
             const protocol = minimalProtocolDefinition.protocol;
-            const protocolsConfig = yield ProtocolsConfigure.create({
+            const protocolsConfig = await ProtocolsConfigure.create({
                 signer: Jws.createSigner(alice),
                 definition: protocolDefinition
             });
-            const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // 2. Alice creates a delegated grant for App X to write as Alice, but with invalid signature
             const scope = {
@@ -352,7 +343,7 @@ export function testOwnerDelegatedGrant() {
                 method: DwnMethodName.Write,
                 protocol
             };
-            const appXGrant = yield PermissionsProtocol.createGrant({
+            const appXGrant = await PermissionsProtocol.createGrant({
                 delegated: true,
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: appX.did,
@@ -360,10 +351,10 @@ export function testOwnerDelegatedGrant() {
                 signer: Jws.createSigner(alice)
             });
             const appXGrantMessage = appXGrant.dataEncodedMessage;
-            appXGrantMessage.authorization.signature.signatures[0].signature = yield TestDataGenerator.randomSignatureString();
+            appXGrantMessage.authorization.signature.signatures[0].signature = await TestDataGenerator.randomSignatureString();
             // 3. A third party (Bob) authors a RecordsWrite
             const bobRecordsWriteBytes = new TextEncoder().encode('message from Bob');
-            const bobRecordsWrite = yield RecordsWrite.create({
+            const bobRecordsWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(bob),
                 protocol,
                 protocolPath: 'foo', // this comes from `types` in protocol definition
@@ -371,39 +362,38 @@ export function testOwnerDelegatedGrant() {
                 data: bobRecordsWriteBytes
             });
             // 4. Verify that App X cannot write Bob's message in Alice's DWN by invoking an owner-delegated grant with invalid signature
-            const appXAugmentedWrite = yield RecordsWrite.parse(bobRecordsWrite.message);
-            yield appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrantMessage);
-            const appXWriteReply = yield dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
+            const appXAugmentedWrite = await RecordsWrite.parse(bobRecordsWrite.message);
+            await appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrantMessage);
+            const appXWriteReply = await dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
             expect(appXWriteReply.status.code).toBe(401);
             expect(appXWriteReply.status.detail).toContain(DwnErrorCode.GeneralJwsVerifierInvalidSignature);
             // 5. Sanity verify the RecordsWrite is not written by App X
-            const recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQuery = await TestDataGenerator.generateRecordsQuery({
                 author: alice,
                 filter: { protocol }
             });
-            const recordsQueryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+            const recordsQueryReply = await dwn.processMessage(alice.did, recordsQuery.message);
             expect(recordsQueryReply.status.code).toBe(200);
-            expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
-        }));
-        it('should fail RecordsWrite if grant ID in owner signature payload and CID of owner-delegated grant are mismatching', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            expect(recordsQueryReply.entries?.length).toBe(0);
+        });
+        it('should fail RecordsWrite if grant ID in owner signature payload and CID of owner-delegated grant are mismatching', async () => {
             // scenario:
             // 1. Alice installs a protocol
             // 2. Creates two delegated grant for App X to write as Alice
             // 3. A third party (Bob) authors a RecordsWrite
             // 4. Verify that App X cannot write Bob's message in Alice's DWN by invoking an owner-delegated grant with the wrong ID
             // 5. Sanity verify the RecordsWrite is not written by App X
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const appX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const appX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Alice installs a protocol
             const protocolDefinition = minimalProtocolDefinition;
             const protocol = minimalProtocolDefinition.protocol;
-            const protocolsConfig = yield ProtocolsConfigure.create({
+            const protocolsConfig = await ProtocolsConfigure.create({
                 signer: Jws.createSigner(alice),
                 definition: protocolDefinition
             });
-            const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // 2. Creates two delegated grant for App X to write as Alice
             const scope = {
@@ -411,15 +401,15 @@ export function testOwnerDelegatedGrant() {
                 method: DwnMethodName.Write,
                 protocol
             };
-            const appXGrant = yield PermissionsProtocol.createGrant({
+            const appXGrant = await PermissionsProtocol.createGrant({
                 delegated: true,
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: appX.did,
                 scope: scope,
                 signer: Jws.createSigner(alice)
             });
-            yield Time.minimalSleep();
-            const appXGrant2 = yield PermissionsProtocol.createGrant({
+            await Time.minimalSleep();
+            const appXGrant2 = await PermissionsProtocol.createGrant({
                 delegated: true,
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: appX.did,
@@ -428,7 +418,7 @@ export function testOwnerDelegatedGrant() {
             });
             // 3. A third party (Bob) authors a RecordsWrite
             const bobRecordsWriteBytes = new TextEncoder().encode('message from Bob');
-            const bobRecordsWrite = yield RecordsWrite.create({
+            const bobRecordsWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(bob),
                 protocol,
                 protocolPath: 'foo', // this comes from `types` in protocol definition
@@ -436,23 +426,22 @@ export function testOwnerDelegatedGrant() {
                 data: bobRecordsWriteBytes
             });
             // 4. Verify that App X cannot write Bob's message in Alice's DWN by invoking an owner-delegated grant with the wrong ID
-            const appXAugmentedWrite = yield RecordsWrite.parse(bobRecordsWrite.message);
-            yield appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrant.dataEncodedMessage);
+            const appXAugmentedWrite = await RecordsWrite.parse(bobRecordsWrite.message);
+            await appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrant.dataEncodedMessage);
             appXAugmentedWrite.message.authorization.ownerDelegatedGrant = appXGrant2.dataEncodedMessage; // intentionally have a mismatching grant
-            const appXWriteReply = yield dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
+            const appXWriteReply = await dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
             expect(appXWriteReply.status.code).toBe(400);
             expect(appXWriteReply.status.detail).toContain(DwnErrorCode.RecordsOwnerDelegatedGrantCidMismatch);
             // 5. Sanity verify the RecordsWrite is not written by App X
-            const recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQuery = await TestDataGenerator.generateRecordsQuery({
                 author: alice,
                 filter: { protocol }
             });
-            const recordsQueryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+            const recordsQueryReply = await dwn.processMessage(alice.did, recordsQuery.message);
             expect(recordsQueryReply.status.code).toBe(200);
-            expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
-        }));
-        it('should fail RecordsWrite if owner-delegated grant is revoked', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            expect(recordsQueryReply.entries?.length).toBe(0);
+        });
+        it('should fail RecordsWrite if owner-delegated grant is revoked', async () => {
             // scenario:
             // 1. Alice installs a protocol
             // 2. Alice creates a delegated grant for App X to write as Alice
@@ -460,17 +449,17 @@ export function testOwnerDelegatedGrant() {
             // 4. A third party (Bob) authors a RecordsWrite
             // 5. Verify that App X cannot write Bob's message in Alice's DWN by invoking a revoked owner-delegated grant
             // 6. Sanity verify the RecordsWrite is not written by App X
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const appX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const appX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Alice installs a protocol
             const protocolDefinition = minimalProtocolDefinition;
             const protocol = minimalProtocolDefinition.protocol;
-            const protocolsConfig = yield ProtocolsConfigure.create({
+            const protocolsConfig = await ProtocolsConfigure.create({
                 signer: Jws.createSigner(alice),
                 definition: protocolDefinition
             });
-            const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // 2. Alice creates a delegated grant for App X to write as Alice
             const scope = {
@@ -478,7 +467,7 @@ export function testOwnerDelegatedGrant() {
                 method: DwnMethodName.Write,
                 protocol
             };
-            const appXGrant = yield PermissionsProtocol.createGrant({
+            const appXGrant = await PermissionsProtocol.createGrant({
                 delegated: true,
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: appX.did,
@@ -486,19 +475,19 @@ export function testOwnerDelegatedGrant() {
                 signer: Jws.createSigner(alice)
             });
             const grantDataStream = DataStream.fromBytes(appXGrant.permissionGrantBytes);
-            const permissionGrantWriteReply = yield dwn.processMessage(alice.did, appXGrant.recordsWrite.message, { dataStream: grantDataStream });
+            const permissionGrantWriteReply = await dwn.processMessage(alice.did, appXGrant.recordsWrite.message, { dataStream: grantDataStream });
             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(appXGrant.dataEncodedMessage),
+                grant: PermissionGrant.parse(appXGrant.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);
             // 4. A third party (Bob) authors a RecordsWrite
             const bobRecordsWriteBytes = new TextEncoder().encode('message from Bob');
-            const bobRecordsWrite = yield RecordsWrite.create({
+            const bobRecordsWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(bob),
                 protocol,
                 protocolPath: 'foo', // this comes from `types` in protocol definition
@@ -506,39 +495,38 @@ export function testOwnerDelegatedGrant() {
                 data: bobRecordsWriteBytes
             });
             // 5. Verify that App X cannot write Bob's message in Alice's DWN by invoking a revoked owner-delegated grant
-            const appXAugmentedWrite = yield RecordsWrite.parse(bobRecordsWrite.message);
-            yield appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrant.dataEncodedMessage);
-            const appXWriteReply = yield dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
+            const appXAugmentedWrite = await RecordsWrite.parse(bobRecordsWrite.message);
+            await appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrant.dataEncodedMessage);
+            const appXWriteReply = await dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
             expect(appXWriteReply.status.code).toBe(401);
             expect(appXWriteReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationGrantRevoked);
             // 6. Sanity verify the RecordsWrite is not written by App X
-            const recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQuery = await TestDataGenerator.generateRecordsQuery({
                 author: alice,
                 filter: { protocol }
             });
-            const recordsQueryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+            const recordsQueryReply = await dwn.processMessage(alice.did, recordsQuery.message);
             expect(recordsQueryReply.status.code).toBe(200);
-            expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
-        }));
-        it('should fail RecordsWrite if owner-delegated grant is expired', () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            expect(recordsQueryReply.entries?.length).toBe(0);
+        });
+        it('should fail RecordsWrite if owner-delegated grant is expired', async () => {
             // scenario:
             // 1. Alice installs a protocol
             // 2. Alice creates a delegated grant for App X to write as Alice, but make it expired
             // 3. A third party (Bob) authors a RecordsWrite
             // 4. Verify that App X cannot write Bob's message in Alice's DWN by invoking an expired owner-delegated grant
             // 5. Sanity verify the RecordsWrite is not written by App X
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const appX = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const appX = await TestDataGenerator.generateDidKeyPersona();
             // 1. Alice installs a protocol
             const protocolDefinition = minimalProtocolDefinition;
             const protocol = minimalProtocolDefinition.protocol;
-            const protocolsConfig = yield ProtocolsConfigure.create({
+            const protocolsConfig = await ProtocolsConfigure.create({
                 signer: Jws.createSigner(alice),
                 definition: protocolDefinition
             });
-            const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // 2. Alice creates a delegated grant for App X to write as Alice, but make it expired
             const scope = {
@@ -546,7 +534,7 @@ export function testOwnerDelegatedGrant() {
                 method: DwnMethodName.Write,
                 protocol
             };
-            const appXGrant = yield PermissionsProtocol.createGrant({
+            const appXGrant = await PermissionsProtocol.createGrant({
                 delegated: true,
                 dateExpires: Time.getCurrentTimestamp(), // intentionally set to current time to make it expired immediately
                 grantedTo: appX.did,
@@ -555,7 +543,7 @@ export function testOwnerDelegatedGrant() {
             });
             // 3. A third party (Bob) authors a RecordsWrite
             const bobRecordsWriteBytes = new TextEncoder().encode('message from Bob');
-            const bobRecordsWrite = yield RecordsWrite.create({
+            const bobRecordsWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(bob),
                 protocol,
                 protocolPath: 'foo', // this comes from `types` in protocol definition
@@ -563,20 +551,20 @@ export function testOwnerDelegatedGrant() {
                 data: bobRecordsWriteBytes
             });
             // 4. Verify that App X cannot write Bob's message in Alice's DWN by invoking an expired owner-delegated grant
-            const appXAugmentedWrite = yield RecordsWrite.parse(bobRecordsWrite.message);
-            yield appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrant.dataEncodedMessage);
-            const appXWriteReply = yield dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
+            const appXAugmentedWrite = await RecordsWrite.parse(bobRecordsWrite.message);
+            await appXAugmentedWrite.signAsOwnerDelegate(Jws.createSigner(appX), appXGrant.dataEncodedMessage);
+            const appXWriteReply = await dwn.processMessage(alice.did, appXAugmentedWrite.message, { dataStream: DataStream.fromBytes(bobRecordsWriteBytes) });
             expect(appXWriteReply.status.code).toBe(401);
             expect(appXWriteReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationGrantExpired);
             // 5. Sanity verify the RecordsWrite is not written by App X
-            const recordsQuery = yield TestDataGenerator.generateRecordsQuery({
+            const recordsQuery = await TestDataGenerator.generateRecordsQuery({
                 author: alice,
                 filter: { protocol }
             });
-            const recordsQueryReply = yield dwn.processMessage(alice.did, recordsQuery.message);
+            const recordsQueryReply = await dwn.processMessage(alice.did, recordsQuery.message);
             expect(recordsQueryReply.status.code).toBe(200);
-            expect((_a = recordsQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(0);
-        }));
+            expect(recordsQueryReply.entries?.length).toBe(0);
+        });
     });
 }
 //# sourceMappingURL=owner-delegated-grant.spec.js.map