@enbox/dwn-sdk-js 0.0.6 → 0.0.8

package/dist/esm/tests/handlers/records-delete.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 { ResumableTaskManager } from '../../src/core/resumable-task-manager.js';
 import sinon from 'sinon';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
@@ -21,7 +12,7 @@ import { Message } from '../../src/core/message.js';
 import { normalizeSchemaUrl } from '../../src/utils/url.js';
 import { RecordsDeleteHandler } from '../../src/handlers/records-delete.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';
@@ -35,7 +26,7 @@ export function testRecordsDeleteHandler() {
         let dataStore;
         let resumableTaskStore;
         let stateIndex;
-        let eventStream;
+        let eventLog;
         let dwn;
         beforeEach(() => {
             sinon.restore();
@@ -46,519 +37,521 @@ export function testRecordsDeleteHandler() {
         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 () => {
                 // 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 handle RecordsDelete successfully and return 404 if deleting a deleted record', () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                await messageStore.clear();
+                await dataStore.clear();
+                await resumableTaskStore.clear();
+                await stateIndex.clear();
+            });
+            afterAll(async () => {
+                await dwn.close();
+            });
+            it('should handle RecordsDelete successfully and return 404 if deleting a deleted record', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // insert data
-                const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // ensure data is inserted
-                const queryData = yield TestDataGenerator.generateRecordsQuery({
+                const queryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: message.recordId }
                 });
-                const reply = yield dwn.processMessage(alice.did, queryData.message);
+                const reply = await dwn.processMessage(alice.did, queryData.message);
                 expect(reply.status.code).toBe(200);
-                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(reply.entries?.length).toBe(1);
                 // testing delete
-                const recordsDelete = yield RecordsDelete.create({
+                const recordsDelete = await RecordsDelete.create({
                     recordId: message.recordId,
                     signer: Jws.createSigner(alice)
                 });
-                const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                const deleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                 expect(deleteReply.status.code).toBe(202);
                 // ensure a query will no longer find the deleted record
-                const reply2 = yield dwn.processMessage(alice.did, queryData.message);
+                const reply2 = await dwn.processMessage(alice.did, queryData.message);
                 expect(reply2.status.code).toBe(200);
-                expect((_b = reply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
+                expect(reply2.entries?.length).toBe(0);
                 // testing deleting a deleted record
-                const recordsDelete2 = yield RecordsDelete.create({
+                const recordsDelete2 = await RecordsDelete.create({
                     recordId: message.recordId,
                     signer: Jws.createSigner(alice)
                 });
-                const recordsDelete2Reply = yield dwn.processMessage(alice.did, recordsDelete2.message);
+                const recordsDelete2Reply = await dwn.processMessage(alice.did, recordsDelete2.message);
                 expect(recordsDelete2Reply.status.code).toBe(404);
-            }));
-            it('should not affect other records or tenants with the same data', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should not affect other records or tenants with the same data', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, bob);
                 const data = Encoder.stringToBytes('test');
                 // alice writes a records with data
-                const aliceWriteData = yield TestDataGenerator.generateRecordsWrite({ author: alice, data });
-                const aliceWriteReply = yield dwn.processMessage(alice.did, aliceWriteData.message, { dataStream: aliceWriteData.dataStream });
+                const aliceWriteData = await TestDataGenerator.generateRecordsWrite({ author: alice, data });
+                const aliceWriteReply = await dwn.processMessage(alice.did, aliceWriteData.message, { dataStream: aliceWriteData.dataStream });
                 expect(aliceWriteReply.status.code).toBe(202);
                 // alice writes another record with the same data
-                const aliceWrite2Data = yield TestDataGenerator.generateRecordsWrite({ author: alice, data });
-                const aliceWrite2Reply = yield dwn.processMessage(alice.did, aliceWrite2Data.message, { dataStream: aliceWrite2Data.dataStream });
+                const aliceWrite2Data = await TestDataGenerator.generateRecordsWrite({ author: alice, data });
+                const aliceWrite2Reply = await dwn.processMessage(alice.did, aliceWrite2Data.message, { dataStream: aliceWrite2Data.dataStream });
                 expect(aliceWrite2Reply.status.code).toBe(202);
                 // bob writes a records with same data
-                const bobWriteData = yield TestDataGenerator.generateRecordsWrite({ author: bob, data });
-                const bobWriteReply = yield dwn.processMessage(bob.did, bobWriteData.message, { dataStream: bobWriteData.dataStream });
+                const bobWriteData = await TestDataGenerator.generateRecordsWrite({ author: bob, data });
+                const bobWriteReply = await dwn.processMessage(bob.did, bobWriteData.message, { dataStream: bobWriteData.dataStream });
                 expect(bobWriteReply.status.code).toBe(202);
                 // bob writes another record with the same data
-                const bobWrite2Data = yield TestDataGenerator.generateRecordsWrite({ author: bob, data });
-                const bobWrite2Reply = yield dwn.processMessage(bob.did, bobWrite2Data.message, { dataStream: bobWrite2Data.dataStream });
+                const bobWrite2Data = await TestDataGenerator.generateRecordsWrite({ author: bob, data });
+                const bobWrite2Reply = await dwn.processMessage(bob.did, bobWrite2Data.message, { dataStream: bobWrite2Data.dataStream });
                 expect(bobWrite2Reply.status.code).toBe(202);
                 // alice deletes one of the two records
-                const aliceDeleteWriteData = yield TestDataGenerator.generateRecordsDelete({
+                const aliceDeleteWriteData = await TestDataGenerator.generateRecordsDelete({
                     author: alice,
                     recordId: aliceWriteData.message.recordId
                 });
-                const aliceDeleteWriteReply = yield dwn.processMessage(alice.did, aliceDeleteWriteData.message);
+                const aliceDeleteWriteReply = await dwn.processMessage(alice.did, aliceDeleteWriteData.message);
                 expect(aliceDeleteWriteReply.status.code).toBe(202);
                 // verify the other record with the same data is unaffected
-                const aliceRead1 = yield RecordsRead.create({
+                const aliceRead1 = await RecordsRead.create({
                     filter: {
                         recordId: aliceWrite2Data.message.recordId,
                     },
                     signer: Jws.createSigner(alice)
                 });
-                const aliceRead1Reply = yield dwn.processMessage(alice.did, aliceRead1.message);
+                const aliceRead1Reply = await dwn.processMessage(alice.did, aliceRead1.message);
                 expect(aliceRead1Reply.status.code).toBe(200);
-                const aliceDataFetched = yield DataStream.toBytes(aliceRead1Reply.entry.data);
+                const aliceDataFetched = await DataStream.toBytes(aliceRead1Reply.entry.data);
                 expect(ArrayUtility.byteArraysEqual(aliceDataFetched, data)).toBe(true);
                 // alice deletes the other record
-                const aliceDeleteWrite2Data = yield TestDataGenerator.generateRecordsDelete({
+                const aliceDeleteWrite2Data = await TestDataGenerator.generateRecordsDelete({
                     author: alice,
                     recordId: aliceWrite2Data.message.recordId
                 });
-                const aliceDeleteWrite2Reply = yield dwn.processMessage(alice.did, aliceDeleteWrite2Data.message);
+                const aliceDeleteWrite2Reply = await dwn.processMessage(alice.did, aliceDeleteWrite2Data.message);
                 expect(aliceDeleteWrite2Reply.status.code).toBe(202);
                 // verify that alice can no longer fetch the 2nd record
-                const aliceRead2Reply = yield dwn.processMessage(alice.did, aliceRead1.message);
+                const aliceRead2Reply = await dwn.processMessage(alice.did, aliceRead1.message);
                 expect(aliceRead2Reply.status.code).toBe(404);
                 // verify that bob can still fetch record with the same data
-                const bobRead1 = yield RecordsRead.create({
+                const bobRead1 = await RecordsRead.create({
                     filter: {
                         recordId: bobWriteData.message.recordId,
                     },
                     signer: Jws.createSigner(bob)
                 });
-                const bobRead1Reply = yield dwn.processMessage(bob.did, bobRead1.message);
+                const bobRead1Reply = await dwn.processMessage(bob.did, bobRead1.message);
                 expect(bobRead1Reply.status.code).toBe(200);
-                const bobDataFetched = yield DataStream.toBytes(bobRead1Reply.entry.data);
+                const bobDataFetched = await DataStream.toBytes(bobRead1Reply.entry.data);
                 expect(ArrayUtility.byteArraysEqual(bobDataFetched, data)).toBe(true);
-            }));
-            it('should return 404 if deleting a non-existent record', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should return 404 if deleting a non-existent record', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // testing deleting a non-existent record
-                const recordsDelete = yield RecordsDelete.create({
+                const recordsDelete = await RecordsDelete.create({
                     recordId: 'nonExistentRecordId',
                     signer: Jws.createSigner(alice)
                 });
-                const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                const deleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                 expect(deleteReply.status.code).toBe(404);
-            }));
-            it('should be disallowed if there is a newer RecordsWrite already in the DWN ', () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should be disallowed if there is a newer RecordsWrite already in the DWN ', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // initial write
-                const initialWriteData = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                const initialWriteReply = yield dwn.processMessage(alice.did, initialWriteData.message, { dataStream: initialWriteData.dataStream });
+                const initialWriteData = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                const initialWriteReply = await dwn.processMessage(alice.did, initialWriteData.message, { dataStream: initialWriteData.dataStream });
                 expect(initialWriteReply.status.code).toBe(202);
                 // generate subsequent write and delete with the delete having an earlier timestamp
                 // NOTE: creating RecordsDelete first ensures it has an earlier `messageTimestamp` time
-                const recordsDelete = yield RecordsDelete.create({
+                const recordsDelete = await RecordsDelete.create({
                     recordId: initialWriteData.message.recordId,
                     signer: Jws.createSigner(alice)
                 });
-                yield Time.minimalSleep();
-                const subsequentWriteData = yield TestDataGenerator.generateFromRecordsWrite({
+                await Time.minimalSleep();
+                const subsequentWriteData = await TestDataGenerator.generateFromRecordsWrite({
                     existingWrite: initialWriteData.recordsWrite,
                     author: alice
                 });
                 // subsequent write
-                const subsequentWriteReply = yield dwn.processMessage(alice.did, subsequentWriteData.message, { dataStream: subsequentWriteData.dataStream });
+                const subsequentWriteReply = await dwn.processMessage(alice.did, subsequentWriteData.message, { dataStream: subsequentWriteData.dataStream });
                 expect(subsequentWriteReply.status.code).toBe(202);
                 // test that a delete with an earlier `messageTimestamp` results in a 409
-                const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                const deleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                 expect(deleteReply.status.code).toBe(409);
                 // ensure data still exists
-                const queryData = yield TestDataGenerator.generateRecordsQuery({
+                const queryData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: initialWriteData.message.recordId }
                 });
                 const expectedEncodedData = Encoder.bytesToBase64Url(subsequentWriteData.dataBytes);
-                const reply = yield dwn.processMessage(alice.did, queryData.message);
+                const reply = await dwn.processMessage(alice.did, queryData.message);
                 expect(reply.status.code).toBe(200);
-                expect((_a = reply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(reply.entries?.length).toBe(1);
                 expect(reply.entries[0].encodedData).toBe(expectedEncodedData);
-            }));
-            it('should be able to delete then rewrite the same data', () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should be able to delete then rewrite the same data', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const data = Encoder.stringToBytes('test');
                 const encodedData = Encoder.bytesToBase64Url(data);
                 // alice writes a record
-                const aliceWriteData = yield TestDataGenerator.generateRecordsWrite({
+                const aliceWriteData = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     data
                 });
-                const aliceWriteReply = yield dwn.processMessage(alice.did, aliceWriteData.message, { dataStream: aliceWriteData.dataStream });
+                const aliceWriteReply = await dwn.processMessage(alice.did, aliceWriteData.message, { dataStream: aliceWriteData.dataStream });
                 expect(aliceWriteReply.status.code).toBe(202);
-                const aliceQueryWriteAfterAliceWriteData = yield TestDataGenerator.generateRecordsQuery({
+                const aliceQueryWriteAfterAliceWriteData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: aliceWriteData.message.recordId }
                 });
-                const aliceQueryWriteAfterAliceWriteReply = yield dwn.processMessage(alice.did, aliceQueryWriteAfterAliceWriteData.message);
+                const aliceQueryWriteAfterAliceWriteReply = await dwn.processMessage(alice.did, aliceQueryWriteAfterAliceWriteData.message);
                 expect(aliceQueryWriteAfterAliceWriteReply.status.code).toBe(200);
-                expect((_a = aliceQueryWriteAfterAliceWriteReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(aliceQueryWriteAfterAliceWriteReply.entries?.length).toBe(1);
                 expect(aliceQueryWriteAfterAliceWriteReply.entries[0].encodedData).toBe(encodedData);
                 // alice deleting the record
-                const aliceDeleteWriteData = yield TestDataGenerator.generateRecordsDelete({
+                const aliceDeleteWriteData = await TestDataGenerator.generateRecordsDelete({
                     author: alice,
                     recordId: aliceWriteData.message.recordId
                 });
-                const aliceDeleteWriteReply = yield dwn.processMessage(alice.did, aliceDeleteWriteData.message);
+                const aliceDeleteWriteReply = await dwn.processMessage(alice.did, aliceDeleteWriteData.message);
                 expect(aliceDeleteWriteReply.status.code).toBe(202);
-                const aliceQueryWriteAfterAliceDeleteData = yield TestDataGenerator.generateRecordsQuery({
+                const aliceQueryWriteAfterAliceDeleteData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: aliceWriteData.message.recordId }
                 });
-                const aliceQueryWriteAfterAliceDeleteReply = yield dwn.processMessage(alice.did, aliceQueryWriteAfterAliceDeleteData.message);
+                const aliceQueryWriteAfterAliceDeleteReply = await dwn.processMessage(alice.did, aliceQueryWriteAfterAliceDeleteData.message);
                 expect(aliceQueryWriteAfterAliceDeleteReply.status.code).toBe(200);
-                expect((_b = aliceQueryWriteAfterAliceDeleteReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
+                expect(aliceQueryWriteAfterAliceDeleteReply.entries?.length).toBe(0);
                 // alice writes a new record with the same data
-                const aliceRewriteData = yield TestDataGenerator.generateRecordsWrite({
+                const aliceRewriteData = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     data
                 });
-                const aliceRewriteReply = yield dwn.processMessage(alice.did, aliceRewriteData.message, { dataStream: aliceRewriteData.dataStream });
+                const aliceRewriteReply = await dwn.processMessage(alice.did, aliceRewriteData.message, { dataStream: aliceRewriteData.dataStream });
                 expect(aliceRewriteReply.status.code).toBe(202);
-                const aliceQueryWriteAfterAliceRewriteData = yield TestDataGenerator.generateRecordsQuery({
+                const aliceQueryWriteAfterAliceRewriteData = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: { recordId: aliceRewriteData.message.recordId }
                 });
-                const aliceQueryWriteAfterAliceRewriteReply = yield dwn.processMessage(alice.did, aliceQueryWriteAfterAliceRewriteData.message);
+                const aliceQueryWriteAfterAliceRewriteReply = await dwn.processMessage(alice.did, aliceQueryWriteAfterAliceRewriteData.message);
                 expect(aliceQueryWriteAfterAliceRewriteReply.status.code).toBe(200);
-                expect((_c = aliceQueryWriteAfterAliceRewriteReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(1);
+                expect(aliceQueryWriteAfterAliceRewriteReply.entries?.length).toBe(1);
                 expect(aliceQueryWriteAfterAliceRewriteReply.entries[0].encodedData).toBe(encodedData);
-            }));
+            });
             describe('protocol based deletes', () => {
-                it('should allow delete with allow-anyone rule', () => __awaiter(this, void 0, void 0, function* () {
+                it('should allow delete with allow-anyone rule', async () => {
                     // scenario: Alice creates a record in her DWN. Bob (anyone) is able to delete the record.
                     const protocolDefinition = anyoneCollaborateProtocolDefinition;
-                    const alice = yield TestDataGenerator.generatePersona();
-                    const bob = yield TestDataGenerator.generatePersona();
-                    const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    const alice = await TestDataGenerator.generatePersona();
+                    const bob = await TestDataGenerator.generatePersona();
+                    const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
                     // setting up a stub DID resolver
                     TestStubGenerator.stubDidResolver(didResolver, [alice, bob]);
-                    const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                    const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                     expect(protocolsConfigureReply.status.code).toBe(202);
                     // Alice writes a record
-                    const recordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                    const recordsWrite = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'doc',
                     });
-                    const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
+                    const recordsWriteReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
                     expect(recordsWriteReply.status.code).toBe(202);
                     // Bob (anyone) is able to delete the record
-                    const recordsDelete = yield TestDataGenerator.generateRecordsDelete({
+                    const recordsDelete = await TestDataGenerator.generateRecordsDelete({
                         author: bob,
                         recordId: recordsWrite.message.recordId,
                     });
-                    const recordsDeleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                    const recordsDeleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                     expect(recordsDeleteReply.status.code).toBe(202);
-                }));
+                });
                 describe('recipient rules', () => {
-                    it('should allow delete with ancestor recipient rule', () => __awaiter(this, void 0, void 0, function* () {
+                    it('should allow delete with ancestor recipient rule', async () => {
                         // scenario: Alice creates a 'post' with Bob as recipient and a 'post/tag'. Bob is able to delete
                         //           the 'chat/tag' because he was recipient of the 'chat'. Carol is not able to delete.
                         const protocolDefinition = recipientCanProtocolDefinition;
-                        const alice = yield TestDataGenerator.generatePersona();
-                        const bob = yield TestDataGenerator.generatePersona();
-                        const carol = yield TestDataGenerator.generatePersona();
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                        const alice = await TestDataGenerator.generatePersona();
+                        const bob = await TestDataGenerator.generatePersona();
+                        const carol = await TestDataGenerator.generatePersona();
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
                         // setting up a stub DID resolver
                         TestStubGenerator.stubDidResolver(didResolver, [alice, bob, carol]);
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice writes a chat
-                        const chatRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: bob.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'post',
                         });
-                        const chatRecordsWriteReply = yield dwn.processMessage(alice.did, chatRecordsWrite.message, { dataStream: chatRecordsWrite.dataStream });
+                        const chatRecordsWriteReply = await dwn.processMessage(alice.did, chatRecordsWrite.message, { dataStream: chatRecordsWrite.dataStream });
                         expect(chatRecordsWriteReply.status.code).toBe(202);
                         // Alice writes a 'chat/tag'
-                        const tagRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                        const tagRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'post/tag',
                             parentContextId: chatRecordsWrite.message.contextId,
                         });
-                        const tagRecordsWriteReply = yield dwn.processMessage(alice.did, tagRecordsWrite.message, { dataStream: tagRecordsWrite.dataStream });
+                        const tagRecordsWriteReply = await dwn.processMessage(alice.did, tagRecordsWrite.message, { dataStream: tagRecordsWrite.dataStream });
                         expect(tagRecordsWriteReply.status.code).toBe(202);
                         // Carol is unable to delete the 'chat/tag'
-                        const recordsDeleteCarol = yield TestDataGenerator.generateRecordsDelete({
+                        const recordsDeleteCarol = await TestDataGenerator.generateRecordsDelete({
                             author: carol,
                             recordId: tagRecordsWrite.message.recordId,
                         });
-                        const recordsDeleteCarolReply = yield dwn.processMessage(alice.did, recordsDeleteCarol.message);
+                        const recordsDeleteCarolReply = await dwn.processMessage(alice.did, recordsDeleteCarol.message);
                         expect(recordsDeleteCarolReply.status.code).toBe(401);
                         expect(recordsDeleteCarolReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                         // Bob is able to delete the 'chat/tag'
-                        const recordsDelete = yield TestDataGenerator.generateRecordsDelete({
+                        const recordsDelete = await TestDataGenerator.generateRecordsDelete({
                             author: bob,
                             recordId: tagRecordsWrite.message.recordId,
                         });
-                        const recordsDeleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                        const recordsDeleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                         expect(recordsDeleteReply.status.code).toBe(202);
-                    }));
-                    it('should allow delete with direct recipient rule', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    it('should allow delete with direct recipient rule', async () => {
                         // scenario: Alice creates a 'post' with Bob as recipient. Bob is able to delete
                         //           the 'post' because he was recipient of it. Carol is not able to delete.
                         const protocolDefinition = recipientCanProtocolDefinition;
-                        const alice = yield TestDataGenerator.generatePersona();
-                        const bob = yield TestDataGenerator.generatePersona();
-                        const carol = yield TestDataGenerator.generatePersona();
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                        const alice = await TestDataGenerator.generatePersona();
+                        const bob = await TestDataGenerator.generatePersona();
+                        const carol = await TestDataGenerator.generatePersona();
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
                         // setting up a stub DID resolver
                         TestStubGenerator.stubDidResolver(didResolver, [alice, bob, carol]);
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates a 'post' with Bob as recipient
-                        const recordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                        const recordsWrite = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: bob.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'post',
                         });
-                        const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
+                        const recordsWriteReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
                         expect(recordsWriteReply.status.code).toBe(202);
                         // Carol is unable to delete the 'post'
-                        const carolRecordsDelete = yield TestDataGenerator.generateRecordsDelete({
+                        const carolRecordsDelete = await TestDataGenerator.generateRecordsDelete({
                             author: carol,
                             recordId: recordsWrite.message.recordId,
                         });
-                        const carolRecordsDeleteReply = yield dwn.processMessage(alice.did, carolRecordsDelete.message);
+                        const carolRecordsDeleteReply = await dwn.processMessage(alice.did, carolRecordsDelete.message);
                         expect(carolRecordsDeleteReply.status.code).toBe(401);
                         expect(carolRecordsDeleteReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                         // Bob is able to delete the post
-                        const bobRecordsDelete = yield TestDataGenerator.generateRecordsDelete({
+                        const bobRecordsDelete = await TestDataGenerator.generateRecordsDelete({
                             author: bob,
                             recordId: recordsWrite.message.recordId,
                         });
-                        const bobRecordsDeleteReply = yield dwn.processMessage(alice.did, bobRecordsDelete.message);
+                        const bobRecordsDeleteReply = await dwn.processMessage(alice.did, bobRecordsDelete.message);
                         expect(bobRecordsDeleteReply.status.code).toBe(202);
-                    }));
+                    });
                 });
                 describe('author action rules', () => {
-                    it('allow author to delete with ancestor author rule', () => __awaiter(this, void 0, void 0, function* () {
+                    it('allow author to delete with ancestor author rule', async () => {
                         // scenario: Bob writes a 'post' and Alice writes a 'post/comment' to her DWN. Bob deletes the comment
                         //           because author of post can delete. Carol is unable to delete the comment.
                         const protocolDefinition = authorCanProtocolDefinition;
-                        const alice = yield TestDataGenerator.generatePersona();
-                        const bob = yield TestDataGenerator.generatePersona();
-                        const carol = yield TestDataGenerator.generatePersona();
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                        const alice = await TestDataGenerator.generatePersona();
+                        const bob = await TestDataGenerator.generatePersona();
+                        const carol = await TestDataGenerator.generatePersona();
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
                         // setting up a stub DID resolver
                         TestStubGenerator.stubDidResolver(didResolver, [alice, bob, carol]);
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolsConfigureReply.status.code).toBe(202);
                         // Bob writes a post
-                        const postRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                        const postRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                             author: bob,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'post',
                         });
-                        const postRecordsWriteReply = yield dwn.processMessage(alice.did, postRecordsWrite.message, { dataStream: postRecordsWrite.dataStream });
+                        const postRecordsWriteReply = await dwn.processMessage(alice.did, postRecordsWrite.message, { dataStream: postRecordsWrite.dataStream });
                         expect(postRecordsWriteReply.status.code).toBe(202);
                         // Alice writes a 'post/comment'
-                        const commentRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                        const commentRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'post/comment',
                             parentContextId: postRecordsWrite.message.contextId,
                         });
-                        const commentRecordsWriteReply = yield dwn.processMessage(alice.did, commentRecordsWrite.message, { dataStream: commentRecordsWrite.dataStream });
+                        const commentRecordsWriteReply = await dwn.processMessage(alice.did, commentRecordsWrite.message, { dataStream: commentRecordsWrite.dataStream });
                         expect(commentRecordsWriteReply.status.code).toBe(202);
                         // Carol is unable to delete Alice's 'post/comment'
-                        const recordsDeleteCarol = yield TestDataGenerator.generateRecordsDelete({
+                        const recordsDeleteCarol = await TestDataGenerator.generateRecordsDelete({
                             author: carol,
                             recordId: commentRecordsWrite.message.recordId,
                         });
-                        const recordsDeleteCarolReply = yield dwn.processMessage(alice.did, recordsDeleteCarol.message);
+                        const recordsDeleteCarolReply = await dwn.processMessage(alice.did, recordsDeleteCarol.message);
                         expect(recordsDeleteCarolReply.status.code).toBe(401);
                         expect(recordsDeleteCarolReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                         // Bob is able to delete the Alice's 'post/comment'
-                        const recordsDelete = yield TestDataGenerator.generateRecordsDelete({
+                        const recordsDelete = await TestDataGenerator.generateRecordsDelete({
                             author: bob,
                             recordId: commentRecordsWrite.message.recordId,
                         });
-                        const recordsDeleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                        const recordsDeleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                         expect(recordsDeleteReply.status.code).toBe(202);
-                    }));
+                    });
                 });
                 describe('role based deletes', () => {
-                    it('should allow co-delete by invoking a context role', () => __awaiter(this, void 0, void 0, function* () {
+                    it('should allow co-delete by invoking a context role', async () => {
                         // scenario: Alice adds Bob as a 'thread/admin' role. She writes a 'thread/chat'.
                         //           Bob invokes his admin role to delete the 'thread/chat'. Carol is unable to delete
                         //           the 'thread/chat'.
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const bob = yield TestDataGenerator.generateDidKeyPersona();
-                        const carol = yield TestDataGenerator.generateDidKeyPersona();
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
+                        const carol = await TestDataGenerator.generateDidKeyPersona();
                         const protocolDefinition = threadRoleProtocolDefinition;
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice creates a thread
-                        const threadRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const threadRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: bob.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'thread'
                         });
-                        const threadRecordReply = yield dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
+                        const threadRecordReply = await dwn.processMessage(alice.did, threadRecord.message, { dataStream: threadRecord.dataStream });
                         expect(threadRecordReply.status.code).toBe(202);
                         // Alice adds Bob as a 'thread/admin' in that thread
-                        const participantRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const participantRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: bob.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'thread/admin',
                             parentContextId: threadRecord.message.contextId,
                         });
-                        const participantRecordReply = yield dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
+                        const participantRecordReply = await dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
                         expect(participantRecordReply.status.code).toBe(202);
                         // Alice writes a chat message in that thread
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: alice.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'thread/chat',
                             parentContextId: threadRecord.message.contextId,
                         });
-                        const chatRecordReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+                        const chatRecordReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         expect(chatRecordReply.status.code).toBe(202);
                         // Verifies that Carol cannot delete without appropriate role
-                        const chatDeleteCarol = yield TestDataGenerator.generateRecordsDelete({
+                        const chatDeleteCarol = await TestDataGenerator.generateRecordsDelete({
                             author: carol,
                             recordId: chatRecord.message.recordId,
                         });
-                        const chatDeleteReplyCarol = yield dwn.processMessage(alice.did, chatDeleteCarol.message);
+                        const chatDeleteReplyCarol = await dwn.processMessage(alice.did, chatDeleteCarol.message);
                         expect(chatDeleteReplyCarol.status.code).toBe(401);
                         expect(chatDeleteReplyCarol.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                         // Bob invokes the role to delete the chat message
-                        const chatDelete = yield TestDataGenerator.generateRecordsDelete({
+                        const chatDelete = await TestDataGenerator.generateRecordsDelete({
                             author: bob,
                             recordId: chatRecord.message.recordId,
                             protocolRole: 'thread/admin',
                         });
-                        const chatDeleteReply = yield dwn.processMessage(alice.did, chatDelete.message);
+                        const chatDeleteReply = await dwn.processMessage(alice.did, chatDelete.message);
                         expect(chatDeleteReply.status.code).toBe(202);
-                    }));
-                    it('should allow co-delete invoking a root-level role', () => __awaiter(this, void 0, void 0, function* () {
+                    });
+                    it('should allow co-delete invoking a root-level role', async () => {
                         // scenario: Alice adds Bob as a root-level 'admin' role. She writes a 'chat'.
                         //           Bob invokes his admin role to delete the 'chat'.
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
-                        const bob = yield TestDataGenerator.generateDidKeyPersona();
-                        const carol = yield TestDataGenerator.generateDidKeyPersona();
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
+                        const bob = await TestDataGenerator.generateDidKeyPersona();
+                        const carol = await TestDataGenerator.generateDidKeyPersona();
                         const protocolDefinition = friendRoleProtocolDefinition;
-                        const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition
                         });
-                        const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                        const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                         expect(protocolsConfigureReply.status.code).toBe(202);
                         // Alice adds Bob as a 'thread/admin' in that thread
-                        const participantRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const participantRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: bob.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'admin',
                         });
-                        const participantRecordReply = yield dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
+                        const participantRecordReply = await dwn.processMessage(alice.did, participantRecord.message, { dataStream: participantRecord.dataStream });
                         expect(participantRecordReply.status.code).toBe(202);
                         // Alice writes a chat message in that thread
-                        const chatRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const chatRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             recipient: alice.did,
                             protocol: protocolDefinition.protocol,
                             protocolPath: 'chat',
                         });
-                        const chatRecordReply = yield dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
+                        const chatRecordReply = await dwn.processMessage(alice.did, chatRecord.message, { dataStream: chatRecord.dataStream });
                         expect(chatRecordReply.status.code).toBe(202);
                         // Carol is unable to delete the chat message
-                        const chatDeleteCarol = yield TestDataGenerator.generateRecordsDelete({
+                        const chatDeleteCarol = await TestDataGenerator.generateRecordsDelete({
                             author: carol,
                             recordId: chatRecord.message.recordId,
                         });
-                        const chatDeleteCarolReply = yield dwn.processMessage(alice.did, chatDeleteCarol.message);
+                        const chatDeleteCarolReply = await dwn.processMessage(alice.did, chatDeleteCarol.message);
                         expect(chatDeleteCarolReply.status.code).toBe(401);
                         expect(chatDeleteCarolReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
                         // Bob invokes the role to delete the chat message
-                        const chatDelete = yield TestDataGenerator.generateRecordsDelete({
+                        const chatDelete = await TestDataGenerator.generateRecordsDelete({
                             author: bob,
                             recordId: chatRecord.message.recordId,
                             protocolRole: 'admin',
                         });
-                        const chatDeleteReply = yield dwn.processMessage(alice.did, chatDelete.message);
+                        const chatDeleteReply = await dwn.processMessage(alice.did, chatDelete.message);
                         expect(chatDeleteReply.status.code).toBe(202);
-                    }));
+                    });
                 });
             });
-            it('should return 401 if message is not authorized', () => __awaiter(this, void 0, void 0, function* () {
+            it('should return 401 if message is not authorized', async () => {
                 // scenario: Alice creates a record and Bob is unable to delete it.
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                const recordsWrite = yield TestDataGenerator.generateRecordsWrite({
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const recordsWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                 });
-                const recordsWriteReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
+                const recordsWriteReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream: recordsWrite.dataStream });
                 expect(recordsWriteReply.status.code).toBe(202);
-                const recordsDelete = yield TestDataGenerator.generateRecordsDelete({
+                const recordsDelete = await TestDataGenerator.generateRecordsDelete({
                     author: bob,
                     recordId: recordsWrite.message.recordId,
                 });
-                const recordsDeleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                const recordsDeleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                 expect(recordsDeleteReply.status.code).toBe(401);
-                expect(recordsDeleteReply.status.detail).toContain(DwnErrorCode.RecordsDeleteAuthorizationFailed);
-            }));
+            });
             describe('grant based deletes', () => {
-                it('should allow delete with a matching protocol grant scope', () => __awaiter(this, void 0, void 0, function* () {
+                it('should allow delete with a matching protocol grant scope', async () => {
                     // scenario: Alice writes a protocol record, grants Bob delete permission, Bob deletes it.
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     const protocolDefinition = {
                         protocol: 'http://grant-delete-test.xyz',
                         published: false,
@@ -566,22 +559,22 @@ export function testRecordsDeleteHandler() {
                         structure: { foo: {} }
                     };
                     // Alice installs the protocol
-                    const protocolsConfig = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolsConfig = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+                    const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
                     expect(protocolsConfigureReply.status.code).toBe(202);
                     // Alice writes a record
-                    const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
+                    const { recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'foo',
                     });
-                    const writeReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
+                    const writeReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
                     expect(writeReply.status.code).toBe(202);
                     // Alice grants Bob delete permission scoped to the 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 }),
@@ -592,22 +585,22 @@ export function testRecordsDeleteHandler() {
                         }
                     });
                     const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
-                    const grantWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
+                    const grantWriteReply = await dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream });
                     expect(grantWriteReply.status.code).toBe(202);
                     // Bob deletes the record using the grant
-                    const recordsDelete = yield RecordsDelete.create({
+                    const recordsDelete = await RecordsDelete.create({
                         recordId: recordsWrite.message.recordId,
                         signer: Jws.createSigner(bob),
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
-                    const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                    const deleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                     expect(deleteReply.status.code).toBe(202);
-                }));
-                it('should reject delete when grant has mismatching protocol scope', () => __awaiter(this, void 0, void 0, function* () {
+                });
+                it('should reject delete when grant has mismatching protocol scope', async () => {
                     // scenario: Alice grants Bob delete permission for protocol A,
                     //           Bob tries to delete a record in protocol B.
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     const protocolA = {
                         protocol: 'http://protocol-a.xyz',
                         published: false,
@@ -621,20 +614,20 @@ export function testRecordsDeleteHandler() {
                         structure: { foo: {} }
                     };
                     // Alice installs both protocols
-                    const configA = yield TestDataGenerator.generateProtocolsConfigure({ author: alice, protocolDefinition: protocolA });
-                    expect((yield dwn.processMessage(alice.did, configA.message)).status.code).toBe(202);
-                    const configB = yield TestDataGenerator.generateProtocolsConfigure({ author: alice, protocolDefinition: protocolB });
-                    expect((yield dwn.processMessage(alice.did, configB.message)).status.code).toBe(202);
+                    const configA = await TestDataGenerator.generateProtocolsConfigure({ author: alice, protocolDefinition: protocolA });
+                    expect((await dwn.processMessage(alice.did, configA.message)).status.code).toBe(202);
+                    const configB = await TestDataGenerator.generateProtocolsConfigure({ author: alice, protocolDefinition: protocolB });
+                    expect((await dwn.processMessage(alice.did, configB.message)).status.code).toBe(202);
                     // Alice writes a record in protocol B
-                    const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({
+                    const { recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolB.protocol,
                         protocolPath: 'foo',
                     });
-                    const writeReply = yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
+                    const writeReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
                     expect(writeReply.status.code).toBe(202);
                     // Alice grants Bob delete permission scoped to protocol A (not B)
-                    const permissionGrant = yield PermissionsProtocol.createGrant({
+                    const permissionGrant = await PermissionsProtocol.createGrant({
                         signer: Jws.createSigner(alice),
                         grantedTo: bob.did,
                         dateExpires: Time.createOffsetTimestamp({ seconds: 60 * 60 * 24 }),
@@ -645,133 +638,127 @@ export function testRecordsDeleteHandler() {
                         }
                     });
                     const grantDataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
-                    expect((yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream })).status.code).toBe(202);
+                    expect((await dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream: grantDataStream })).status.code).toBe(202);
                     // Bob tries to delete the protocol B record with the protocol A grant — should fail
-                    const recordsDelete = yield RecordsDelete.create({
+                    const recordsDelete = await RecordsDelete.create({
                         recordId: recordsWrite.message.recordId,
                         signer: Jws.createSigner(bob),
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId,
                     });
-                    const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                    const deleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                     expect(deleteReply.status.code).toBe(401);
                     expect(deleteReply.status.detail).toContain(DwnErrorCode.RecordsGrantAuthorizationDeleteProtocolScopeMismatch);
-                }));
-                it('should reject delete without a grant when non-owner tries to delete a non-protocol record', () => __awaiter(this, void 0, void 0, function* () {
-                    // scenario: Alice writes a non-protocol record, Bob tries to delete it without any grant.
-                    //           This test verifies the fallback error path is unchanged.
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
-                    const { recordsWrite, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                    expect((yield dwn.processMessage(alice.did, recordsWrite.message, { dataStream })).status.code).toBe(202);
-                    const recordsDelete = yield RecordsDelete.create({
-                        recordId: recordsWrite.message.recordId,
-                        signer: Jws.createSigner(bob),
-                    });
-                    const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
-                    expect(deleteReply.status.code).toBe(401);
-                    expect(deleteReply.status.detail).toContain(DwnErrorCode.RecordsDeleteAuthorizationFailed);
-                }));
+                });
             });
-            it('should index additional properties from the RecordsWrite being deleted', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            it('should index additional properties from the RecordsWrite being deleted', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // initial write
-                const initialWriteData = yield TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'testSchema' });
-                const initialWriteReply = yield dwn.processMessage(alice.did, initialWriteData.message, { dataStream: initialWriteData.dataStream });
+                const initialWriteData = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'testSchema' });
+                const initialWriteReply = await dwn.processMessage(alice.did, initialWriteData.message, { dataStream: initialWriteData.dataStream });
                 expect(initialWriteReply.status.code).toBe(202);
                 // generate subsequent write and delete with the delete having an earlier timestamp
                 // NOTE: creating RecordsDelete first ensures it has an earlier `messageTimestamp` time
-                const recordsDelete = yield RecordsDelete.create({
+                const recordsDelete = await RecordsDelete.create({
                     recordId: initialWriteData.message.recordId,
                     signer: Jws.createSigner(alice)
                 });
-                const deleteMessageCid = yield Message.getCid(recordsDelete.message);
-                const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                const deleteMessageCid = await Message.getCid(recordsDelete.message);
+                const deleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                 expect(deleteReply.status.code).toBe(202);
                 // message store
-                const { messages } = yield messageStore.query(alice.did, [{ schema: normalizeSchemaUrl('testSchema'), method: DwnMethodName.Delete }]);
+                const { messages } = await messageStore.query(alice.did, [{ schema: normalizeSchemaUrl('testSchema'), method: DwnMethodName.Delete }]);
                 expect(messages.length).toBe(1);
-                expect(yield Message.getCid(messages[0])).toBe(deleteMessageCid);
+                expect(await Message.getCid(messages[0])).toBe(deleteMessageCid);
                 // state index
-                const events = yield stateIndex.getLeaves(alice.did, []);
+                const events = await stateIndex.getLeaves(alice.did, []);
                 expect(events).toContain(deleteMessageCid);
-            }));
+            });
             describe('state index', () => {
-                it('should include RecordsDelete event and keep initial RecordsWrite event', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const { message, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                    const writeReply = yield dwn.processMessage(alice.did, message, { dataStream });
+                it('should include RecordsDelete event and keep initial RecordsWrite event', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                    const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                    const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                     expect(writeReply.status.code).toBe(202);
-                    const recordsDelete = yield RecordsDelete.create({
+                    const recordsDelete = await RecordsDelete.create({
                         recordId: message.recordId,
                         signer: Jws.createSigner(alice)
                     });
-                    const deleteReply = yield dwn.processMessage(alice.did, recordsDelete.message);
+                    const deleteReply = await dwn.processMessage(alice.did, recordsDelete.message);
                     expect(deleteReply.status.code).toBe(202);
-                    const events = yield stateIndex.getLeaves(alice.did, []);
-                    expect(events.length).toBe(2);
-                    const writeMessageCid = yield Message.getCid(message);
-                    const deleteMessageCid = yield Message.getCid(recordsDelete.message);
+                    // NOTE: getLeaves returns ALL messageCids (including ProtocolsConfigure), so count is 3 not 2
+                    const events = await stateIndex.getLeaves(alice.did, []);
+                    expect(events.length).toBe(3);
+                    const writeMessageCid = await Message.getCid(message);
+                    const deleteMessageCid = await Message.getCid(recordsDelete.message);
                     const expectedMessageCids = new Set([writeMessageCid, deleteMessageCid]);
                     for (const messageCid of events) {
                         expectedMessageCids.delete(messageCid);
                     }
                     expect(expectedMessageCids.size).toBe(0);
-                }));
-                it('should only keep first write and delete when subsequent writes happen', () => __awaiter(this, void 0, void 0, function* () {
-                    const { message, author, dataStream, recordsWrite } = yield TestDataGenerator.generateRecordsWrite();
+                });
+                it('should only keep first write and delete when subsequent writes happen', async () => {
+                    const author = await TestDataGenerator.generatePersona();
                     TestStubGenerator.stubDidResolver(didResolver, [author]);
-                    const reply = yield dwn.processMessage(author.did, message, { dataStream });
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, author);
+                    const { message, dataStream, recordsWrite } = await TestDataGenerator.generateRecordsWrite({ author });
+                    const reply = await dwn.processMessage(author.did, message, { dataStream });
                     expect(reply.status.code).toBe(202);
-                    const newWrite = yield RecordsWrite.createFrom({
+                    const newWrite = await RecordsWrite.createFrom({
                         recordsWriteMessage: recordsWrite.message,
                         published: true,
                         signer: Jws.createSigner(author)
                     });
-                    const newWriteReply = yield dwn.processMessage(author.did, newWrite.message);
+                    const newWriteReply = await dwn.processMessage(author.did, newWrite.message);
                     expect(newWriteReply.status.code).toBe(202);
-                    const recordsDelete = yield RecordsDelete.create({
+                    const recordsDelete = await RecordsDelete.create({
                         recordId: message.recordId,
                         signer: Jws.createSigner(author)
                     });
-                    const deleteReply = yield dwn.processMessage(author.did, recordsDelete.message);
+                    const deleteReply = await dwn.processMessage(author.did, recordsDelete.message);
                     expect(deleteReply.status.code).toBe(202);
-                    const events = yield stateIndex.getLeaves(author.did, []);
-                    expect(events.length).toBe(2);
-                    const deletedMessageCid = yield Message.getCid(newWrite.message);
+                    const events = await stateIndex.getLeaves(author.did, []);
+                    expect(events.length).toBe(3);
+                    const deletedMessageCid = await Message.getCid(newWrite.message);
                     for (const messageCid of events) {
                         if (messageCid === deletedMessageCid) {
                             throw new Error(`${messageCid} should not exist`);
                         }
                     }
-                }));
+                });
             });
         });
-        it('should return 401 if signature check fails', () => __awaiter(this, void 0, void 0, function* () {
-            const { author, message } = yield TestDataGenerator.generateRecordsDelete();
+        it('should return 401 if signature check fails', async () => {
+            const { author, message } = await TestDataGenerator.generateRecordsDelete();
             const tenant = author.did;
             // setting up a stub did resolver & message store
             // intentionally not supplying the public key so a different public key is generated to simulate invalid signature
-            const mismatchingPersona = yield TestDataGenerator.generatePersona({ did: author.did, keyId: author.keyId });
+            const mismatchingPersona = await TestDataGenerator.generatePersona({ did: author.did, keyId: author.keyId });
             const didResolver = TestStubGenerator.createDidResolverStub(mismatchingPersona);
             // setting up a stub method resolver & message store
             const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
             const resumableTaskManagerStub = sinon.createStubInstance(ResumableTaskManager);
-            const recordsDeleteHandler = new RecordsDeleteHandler(didResolver, messageStoreStub, resumableTaskManagerStub);
-            const reply = yield recordsDeleteHandler.handle({ tenant, message });
+            const recordsDeleteHandler = new RecordsDeleteHandler({
+                didResolver, messageStore: messageStoreStub, resumableTaskManager: resumableTaskManagerStub,
+            });
+            const reply = await recordsDeleteHandler.handle({ tenant, message });
             expect(reply.status.code).toBe(401);
-        }));
-        it('should return 400 if fail parsing the message', () => __awaiter(this, void 0, void 0, function* () {
-            const { author, message } = yield TestDataGenerator.generateRecordsDelete();
+        });
+        it('should return 400 if fail parsing the message', async () => {
+            const { author, message } = await TestDataGenerator.generateRecordsDelete();
             const tenant = author.did;
             // setting up a stub method resolver & message store
             const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
             const resumableTaskManagerStub = sinon.createStubInstance(ResumableTaskManager);
-            const recordsDeleteHandler = new RecordsDeleteHandler(didResolver, messageStoreStub, resumableTaskManagerStub);
+            const recordsDeleteHandler = new RecordsDeleteHandler({
+                didResolver, messageStore: messageStoreStub, resumableTaskManager: resumableTaskManagerStub,
+            });
             // stub the `parse()` function to throw an error
             sinon.stub(RecordsDelete, 'parse').throws('anyError');
-            const reply = yield recordsDeleteHandler.handle({ tenant, message });
+            const reply = await recordsDeleteHandler.handle({ tenant, message });
             expect(reply.status.code).toBe(400);
-        }));
+        });
     });
 }
 //# sourceMappingURL=records-delete.spec.js.map