@enbox/dwn-sdk-js 0.0.6 → 0.0.8

package/dist/esm/tests/handlers/protocols-configure.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 dexProtocolDefinition from '../vectors/protocol-definitions/dex.json' with { type: 'json' };
 import minimalProtocolDefinition from '../vectors/protocol-definitions/minimal.json' with { type: 'json' };
 import sinon from 'sinon';
@@ -15,7 +6,7 @@ import { lexicographicalCompare } from '../../src/utils/string.js';
 import { Message } from '../../src/core/message.js';
 import { ProtocolAction } from '../../src/types/protocols-types.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 { TestStubGenerator } from '../utils/test-stub-generator.js';
 import { Time } from '../../src/utils/time.js';
@@ -29,202 +20,209 @@ export function testProtocolsConfigureHandler() {
         let dataStore;
         let resumableTaskStore;
         let stateIndex;
-        let eventStream;
+        let eventLog;
         let dwn;
         describe('functional tests', () => {
             // important to follow the `before` and `after` pattern to initialize and clean the stores in tests
             // so that different test suites can reuse the same backend store for testing
-            beforeAll(() => __awaiter(this, void 0, void 0, function* () {
+            beforeAll(async () => {
                 didResolver = new UniversalResolver({ didResolvers: [DidKey] });
                 const stores = TestStores.get();
                 messageStore = stores.messageStore;
                 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();
-            }));
-            it('should allow a protocol definition with schema or dataFormat omitted', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                await messageStore.clear();
+                await dataStore.clear();
+                await resumableTaskStore.clear();
+                await stateIndex.clear();
+            });
+            afterAll(async () => {
+                await dwn.close();
+            });
+            it('should allow a protocol definition with schema or dataFormat omitted', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const protocolDefinition = minimalProtocolDefinition;
-                const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition,
                 });
-                const reply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                const reply = await dwn.processMessage(alice.did, protocolsConfig.message);
                 expect(reply.status.code).toBe(202);
-            }));
-            it('should return 400 if more than 1 signature is provided in `authorization`', () => __awaiter(this, void 0, void 0, function* () {
-                const { author, message, protocolsConfigure } = yield TestDataGenerator.generateProtocolsConfigure();
+            });
+            it('should return 400 if more than 1 signature is provided in `authorization`', async () => {
+                const { author, message, protocolsConfigure } = await TestDataGenerator.generateProtocolsConfigure();
                 const tenant = author.did;
                 // intentionally create more than one signature, which is not allowed
-                const extraRandomPersona = yield TestDataGenerator.generatePersona();
+                const extraRandomPersona = await TestDataGenerator.generatePersona();
                 const signer1 = Jws.createSigner(author);
                 const signer2 = Jws.createSigner(extraRandomPersona);
                 const signaturePayloadBytes = Encoder.objectToBytes(protocolsConfigure.signaturePayload);
-                const jwsBuilder = yield GeneralJwsBuilder.create(signaturePayloadBytes, [signer1, signer2]);
+                const jwsBuilder = await GeneralJwsBuilder.create(signaturePayloadBytes, [signer1, signer2]);
                 message.authorization = { signature: jwsBuilder.getJws() };
                 TestStubGenerator.stubDidResolver(didResolver, [author]);
-                const reply = yield dwn.processMessage(tenant, message);
+                const reply = await dwn.processMessage(tenant, message);
                 expect(reply.status.code).toBe(400);
                 expect(reply.status.detail).toContain('expected no more than 1 signature');
-            }));
-            it('should return 401 if auth fails', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const { message } = yield TestDataGenerator.generateProtocolsConfigure({ author: alice });
+            });
+            it('should return 401 if auth fails', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const { message } = await TestDataGenerator.generateProtocolsConfigure({ author: alice });
                 // use a bad signature to fail authentication
-                const badSignature = yield TestDataGenerator.randomSignatureString();
+                const badSignature = await TestDataGenerator.randomSignatureString();
                 message.authorization.signature.signatures[0].signature = badSignature;
-                const reply = yield dwn.processMessage(alice.did, message);
+                const reply = await dwn.processMessage(alice.did, message);
                 expect(reply.status.code).toBe(401);
                 expect(reply.status.detail).toContain(DwnErrorCode.GeneralJwsVerifierInvalidSignature);
-            }));
-            it('should store all protocol versions and query should only return the latest', () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should store all protocol versions and query should only return the latest', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const protocolDefinition = minimalProtocolDefinition;
-                const oldProtocolsConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                const oldProtocolsConfigure = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition,
                 });
-                yield Time.minimalSleep();
-                const middleProtocolsConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                await Time.minimalSleep();
+                const middleProtocolsConfigure = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition,
                 });
                 // first ProtocolsConfigure
-                const reply1 = yield dwn.processMessage(alice.did, middleProtocolsConfigure.message);
+                const reply1 = await dwn.processMessage(alice.did, middleProtocolsConfigure.message);
                 expect(reply1.status.code).toBe(202);
                 // older messages are also accepted (stored as historical versions)
-                const reply2 = yield dwn.processMessage(alice.did, oldProtocolsConfigure.message);
+                const reply2 = await dwn.processMessage(alice.did, oldProtocolsConfigure.message);
                 expect(reply2.status.code).toBe(202);
                 // newer message is also accepted and becomes the latest
-                const newProtocolsConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                const newProtocolsConfigure = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition,
                 });
-                const reply3 = yield dwn.processMessage(alice.did, newProtocolsConfigure.message);
+                const reply3 = await dwn.processMessage(alice.did, newProtocolsConfigure.message);
                 expect(reply3.status.code).toBe(202);
                 // only the newest protocol should be returned by query (ProtocolsQuery returns only latest)
-                const queryMessageData = yield TestDataGenerator.generateProtocolsQuery({
+                const queryMessageData = await TestDataGenerator.generateProtocolsQuery({
                     author: alice,
                     filter: { protocol: protocolDefinition.protocol }
                 });
-                const queryReply = yield dwn.processMessage(alice.did, queryMessageData.message);
+                const queryReply = await dwn.processMessage(alice.did, queryMessageData.message);
                 expect(queryReply.status.code).toBe(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
-            }));
-            it('should store all protocol versions with identical timestamps and query should only return the newest (by CID tiebreak)', () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                expect(queryReply.entries?.length).toBe(1);
+            });
+            it('should store all protocol versions with identical timestamps and query should only return the newest (by CID tiebreak)', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // Alter each protocol slightly to create lexicographic difference between them
-                const protocolDefinition1 = Object.assign(Object.assign({}, minimalProtocolDefinition), { types: Object.assign(Object.assign({}, minimalProtocolDefinition.types), { foo1: { dataFormats: ['bar1'] } }) });
-                const protocolDefinition2 = Object.assign(Object.assign({}, minimalProtocolDefinition), { types: Object.assign(Object.assign({}, minimalProtocolDefinition.types), { foo2: { dataFormats: ['bar2'] } }) });
-                const protocolDefinition3 = Object.assign(Object.assign({}, minimalProtocolDefinition), { types: Object.assign(Object.assign({}, minimalProtocolDefinition.types), { foo3: { dataFormats: ['bar3'] } }) });
+                const protocolDefinition1 = {
+                    ...minimalProtocolDefinition,
+                    types: { ...minimalProtocolDefinition.types, foo1: { dataFormats: ['bar1'] } }
+                };
+                const protocolDefinition2 = {
+                    ...minimalProtocolDefinition,
+                    types: { ...minimalProtocolDefinition.types, foo2: { dataFormats: ['bar2'] } }
+                };
+                const protocolDefinition3 = {
+                    ...minimalProtocolDefinition,
+                    types: { ...minimalProtocolDefinition.types, foo3: { dataFormats: ['bar3'] } }
+                };
                 // Create three `ProtocolsConfigure` with identical timestamp
-                const messageData1 = yield TestDataGenerator.generateProtocolsConfigure({
+                const messageData1 = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition: protocolDefinition1
                 });
-                const messageData2 = yield TestDataGenerator.generateProtocolsConfigure({
+                const messageData2 = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition: protocolDefinition2,
                     messageTimestamp: messageData1.message.descriptor.messageTimestamp
                 });
-                const messageData3 = yield TestDataGenerator.generateProtocolsConfigure({
+                const messageData3 = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition: protocolDefinition3,
                     messageTimestamp: messageData1.message.descriptor.messageTimestamp
                 });
                 const messageDataWithCid = [];
                 for (const messageData of [messageData1, messageData2, messageData3]) {
-                    const cid = yield Message.getCid(messageData.message);
-                    messageDataWithCid.push(Object.assign({ cid }, messageData));
+                    const cid = await Message.getCid(messageData.message);
+                    messageDataWithCid.push({ cid, ...messageData });
                 }
                 // sort the message in lexicographic order
                 const [lowestProtocolsConfigure, middleProtocolsConfigure, highestProtocolsConfigure] = messageDataWithCid.sort((messageDataA, messageDataB) => { return lexicographicalCompare(messageDataA.cid, messageDataB.cid); });
                 // write the protocol with the middle lexicographic value
-                const reply1 = yield dwn.processMessage(alice.did, middleProtocolsConfigure.message);
+                const reply1 = await dwn.processMessage(alice.did, middleProtocolsConfigure.message);
                 expect(reply1.status.code).toBe(202);
                 // all versions are accepted (stored as historical versions)
-                const reply2 = yield dwn.processMessage(alice.did, lowestProtocolsConfigure.message);
+                const reply2 = await dwn.processMessage(alice.did, lowestProtocolsConfigure.message);
                 expect(reply2.status.code).toBe(202);
                 // highest lexicographic value is also accepted and becomes the latest
-                const reply3 = yield dwn.processMessage(alice.did, highestProtocolsConfigure.message);
+                const reply3 = await dwn.processMessage(alice.did, highestProtocolsConfigure.message);
                 expect(reply3.status.code).toBe(202);
                 // query should only return the latest protocol definition (highest by CID tiebreak)
-                const queryMessageData = yield TestDataGenerator.generateProtocolsQuery({
+                const queryMessageData = await TestDataGenerator.generateProtocolsQuery({
                     author: alice,
                     filter: { protocol: protocolDefinition1.protocol }
                 });
-                const queryReply = yield dwn.processMessage(alice.did, queryMessageData.message);
+                const queryReply = await dwn.processMessage(alice.did, queryMessageData.message);
                 expect(queryReply.status.code).toBe(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
-            }));
-            it('should return 400 if protocol is not normalized', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                expect(queryReply.entries?.length).toBe(1);
+            });
+            it('should return 400 if protocol is not normalized', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // query for non-normalized protocol
-                const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition: minimalProtocolDefinition
                 });
                 // overwrite protocol because #create auto-normalizes protocol
                 protocolsConfig.message.descriptor.definition.protocol = 'example.com/';
                 // Re-create auth because we altered the descriptor after signing
-                protocolsConfig.message.authorization = yield Message.createAuthorization({
+                protocolsConfig.message.authorization = await Message.createAuthorization({
                     descriptor: protocolsConfig.message.descriptor,
                     signer: Jws.createSigner(alice)
                 });
                 // Send records write message
-                const reply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                const reply = await dwn.processMessage(alice.did, protocolsConfig.message);
                 expect(reply.status.code).toBe(400);
                 expect(reply.status.detail).toContain(DwnErrorCode.UrlProtocolNotNormalized);
-            }));
-            it('should return 400 if schema is not normalized', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should return 400 if schema is not normalized', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const protocolDefinition = dexProtocolDefinition;
-                const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition,
                 });
                 // overwrite schema because #create auto-normalizes schema
                 protocolsConfig.message.descriptor.definition.types.ask.schema = 'ask';
                 // Re-create auth because we altered the descriptor after signing
-                protocolsConfig.message.authorization = yield Message.createAuthorization({
+                protocolsConfig.message.authorization = await Message.createAuthorization({
                     descriptor: protocolsConfig.message.descriptor,
                     signer: Jws.createSigner(alice)
                 });
                 // Send records write message
-                const reply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                const reply = await dwn.processMessage(alice.did, protocolsConfig.message);
                 expect(reply.status.code).toBe(400);
                 expect(reply.status.detail).toContain(DwnErrorCode.UrlSchemaNotNormalized);
-            }));
-            it('rejects non-tenant non-granted ProtocolsConfigures with 401', () => __awaiter(this, void 0, void 0, function* () {
+            });
+            it('rejects non-tenant non-granted ProtocolsConfigures with 401', async () => {
                 // Bob tries to ProtocolsConfigure to Alice's DWN without a permission grant
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 const protocolDefinition = dexProtocolDefinition;
-                const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                     author: bob,
                     protocolDefinition,
                 });
-                const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                 expect(protocolsConfigureReply.status.code).toBe(401);
                 expect(protocolsConfigureReply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureAuthorizationFailed);
-            }));
-            it('should reject ProtocolsConfigure with action rule containing duplicated actor (`who` or `who` + `of` combination) within a rule set', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject ProtocolsConfigure with action rule containing duplicated actor (`who` or `who` + `of` combination) within a rule set', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const protocolDefinition = {
                     protocol: 'http://foo-bar',
                     published: true,
@@ -254,12 +252,12 @@ export function testProtocolsConfigureHandler() {
                     messageTimestamp: Time.getCurrentTimestamp(),
                     definition: protocolDefinition
                 };
-                const authorization = yield Message.createAuthorization({
+                const authorization = await Message.createAuthorization({
                     descriptor,
                     signer: Jws.createSigner(alice)
                 });
                 const protocolsConfigureMessage = { descriptor, authorization };
-                const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
+                const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfigureMessage);
                 expect(protocolsConfigureReply.status.code).toBe(400);
                 expect(protocolsConfigureReply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureDuplicateActorInRuleSet);
                 // similar test as above but with `of` property
@@ -296,17 +294,17 @@ export function testProtocolsConfigureHandler() {
                     messageTimestamp: Time.getCurrentTimestamp(),
                     definition: protocolDefinition2
                 };
-                const authorization2 = yield Message.createAuthorization({
+                const authorization2 = await Message.createAuthorization({
                     descriptor: descriptor2,
                     signer: Jws.createSigner(alice)
                 });
                 const protocolsConfigureMessage2 = { descriptor: descriptor2, authorization: authorization2 };
-                const protocolsConfigure2Reply = yield dwn.processMessage(alice.did, protocolsConfigureMessage2);
+                const protocolsConfigure2Reply = await dwn.processMessage(alice.did, protocolsConfigureMessage2);
                 expect(protocolsConfigure2Reply.status.code).toBe(400);
                 expect(protocolsConfigure2Reply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureDuplicateActorInRuleSet);
-            }));
-            it('should reject ProtocolsConfigure with action rule containing duplicated role within a rule set', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject ProtocolsConfigure with action rule containing duplicated role within a rule set', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const protocolDefinition = {
                     protocol: 'http://foo',
                     published: true,
@@ -340,17 +338,17 @@ export function testProtocolsConfigureHandler() {
                     messageTimestamp: Time.getCurrentTimestamp(),
                     definition: protocolDefinition
                 };
-                const authorization = yield Message.createAuthorization({
+                const authorization = await Message.createAuthorization({
                     descriptor,
                     signer: Jws.createSigner(alice)
                 });
                 const protocolsConfigureMessage = { descriptor, authorization };
-                const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
+                const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfigureMessage);
                 expect(protocolsConfigureReply.status.code).toBe(400);
                 expect(protocolsConfigureReply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureDuplicateRoleInRuleSet);
-            }));
-            it('should reject ProtocolsConfigure with action rule `of` pointing to a sibling type (not an ancestor)', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject ProtocolsConfigure with action rule `of` pointing to a sibling type (not an ancestor)', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // `bar` and `baz` are siblings under `foo`, so `baz` action rule cannot reference `of: 'foo/bar'`
                 const protocolDefinition = {
                     protocol: 'http://example.com/sibling-of-test',
@@ -382,17 +380,17 @@ export function testProtocolsConfigureHandler() {
                     messageTimestamp: Time.getCurrentTimestamp(),
                     definition: protocolDefinition
                 };
-                const authorization = yield Message.createAuthorization({
+                const authorization = await Message.createAuthorization({
                     descriptor,
                     signer: Jws.createSigner(alice)
                 });
                 const protocolsConfigureMessage = { descriptor, authorization };
-                const reply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
+                const reply = await dwn.processMessage(alice.did, protocolsConfigureMessage);
                 expect(reply.status.code).toBe(400);
                 expect(reply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureInvalidActionOfNotAnAncestor);
-            }));
-            it('should reject ProtocolsConfigure with action rule `of` pointing to an unrelated type', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject ProtocolsConfigure with action rule `of` pointing to an unrelated type', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // `comment` is a top-level type unrelated to the nested `thread/reply` path
                 const protocolDefinition = {
                     protocol: 'http://example.com/unrelated-of-test',
@@ -423,17 +421,17 @@ export function testProtocolsConfigureHandler() {
                     messageTimestamp: Time.getCurrentTimestamp(),
                     definition: protocolDefinition
                 };
-                const authorization = yield Message.createAuthorization({
+                const authorization = await Message.createAuthorization({
                     descriptor,
                     signer: Jws.createSigner(alice)
                 });
                 const protocolsConfigureMessage = { descriptor, authorization };
-                const reply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
+                const reply = await dwn.processMessage(alice.did, protocolsConfigureMessage);
                 expect(reply.status.code).toBe(400);
                 expect(reply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureInvalidActionOfNotAnAncestor);
-            }));
-            it('should accept ProtocolsConfigure with action rule `of` pointing to itself (same protocol path)', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should accept ProtocolsConfigure with action rule `of` pointing to itself (same protocol path)', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // `of` pointing to the same protocol path is valid: "the author of this record can update it"
                 const protocolDefinition = {
                     protocol: 'http://example.com/self-of-test',
@@ -456,15 +454,15 @@ export function testProtocolsConfigureHandler() {
                         }
                     }
                 };
-                const protocolsConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolsConfigure = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition,
                 });
-                const reply = yield dwn.processMessage(alice.did, protocolsConfigure.message);
+                const reply = await dwn.processMessage(alice.did, protocolsConfigure.message);
                 expect(reply.status.code).toBe(202);
-            }));
-            it('should accept ProtocolsConfigure with action rule `of` pointing to a valid ancestor', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should accept ProtocolsConfigure with action rule `of` pointing to a valid ancestor', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // `of: 'thread'` is a valid ancestor of `thread/reply/reaction`
                 const protocolDefinition = {
                     protocol: 'http://example.com/valid-ancestor-of-test',
@@ -497,138 +495,147 @@ export function testProtocolsConfigureHandler() {
                         }
                     }
                 };
-                const protocolsConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolsConfigure = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition,
                 });
-                const reply = yield dwn.processMessage(alice.did, protocolsConfigure.message);
+                const reply = await dwn.processMessage(alice.did, protocolsConfigure.message);
                 expect(reply.status.code).toBe(202);
-            }));
+            });
             describe('Grant authorization', () => {
-                it('allows an external party to ProtocolsConfigure only if they have a valid grant', () => __awaiter(this, void 0, void 0, function* () {
+                it('allows an external party to ProtocolsConfigure only if they have a valid grant', async () => {
                     // scenario:
                     // 1. Alice grants Bob the access to ProtocolsConfigure on her DWN
                     // 2. Verify Bob can perform a ProtocolsConfigure
                     // 3. Verify that Mallory cannot to use Bob's permission grant to gain access to Alice's DWN
                     // 4. Alice revokes Bob's grant
                     // 5. Verify Bob cannot perform ProtocolsConfigure with the revoked grant
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
-                    const mallory = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
+                    const mallory = await TestDataGenerator.generateDidKeyPersona();
                     // 1. Alice grants Bob the access to ProtocolsConfigure on her DWN
-                    const permissionGrant = yield PermissionsProtocol.createGrant({
+                    const permissionGrant = await PermissionsProtocol.createGrant({
                         signer: Jws.createSigner(alice),
                         grantedTo: bob.did,
                         dateExpires: Time.createOffsetTimestamp({ seconds: 60 * 60 * 24 }),
                         scope: { interface: DwnInterfaceName.Protocols, method: DwnMethodName.Configure }
                     });
                     const dataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
-                    const grantRecordsWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream });
+                    const grantRecordsWriteReply = await dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream });
                     expect(grantRecordsWriteReply.status.code).toBe(202);
                     // 2. Verify Bob can perform a ProtocolsConfigure
                     const permissionGrantId = permissionGrant.recordsWrite.message.recordId;
-                    const protocolsConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolsConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         permissionGrantId,
                         author: bob,
                         protocolDefinition: minimalProtocolDefinition
                     });
-                    const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigure.message);
+                    const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfigure.message);
                     expect(protocolsConfigureReply.status.code).toBe(202);
                     // 3. Verify that Mallory cannot to use Bob's permission grant to gain access to Alice's DWN
-                    const malloryProtocolsQuery = yield TestDataGenerator.generateProtocolsConfigure({
+                    const malloryProtocolsQuery = await TestDataGenerator.generateProtocolsConfigure({
                         permissionGrantId,
                         author: mallory,
                         protocolDefinition: minimalProtocolDefinition
                     });
-                    const malloryProtocolsQueryReply = yield dwn.processMessage(alice.did, malloryProtocolsQuery.message);
+                    const malloryProtocolsQueryReply = await dwn.processMessage(alice.did, malloryProtocolsQuery.message);
                     expect(malloryProtocolsQueryReply.status.code).toBe(401);
                     expect(malloryProtocolsQueryReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationNotGrantedToAuthor);
                     // 4. Alice revokes Bob's grant
-                    const revokeWrite = yield PermissionsProtocol.createRevocation({
+                    const revokeWrite = await PermissionsProtocol.createRevocation({
                         signer: Jws.createSigner(alice),
-                        grant: yield PermissionGrant.parse(permissionGrant.dataEncodedMessage),
+                        grant: PermissionGrant.parse(permissionGrant.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);
                     // 5. Verify Bob cannot perform ProtocolsQuery with the revoked grant
-                    const unauthorizedProtocolsConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const unauthorizedProtocolsConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         permissionGrantId,
                         author: bob,
-                        protocolDefinition: Object.assign(Object.assign({}, minimalProtocolDefinition), { protocol: 'https://example.com/protocol/another-protocol' })
+                        protocolDefinition: {
+                            ...minimalProtocolDefinition,
+                            protocol: 'https://example.com/protocol/another-protocol'
+                        }
                     });
-                    const unauthorizedProtocolsConfigureReply = yield dwn.processMessage(alice.did, unauthorizedProtocolsConfigure.message);
+                    const unauthorizedProtocolsConfigureReply = await dwn.processMessage(alice.did, unauthorizedProtocolsConfigure.message);
                     expect(unauthorizedProtocolsConfigureReply.status.code).toBe(401);
                     expect(unauthorizedProtocolsConfigureReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationGrantRevoked);
-                }));
-                it('should allow to scope a ProtocolsConfigure to a specific protocol', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should allow to scope a ProtocolsConfigure to a specific protocol', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     // Alice grants Bob the access to ProtocolsConfigure on her DWN for a specific protocol
-                    const permissionGrant = yield PermissionsProtocol.createGrant({
+                    const permissionGrant = await PermissionsProtocol.createGrant({
                         signer: Jws.createSigner(alice),
                         grantedTo: bob.did,
                         dateExpires: Time.createOffsetTimestamp({ seconds: 60 * 60 * 24 }),
                         scope: { interface: DwnInterfaceName.Protocols, method: DwnMethodName.Configure, protocol: 'https://example.com/protocol/allowed' }
                     });
                     const dataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
-                    const grantRecordsWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream });
+                    const grantRecordsWriteReply = await dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream });
                     expect(grantRecordsWriteReply.status.code).toBe(202);
                     // Bob tries to ProtocolsConfigure to Alice's DWN for the allowed protocol
-                    const protocolConfigureAllowed = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigureAllowed = await TestDataGenerator.generateProtocolsConfigure({
                         author: bob,
-                        protocolDefinition: Object.assign(Object.assign({}, minimalProtocolDefinition), { protocol: 'https://example.com/protocol/allowed' }),
+                        protocolDefinition: {
+                            ...minimalProtocolDefinition,
+                            protocol: 'https://example.com/protocol/allowed'
+                        },
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId
                     });
-                    const protocolConfigureAllowedReply = yield dwn.processMessage(alice.did, protocolConfigureAllowed.message);
+                    const protocolConfigureAllowedReply = await dwn.processMessage(alice.did, protocolConfigureAllowed.message);
                     expect(protocolConfigureAllowedReply.status.code).toBe(202);
                     // Bob tries to ProtocolsConfigure to Alice's DWN for a different protocol
-                    const protocolConfigureNotAllowed = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigureNotAllowed = await TestDataGenerator.generateProtocolsConfigure({
                         author: bob,
-                        protocolDefinition: Object.assign(Object.assign({}, minimalProtocolDefinition), { protocol: 'https://example.com/protocol/not-allowed' }),
+                        protocolDefinition: {
+                            ...minimalProtocolDefinition,
+                            protocol: 'https://example.com/protocol/not-allowed'
+                        },
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId
                     });
-                    const protocolConfigureNotAllowedReply = yield dwn.processMessage(alice.did, protocolConfigureNotAllowed.message);
+                    const protocolConfigureNotAllowedReply = await dwn.processMessage(alice.did, protocolConfigureNotAllowed.message);
                     expect(protocolConfigureNotAllowedReply.status.code).toBe(401);
-                }));
+                });
             });
             describe('state index', () => {
-                it('should add event for ProtocolsConfigure', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const { message } = yield TestDataGenerator.generateProtocolsConfigure({ author: alice });
-                    const reply = yield dwn.processMessage(alice.did, message);
+                it('should add event for ProtocolsConfigure', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const { message } = await TestDataGenerator.generateProtocolsConfigure({ author: alice });
+                    const reply = await dwn.processMessage(alice.did, message);
                     expect(reply.status.code).toBe(202);
-                    const events = yield stateIndex.getLeaves(alice.did, []);
+                    const events = await stateIndex.getLeaves(alice.did, []);
                     expect(events.length).toBe(1);
-                    const messageCid = yield Message.getCid(message);
+                    const messageCid = await Message.getCid(message);
                     expect(events[0]).toBe(messageCid);
-                }));
-                it('should retain all ProtocolsConfigure events for protocol versioning', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const oldestWrite = yield TestDataGenerator.generateProtocolsConfigure({ author: alice, protocolDefinition: minimalProtocolDefinition });
-                    yield Time.minimalSleep();
-                    const newestWrite = yield TestDataGenerator.generateProtocolsConfigure({ author: alice, protocolDefinition: minimalProtocolDefinition });
-                    let reply = yield dwn.processMessage(alice.did, oldestWrite.message);
+                });
+                it('should retain all ProtocolsConfigure events for protocol versioning', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const oldestWrite = await TestDataGenerator.generateProtocolsConfigure({ author: alice, protocolDefinition: minimalProtocolDefinition });
+                    await Time.minimalSleep();
+                    const newestWrite = await TestDataGenerator.generateProtocolsConfigure({ author: alice, protocolDefinition: minimalProtocolDefinition });
+                    let reply = await dwn.processMessage(alice.did, oldestWrite.message);
                     expect(reply.status.code).toBe(202);
-                    reply = yield dwn.processMessage(alice.did, newestWrite.message);
+                    reply = await dwn.processMessage(alice.did, newestWrite.message);
                     expect(reply.status.code).toBe(202);
-                    const events = yield stateIndex.getLeaves(alice.did, []);
+                    const events = await stateIndex.getLeaves(alice.did, []);
                     expect(events.length).toBe(2);
-                    const oldestMessageCid = yield Message.getCid(oldestWrite.message);
-                    const newestMessageCid = yield Message.getCid(newestWrite.message);
+                    const oldestMessageCid = await Message.getCid(oldestWrite.message);
+                    const newestMessageCid = await Message.getCid(newestWrite.message);
                     expect(events).toContain(oldestMessageCid);
                     expect(events).toContain(newestMessageCid);
-                }));
+                });
             });
             describe('temporal protocol versioning', () => {
-                it('should authorize records created under v1 even after re-configuring to v2 that removes the type', () => __awaiter(this, void 0, void 0, function* () {
+                it('should authorize records created under v1 even after re-configuring to v2 that removes the type', async () => {
                     // scenario:
                     // 1. Alice installs protocol v1 with types `post` and `comment`
                     // 2. Alice writes a `post` record under v1
                     // 3. Alice re-configures the protocol to v2 which removes the `comment` type
                     // 4. Alice should still be able to read the v1 `post` record
                     // 5. Alice should still be able to update the v1 `post` record (governed by v1 definition)
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // v1: has `post` and `comment` types
                     const protocolUri = 'https://example.com/versioned-protocol';
                     const protocolDefinitionV1 = {
@@ -647,24 +654,24 @@ export function testProtocolsConfigureHandler() {
                             }
                         }
                     };
-                    const configureV1 = yield TestDataGenerator.generateProtocolsConfigure({
+                    const configureV1 = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: protocolDefinitionV1,
                     });
-                    const configureV1Reply = yield dwn.processMessage(alice.did, configureV1.message);
+                    const configureV1Reply = await dwn.processMessage(alice.did, configureV1.message);
                     expect(configureV1Reply.status.code).toBe(202);
                     // write a `post` record under v1
-                    const postRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const postRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolUri,
                         protocolPath: 'post',
                         schema: 'https://example.com/post',
                         dataFormat: 'application/json',
                     });
-                    const postReply = yield dwn.processMessage(alice.did, postRecord.message, { dataStream: postRecord.dataStream });
+                    const postReply = await dwn.processMessage(alice.did, postRecord.message, { dataStream: postRecord.dataStream });
                     expect(postReply.status.code).toBe(202);
                     // write a `comment` record under v1
-                    const commentRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const commentRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolUri,
                         protocolPath: 'post/comment',
@@ -672,9 +679,9 @@ export function testProtocolsConfigureHandler() {
                         dataFormat: 'application/json',
                         parentContextId: postRecord.message.contextId,
                     });
-                    const commentReply = yield dwn.processMessage(alice.did, commentRecord.message, { dataStream: commentRecord.dataStream });
+                    const commentReply = await dwn.processMessage(alice.did, commentRecord.message, { dataStream: commentRecord.dataStream });
                     expect(commentReply.status.code).toBe(202);
-                    yield Time.minimalSleep();
+                    await Time.minimalSleep();
                     // v2: removes the `comment` type entirely, changes `post` schema
                     const protocolDefinitionV2 = {
                         protocol: protocolUri,
@@ -688,43 +695,43 @@ export function testProtocolsConfigureHandler() {
                             }
                         }
                     };
-                    const configureV2 = yield TestDataGenerator.generateProtocolsConfigure({
+                    const configureV2 = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: protocolDefinitionV2,
                     });
-                    const configureV2Reply = yield dwn.processMessage(alice.did, configureV2.message);
+                    const configureV2Reply = await dwn.processMessage(alice.did, configureV2.message);
                     expect(configureV2Reply.status.code).toBe(202);
                     // read the v1 `post` record — should succeed because read authorization uses v1 definition
-                    const readPost = yield RecordsRead.create({
+                    const readPost = await RecordsRead.create({
                         filter: { recordId: postRecord.message.recordId },
                         signer: Jws.createSigner(alice),
                     });
-                    const readPostReply = yield dwn.processMessage(alice.did, readPost.message);
+                    const readPostReply = await dwn.processMessage(alice.did, readPost.message);
                     expect(readPostReply.status.code).toBe(200);
                     // read the v1 `comment` record — should succeed (governed by v1 definition where `comment` exists)
-                    const readComment = yield RecordsRead.create({
+                    const readComment = await RecordsRead.create({
                         filter: { recordId: commentRecord.message.recordId },
                         signer: Jws.createSigner(alice),
                     });
-                    const readCommentReply = yield dwn.processMessage(alice.did, readComment.message);
+                    const readCommentReply = await dwn.processMessage(alice.did, readComment.message);
                     expect(readCommentReply.status.code).toBe(200);
                     // update the v1 `post` record — should succeed (governed by v1 definition)
                     const updatedData = new TextEncoder().encode('{"title":"updated post"}');
-                    const updatePost = yield RecordsWrite.createFrom({
+                    const updatePost = await RecordsWrite.createFrom({
                         recordsWriteMessage: postRecord.message,
                         data: updatedData,
                         signer: Jws.createSigner(alice),
                     });
-                    const updatePostReply = yield dwn.processMessage(alice.did, updatePost.message, { dataStream: DataStream.fromBytes(updatedData) });
+                    const updatePostReply = await dwn.processMessage(alice.did, updatePost.message, { dataStream: DataStream.fromBytes(updatedData) });
                     expect(updatePostReply.status.code).toBe(202);
-                }));
-                it('should authorize new records against the latest protocol definition, not an older one', () => __awaiter(this, void 0, void 0, function* () {
+                });
+                it('should authorize new records against the latest protocol definition, not an older one', async () => {
                     // scenario:
                     // 1. Alice installs protocol v1 with type `post`
                     // 2. Alice re-configures to v2 that changes `post` schema to 'https://example.com/post-v2'
                     // 3. A new record with v1 schema should be rejected (not matching the latest definition)
                     // 4. A new record with v2 schema should be accepted
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     const protocolUri = 'https://example.com/versioned-protocol-2';
                     const protocolDefinitionV1 = {
                         protocol: protocolUri,
@@ -738,13 +745,13 @@ export function testProtocolsConfigureHandler() {
                             }
                         }
                     };
-                    const configureV1 = yield TestDataGenerator.generateProtocolsConfigure({
+                    const configureV1 = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: protocolDefinitionV1,
                     });
-                    const configureV1Reply = yield dwn.processMessage(alice.did, configureV1.message);
+                    const configureV1Reply = await dwn.processMessage(alice.did, configureV1.message);
                     expect(configureV1Reply.status.code).toBe(202);
-                    yield Time.minimalSleep();
+                    await Time.minimalSleep();
                     // v2: changes `post` schema
                     const protocolDefinitionV2 = {
                         protocol: protocolUri,
@@ -758,41 +765,41 @@ export function testProtocolsConfigureHandler() {
                             }
                         }
                     };
-                    const configureV2 = yield TestDataGenerator.generateProtocolsConfigure({
+                    const configureV2 = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: protocolDefinitionV2,
                     });
-                    const configureV2Reply = yield dwn.processMessage(alice.did, configureV2.message);
+                    const configureV2Reply = await dwn.processMessage(alice.did, configureV2.message);
                     expect(configureV2Reply.status.code).toBe(202);
                     // write a new record with v1 schema — should fail (latest definition requires v2 schema)
-                    const postV1 = yield TestDataGenerator.generateRecordsWrite({
+                    const postV1 = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolUri,
                         protocolPath: 'post',
                         schema: 'https://example.com/post-v1',
                         dataFormat: 'application/json',
                     });
-                    const postV1Reply = yield dwn.processMessage(alice.did, postV1.message, { dataStream: postV1.dataStream });
+                    const postV1Reply = await dwn.processMessage(alice.did, postV1.message, { dataStream: postV1.dataStream });
                     expect(postV1Reply.status.code).toBe(400);
                     expect(postV1Reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationInvalidSchema);
                     // write a new record with v2 schema — should succeed
-                    const postV2 = yield TestDataGenerator.generateRecordsWrite({
+                    const postV2 = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolUri,
                         protocolPath: 'post',
                         schema: 'https://example.com/post-v2',
                         dataFormat: 'application/json',
                     });
-                    const postV2Reply = yield dwn.processMessage(alice.did, postV2.message, { dataStream: postV2.dataStream });
+                    const postV2Reply = await dwn.processMessage(alice.did, postV2.message, { dataStream: postV2.dataStream });
                     expect(postV2Reply.status.code).toBe(202);
-                }));
-                it('should authorize deletes of v1 records after re-configuring to v2 that removes the type', () => __awaiter(this, void 0, void 0, function* () {
+                });
+                it('should authorize deletes of v1 records after re-configuring to v2 that removes the type', async () => {
                     // scenario:
                     // 1. Alice installs protocol v1 with types `post` (with delete action) and `comment`
                     // 2. Alice writes a `post/comment` record
                     // 3. Alice re-configures to v2 which removes the `comment` type
                     // 4. Alice should still be able to delete the v1 `comment` record (governed by v1 definition)
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     const protocolUri = 'https://example.com/versioned-protocol-3';
                     const protocolDefinitionV1 = {
                         protocol: protocolUri,
@@ -810,30 +817,30 @@ export function testProtocolsConfigureHandler() {
                             }
                         }
                     };
-                    const configureV1 = yield TestDataGenerator.generateProtocolsConfigure({
+                    const configureV1 = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: protocolDefinitionV1,
                     });
-                    const configureV1Reply = yield dwn.processMessage(alice.did, configureV1.message);
+                    const configureV1Reply = await dwn.processMessage(alice.did, configureV1.message);
                     expect(configureV1Reply.status.code).toBe(202);
                     // write a `post` record
-                    const postRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const postRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolUri,
                         protocolPath: 'post',
                     });
-                    const postReply = yield dwn.processMessage(alice.did, postRecord.message, { dataStream: postRecord.dataStream });
+                    const postReply = await dwn.processMessage(alice.did, postRecord.message, { dataStream: postRecord.dataStream });
                     expect(postReply.status.code).toBe(202);
                     // write a `comment` record under the post
-                    const commentRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const commentRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolUri,
                         protocolPath: 'post/comment',
                         parentContextId: postRecord.message.contextId,
                     });
-                    const commentReply = yield dwn.processMessage(alice.did, commentRecord.message, { dataStream: commentRecord.dataStream });
+                    const commentReply = await dwn.processMessage(alice.did, commentRecord.message, { dataStream: commentRecord.dataStream });
                     expect(commentReply.status.code).toBe(202);
-                    yield Time.minimalSleep();
+                    await Time.minimalSleep();
                     // v2: removes the `comment` type
                     const protocolDefinitionV2 = {
                         protocol: protocolUri,
@@ -847,28 +854,28 @@ export function testProtocolsConfigureHandler() {
                             }
                         }
                     };
-                    const configureV2 = yield TestDataGenerator.generateProtocolsConfigure({
+                    const configureV2 = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: protocolDefinitionV2,
                     });
-                    const configureV2Reply = yield dwn.processMessage(alice.did, configureV2.message);
+                    const configureV2Reply = await dwn.processMessage(alice.did, configureV2.message);
                     expect(configureV2Reply.status.code).toBe(202);
                     // delete the v1 `comment` record — should succeed (governed by v1 definition)
-                    const deleteComment = yield RecordsDelete.create({
+                    const deleteComment = await RecordsDelete.create({
                         signer: Jws.createSigner(alice),
                         recordId: commentRecord.message.recordId,
                     });
-                    const deleteReply = yield dwn.processMessage(alice.did, deleteComment.message);
+                    const deleteReply = await dwn.processMessage(alice.did, deleteComment.message);
                     expect(deleteReply.status.code).toBe(202);
-                }));
-                it('should not retroactively apply v2 action rules to records created under v1', () => __awaiter(this, void 0, void 0, function* () {
+                });
+                it('should not retroactively apply v2 action rules to records created under v1', async () => {
                     // scenario:
                     // 1. Alice installs protocol v1 where anyone can create and update `post` records
                     // 2. Bob writes a `post` to Alice's DWN
                     // 3. Alice re-configures to v2 that restricts `post` updates to author-only (removes co-update)
                     // 4. Bob should still be able to update his own record (governed by v1 definition which had update)
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     const protocolUri = 'https://example.com/versioned-protocol-4';
                     const protocolDefinitionV1 = {
                         protocol: protocolUri,
@@ -882,21 +889,21 @@ export function testProtocolsConfigureHandler() {
                             }
                         }
                     };
-                    const configureV1 = yield TestDataGenerator.generateProtocolsConfigure({
+                    const configureV1 = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: protocolDefinitionV1,
                     });
-                    const configureV1Reply = yield dwn.processMessage(alice.did, configureV1.message);
+                    const configureV1Reply = await dwn.processMessage(alice.did, configureV1.message);
                     expect(configureV1Reply.status.code).toBe(202);
                     // Bob writes a `post` record to Alice's DWN under v1
-                    const postRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const postRecord = await TestDataGenerator.generateRecordsWrite({
                         author: bob,
                         protocol: protocolUri,
                         protocolPath: 'post',
                     });
-                    const postReply = yield dwn.processMessage(alice.did, postRecord.message, { dataStream: postRecord.dataStream });
+                    const postReply = await dwn.processMessage(alice.did, postRecord.message, { dataStream: postRecord.dataStream });
                     expect(postReply.status.code).toBe(202);
-                    yield Time.minimalSleep();
+                    await Time.minimalSleep();
                     // v2: restricts actions (only create, no update for anyone)
                     const protocolDefinitionV2 = {
                         protocol: protocolUri,
@@ -910,30 +917,29 @@ export function testProtocolsConfigureHandler() {
                             }
                         }
                     };
-                    const configureV2 = yield TestDataGenerator.generateProtocolsConfigure({
+                    const configureV2 = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: protocolDefinitionV2,
                     });
-                    const configureV2Reply = yield dwn.processMessage(alice.did, configureV2.message);
+                    const configureV2Reply = await dwn.processMessage(alice.did, configureV2.message);
                     expect(configureV2Reply.status.code).toBe(202);
                     // Bob updates his v1 record — should succeed because v1 definition (which governs this record) allowed update
                     const updatedData = new TextEncoder().encode('updated-post-data');
-                    const updatePost = yield RecordsWrite.createFrom({
+                    const updatePost = await RecordsWrite.createFrom({
                         recordsWriteMessage: postRecord.message,
                         data: updatedData,
                         signer: Jws.createSigner(bob),
                     });
-                    const updateReply = yield dwn.processMessage(alice.did, updatePost.message, { dataStream: DataStream.fromBytes(updatedData) });
+                    const updateReply = await dwn.processMessage(alice.did, updatePost.message, { dataStream: DataStream.fromBytes(updatedData) });
                     expect(updateReply.status.code).toBe(202);
-                }));
-                it('should handle out-of-order protocol configure processing correctly', () => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
+                });
+                it('should handle out-of-order protocol configure processing correctly', async () => {
                     // scenario:
                     // 1. Create v1 and v2 ProtocolsConfigure messages (v2 has a newer timestamp)
                     // 2. Process v2 first, then v1
                     // 3. Both should be stored; query should return only v2 (the latest)
                     // 4. A record written under v2 schema should succeed
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     const protocolUri = 'https://example.com/versioned-protocol-5';
                     const protocolDefinitionV1 = {
                         protocol: protocolUri,
@@ -947,11 +953,11 @@ export function testProtocolsConfigureHandler() {
                             }
                         }
                     };
-                    const configureV1 = yield TestDataGenerator.generateProtocolsConfigure({
+                    const configureV1 = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: protocolDefinitionV1,
                     });
-                    yield Time.minimalSleep();
+                    await Time.minimalSleep();
                     const protocolDefinitionV2 = {
                         protocol: protocolUri,
                         published: true,
@@ -964,36 +970,36 @@ export function testProtocolsConfigureHandler() {
                             }
                         }
                     };
-                    const configureV2 = yield TestDataGenerator.generateProtocolsConfigure({
+                    const configureV2 = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition: protocolDefinitionV2,
                     });
                     // process v2 first (out of order)
-                    const configureV2Reply = yield dwn.processMessage(alice.did, configureV2.message);
+                    const configureV2Reply = await dwn.processMessage(alice.did, configureV2.message);
                     expect(configureV2Reply.status.code).toBe(202);
                     // process v1 second (older, arrives later)
-                    const configureV1Reply = yield dwn.processMessage(alice.did, configureV1.message);
+                    const configureV1Reply = await dwn.processMessage(alice.did, configureV1.message);
                     expect(configureV1Reply.status.code).toBe(202);
                     // query should return only v2 (the latest)
-                    const queryMessageData = yield TestDataGenerator.generateProtocolsQuery({
+                    const queryMessageData = await TestDataGenerator.generateProtocolsQuery({
                         author: alice,
                         filter: { protocol: protocolUri }
                     });
-                    const queryReply = yield dwn.processMessage(alice.did, queryMessageData.message);
+                    const queryReply = await dwn.processMessage(alice.did, queryMessageData.message);
                     expect(queryReply.status.code).toBe(200);
-                    expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                    expect(queryReply.entries?.length).toBe(1);
                     expect(queryReply.entries[0].descriptor.definition.types.post.schema).toBe('https://example.com/post-v2');
                     // writing a new record with v2 schema should succeed (latest definition)
-                    const postV2 = yield TestDataGenerator.generateRecordsWrite({
+                    const postV2 = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolUri,
                         protocolPath: 'post',
                         schema: 'https://example.com/post-v2',
                         dataFormat: 'application/json',
                     });
-                    const postV2Reply = yield dwn.processMessage(alice.did, postV2.message, { dataStream: postV2.dataStream });
+                    const postV2Reply = await dwn.processMessage(alice.did, postV2.message, { dataStream: postV2.dataStream });
                     expect(postV2Reply.status.code).toBe(202);
-                }));
+                });
             });
         });
     });