@enbox/dwn-sdk-js 0.0.6 → 0.0.8

package/dist/esm/tests/features/records-tags.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 sinon from 'sinon';
 import { DidKey } from '@enbox/dids';
 import { Dwn } from '../../src/dwn.js';
@@ -16,7 +7,7 @@ import { Records } from '../../src/utils/records.js';
 import { RecordsRead } from '../../src/interfaces/records-read.js';
 import { RecordsWrite } from '../../src/interfaces/records-write.js';
 import { TestDataGenerator } from '../utils/test-data-generator.js';
-import { TestEventStream } from '../test-event-stream.js';
+import { TestEventLog } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
 import { UniversalResolver } from '@enbox/dids';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
@@ -28,36 +19,36 @@ export function testRecordsTags() {
         let dataStore;
         let resumableTaskStore;
         let stateIndex;
-        let eventStream;
+        let eventLog;
         let dwn;
         // important to follow the `before` and `after` pattern to initialize and clean the stores in tests
         // so that different test suites can reuse the same backend store for testing
-        beforeAll(() => __awaiter(this, void 0, void 0, function* () {
+        beforeAll(async () => {
             didResolver = new UniversalResolver({ didResolvers: [DidKey] });
             const stores = TestStores.get();
             messageStore = stores.messageStore;
             dataStore = stores.dataStore;
             resumableTaskStore = stores.resumableTaskStore;
             stateIndex = stores.stateIndex;
-            eventStream = TestEventStream.get();
-            dwn = yield Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
-        }));
-        beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+            eventLog = TestEventLog.get();
+            dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventLog, resumableTaskStore });
+        });
+        beforeEach(async () => {
             sinon.restore(); // wipe all previous stubs/spies/mocks/fakes
             // clean up before each test rather than after so that a test does not depend on other tests to do the clean up
-            yield messageStore.clear();
-            yield dataStore.clear();
-            yield resumableTaskStore.clear();
-            yield stateIndex.clear();
-        }));
-        afterAll(() => __awaiter(this, void 0, void 0, function* () {
-            yield dwn.close();
-        }));
+            await messageStore.clear();
+            await dataStore.clear();
+            await resumableTaskStore.clear();
+            await stateIndex.clear();
+        });
+        afterAll(async () => {
+            await dwn.close();
+        });
         describe('RecordsWrite with tags', () => {
             describe('protocol rules', () => {
                 describe('ProtocolsConfigure', () => {
-                    it('should support protocol tag types of string, number, integer, boolean and array types of numbers, integers and strings', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    it('should support protocol tag types of string, number, integer, boolean and array types of numbers, integers and strings', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
                         // configure a protocol with tags of string, number, boolean and array types of numbers and strings
                         const protocolDefinition = {
                             protocol: 'http://example.com/protocol/withTags',
@@ -102,15 +93,15 @@ export function testRecordsTags() {
                                 }
                             },
                         };
-                        const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition,
                         });
-                        const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                        const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                         expect(configureReply.status.code).toBe(202);
-                    }));
-                    it('should reject tags that have invalid schema definitions during create', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    });
+                    it('should reject tags that have invalid schema definitions during create', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
                         // protocol definition with an invalid schema
                         const invalidSchemaProtocol = {
                             protocol: 'http://example.com/protocol/withTags',
@@ -139,10 +130,10 @@ export function testRecordsTags() {
                             author: alice,
                             protocolDefinition: invalidSchemaProtocol,
                         });
-                        yield expect(protocolConfigure).rejects.toThrow(DwnErrorCode.ProtocolsConfigureInvalidTagSchema);
-                    }));
-                    it('should reject tags that have invalid schema definitions during process', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        await expect(protocolConfigure).rejects.toThrow(DwnErrorCode.ProtocolsConfigureInvalidTagSchema);
+                    });
+                    it('should reject tags that have invalid schema definitions during process', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
                         // protocol definition with an invalid schema
                         const invalidSchemaProtocol = {
                             protocol: 'http://example.com/protocol/withTags',
@@ -174,19 +165,19 @@ export function testRecordsTags() {
                             messageTimestamp: Time.getCurrentTimestamp(),
                             definition: invalidSchemaProtocol
                         };
-                        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.ProtocolsConfigureInvalidTagSchema);
                         expect(protocolsConfigureReply.status.detail).toContain(`foo/$tags/invalidTag/contains/minimum must be number`);
-                    }));
+                    });
                     describe('should reject invalid tag types', () => {
-                        it('object', () => __awaiter(this, void 0, void 0, function* () {
-                            const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        it('object', async () => {
+                            const alice = await TestDataGenerator.generateDidKeyPersona();
                             // protocol definition with unsupported tag type of object
                             const objectTagsType = {
                                 protocol: 'http://example.com/protocol/withTags',
@@ -211,16 +202,16 @@ export function testRecordsTags() {
                                 messageTimestamp: Time.getCurrentTimestamp(),
                                 definition: objectTagsType
                             };
-                            const authorization = yield Message.createAuthorization({
+                            const authorization = await Message.createAuthorization({
                                 descriptor,
                                 signer: Jws.createSigner(alice)
                             });
                             const protocolsConfigureMessage = { descriptor, authorization };
-                            const objectTagsTypeConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
+                            const objectTagsTypeConfigureReply = await dwn.processMessage(alice.did, protocolsConfigureMessage);
                             expect(objectTagsTypeConfigureReply.status.code).toBe(400);
-                        }));
-                        it('array of objects', () => __awaiter(this, void 0, void 0, function* () {
-                            const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        });
+                        it('array of objects', async () => {
+                            const alice = await TestDataGenerator.generateDidKeyPersona();
                             // protocol definition with unsupported tag type array of objects
                             const objectArrayTagsType = {
                                 protocol: 'http://example.com/protocol/withTags',
@@ -248,16 +239,16 @@ export function testRecordsTags() {
                                 messageTimestamp: Time.getCurrentTimestamp(),
                                 definition: objectArrayTagsType
                             };
-                            const authorization = yield Message.createAuthorization({
+                            const authorization = await Message.createAuthorization({
                                 descriptor,
                                 signer: Jws.createSigner(alice)
                             });
                             const protocolsConfigureMessage = { descriptor, authorization };
-                            const objectArrayTagsTypeConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
+                            const objectArrayTagsTypeConfigureReply = await dwn.processMessage(alice.did, protocolsConfigureMessage);
                             expect(objectArrayTagsTypeConfigureReply.status.code).toBe(400);
-                        }));
-                        it('array of booleans', () => __awaiter(this, void 0, void 0, function* () {
-                            const alice = yield TestDataGenerator.generateDidKeyPersona();
+                        });
+                        it('array of booleans', async () => {
+                            const alice = await TestDataGenerator.generateDidKeyPersona();
                             // protocol definition with unsupported tag type array of booleans
                             const booleanArrayTagsType = {
                                 protocol: 'http://example.com/protocol/withTags',
@@ -284,18 +275,18 @@ export function testRecordsTags() {
                                 messageTimestamp: Time.getCurrentTimestamp(),
                                 definition: booleanArrayTagsType
                             };
-                            const authorization = yield Message.createAuthorization({
+                            const authorization = await Message.createAuthorization({
                                 descriptor,
                                 signer: Jws.createSigner(alice)
                             });
                             const protocolsConfigureMessage = { descriptor, authorization };
-                            const booleanArrayTagsTypeConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
+                            const booleanArrayTagsTypeConfigureReply = await dwn.processMessage(alice.did, protocolsConfigureMessage);
                             expect(booleanArrayTagsTypeConfigureReply.status.code).toBe(400);
-                        }));
+                        });
                     });
                 });
-                it('should reject a record with a tag property that does not match the protocol definition tags', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                it('should reject a record with a tag property that does not match the protocol definition tags', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // has a `knownTag` tag in the protocol definition
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -314,14 +305,14 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition,
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // write a foo record with an `unknownTag` tag.
-                    const fooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -330,13 +321,13 @@ export function testRecordsTags() {
                             unknownTag: 'some-value'
                         }
                     });
-                    const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
+                    const fooRecordReply = await dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
                     expect(fooRecordReply.status.code).toBe(400);
                     expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     // ensure the correct tag descriptor is in the error message
                     expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags must NOT have additional properties`);
                     // write a foo record with a `knownTag` tag.
-                    const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -346,11 +337,11 @@ export function testRecordsTags() {
                         }
                     });
                     // should pass
-                    const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                    const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                     expect(validFooRecordReply.status.code).toBe(202);
-                }));
-                it('should reject a tag value that does not match the boolean type', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should reject a tag value that does not match the boolean type', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with a boolean type for a tag
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -369,14 +360,14 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // `draft` should be a boolean type, but we are passing a string
-                    const fooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -385,12 +376,12 @@ export function testRecordsTags() {
                             draft: 'true'
                         }
                     });
-                    const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
+                    const fooRecordReply = await dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
                     expect(fooRecordReply.status.code).toBe(400);
                     expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/draft must be boolean`);
                     // positive test with a boolean
-                    const fooRecord2 = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord2 = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -399,11 +390,11 @@ export function testRecordsTags() {
                             draft: true
                         }
                     });
-                    const fooRecord2Reply = yield dwn.processMessage(alice.did, fooRecord2.message, { dataStream: fooRecord2.dataStream });
+                    const fooRecord2Reply = await dwn.processMessage(alice.did, fooRecord2.message, { dataStream: fooRecord2.dataStream });
                     expect(fooRecord2Reply.status.code).toBe(202);
-                }));
-                it('should reject a tag value that does not match the number type', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should reject a tag value that does not match the number type', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with a number type for a tag
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -422,14 +413,14 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // `numberType` should be a number type, but we are passing a string
-                    const fooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -438,12 +429,12 @@ export function testRecordsTags() {
                             numberType: '1'
                         }
                     });
-                    const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
+                    const fooRecordReply = await dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
                     expect(fooRecordReply.status.code).toBe(400);
                     expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/numberType must be number`);
                     // positive tests with an integer number
-                    const fooRecord2 = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord2 = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -452,10 +443,10 @@ export function testRecordsTags() {
                             numberType: 1
                         }
                     });
-                    const fooRecord2Reply = yield dwn.processMessage(alice.did, fooRecord2.message, { dataStream: fooRecord2.dataStream });
+                    const fooRecord2Reply = await dwn.processMessage(alice.did, fooRecord2.message, { dataStream: fooRecord2.dataStream });
                     expect(fooRecord2Reply.status.code).toBe(202);
                     // positive tests with a decimal number
-                    const fooRecord3 = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord3 = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -464,11 +455,11 @@ export function testRecordsTags() {
                             numberType: 1.5
                         }
                     });
-                    const fooRecord3Reply = yield dwn.processMessage(alice.did, fooRecord3.message, { dataStream: fooRecord3.dataStream });
+                    const fooRecord3Reply = await dwn.processMessage(alice.did, fooRecord3.message, { dataStream: fooRecord3.dataStream });
                     expect(fooRecord3Reply.status.code).toBe(202);
-                }));
-                it('should reject a tag value that does not match the integer type', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should reject a tag value that does not match the integer type', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with an integer type for a tag
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -487,14 +478,14 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // `count` should be an integer type, but we are passing decimal number
-                    const fooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -503,12 +494,12 @@ export function testRecordsTags() {
                             count: 1.5
                         }
                     });
-                    const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
+                    const fooRecordReply = await dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
                     expect(fooRecordReply.status.code).toBe(400);
                     expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/count must be integer`);
                     // positive test with an integer
-                    const fooRecord2 = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord2 = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -517,11 +508,11 @@ export function testRecordsTags() {
                             count: 1
                         }
                     });
-                    const fooRecord2Reply = yield dwn.processMessage(alice.did, fooRecord2.message, { dataStream: fooRecord2.dataStream });
+                    const fooRecord2Reply = await dwn.processMessage(alice.did, fooRecord2.message, { dataStream: fooRecord2.dataStream });
                     expect(fooRecord2Reply.status.code).toBe(202);
-                }));
-                it('should reject a record with a tag value that does not match a given enum in the protocol definition', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should reject a record with a tag value that does not match a given enum in the protocol definition', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with an enum for a tag
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -541,14 +532,14 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition,
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // write a foo record with an `unknown_status` tag value.
-                    const fooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -557,7 +548,7 @@ export function testRecordsTags() {
                             status: 'unknown_status'
                         }
                     });
-                    const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
+                    const fooRecordReply = await dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
                     expect(fooRecordReply.status.code).toBe(400);
                     expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     const expectedStatusMsg = `${protocolDefinition.protocol}/foo/$tags/status must be equal to one of the allowed values`;
@@ -565,7 +556,7 @@ export function testRecordsTags() {
                     // ensure the correct tag descriptor path is in the error message
                     expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/status`);
                     // write a foo record with a valid `status` tag value.
-                    const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -575,11 +566,11 @@ export function testRecordsTags() {
                         }
                     });
                     // should pass
-                    const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                    const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                     expect(validFooRecordReply.status.code).toBe(202);
-                }));
-                it('should reject a record with a tag value that is not within the `minimum` and `maximum` range', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should reject a record with a tag value that is not within the `minimum` and `maximum` range', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with minimum and maximum for a number
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -600,14 +591,14 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition,
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // write a foo record with an `score` value less than 0.
-                    const fooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -617,12 +608,12 @@ export function testRecordsTags() {
                         }
                     });
                     // should fail
-                    const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
+                    const fooRecordReply = await dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
                     expect(fooRecordReply.status.code).toBe(400);
                     expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/score must be >= 0`);
                     // write a foo record with an `score` value greater than 100.
-                    const fooRecord2 = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord2 = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -632,12 +623,12 @@ export function testRecordsTags() {
                         }
                     });
                     // should fail
-                    const fooRecord2Reply = yield dwn.processMessage(alice.did, fooRecord2.message, { dataStream: fooRecord2.dataStream });
+                    const fooRecord2Reply = await dwn.processMessage(alice.did, fooRecord2.message, { dataStream: fooRecord2.dataStream });
                     expect(fooRecord2Reply.status.code).toBe(400);
                     expect(fooRecord2Reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(fooRecord2Reply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/score must be <= 100`);
                     // write a foo record with a maximum `score` of 100.
-                    const validFooMaxRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const validFooMaxRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -647,10 +638,10 @@ export function testRecordsTags() {
                         }
                     });
                     // should pass
-                    const validFooMaxRecordReply = yield dwn.processMessage(alice.did, validFooMaxRecord.message, { dataStream: validFooMaxRecord.dataStream });
+                    const validFooMaxRecordReply = await dwn.processMessage(alice.did, validFooMaxRecord.message, { dataStream: validFooMaxRecord.dataStream });
                     expect(validFooMaxRecordReply.status.code).toBe(202);
                     // write a foo record with a maximum `score` of 0.
-                    const validFooMinRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const validFooMinRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -660,10 +651,10 @@ export function testRecordsTags() {
                         }
                     });
                     // should pass
-                    const validFooMinRecordReply = yield dwn.processMessage(alice.did, validFooMinRecord.message, { dataStream: validFooMinRecord.dataStream });
+                    const validFooMinRecordReply = await dwn.processMessage(alice.did, validFooMinRecord.message, { dataStream: validFooMinRecord.dataStream });
                     expect(validFooMinRecordReply.status.code).toBe(202);
                     // write a foo record within the range
-                    const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -673,11 +664,11 @@ export function testRecordsTags() {
                         }
                     });
                     // should pass
-                    const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                    const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                     expect(validFooRecordReply.status.code).toBe(202);
-                }));
-                it('should reject a record with a tag value that is not within the `exclusiveMinimum` and `exclusiveMaximum` range', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should reject a record with a tag value that is not within the `exclusiveMinimum` and `exclusiveMaximum` range', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with exclusiveMinimum and exclusiveMaximum for a number
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -698,14 +689,14 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition,
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // write a foo record with an hour at the exclusiveMaximum
-                    const exclusiveMaxRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const exclusiveMaxRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -715,12 +706,12 @@ export function testRecordsTags() {
                         }
                     });
                     // should fail
-                    const exclusiveMaxReply = yield dwn.processMessage(alice.did, exclusiveMaxRecord.message, { dataStream: exclusiveMaxRecord.dataStream });
+                    const exclusiveMaxReply = await dwn.processMessage(alice.did, exclusiveMaxRecord.message, { dataStream: exclusiveMaxRecord.dataStream });
                     expect(exclusiveMaxReply.status.code).toBe(400);
                     expect(exclusiveMaxReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(exclusiveMaxReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/hours must be < 24`);
                     // write a foo record with an hour at the exclusiveMinimum
-                    const exclusiveMinRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const exclusiveMinRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -730,12 +721,12 @@ export function testRecordsTags() {
                         }
                     });
                     // should fail
-                    const exclusiveMinReply = yield dwn.processMessage(alice.did, exclusiveMinRecord.message, { dataStream: exclusiveMinRecord.dataStream });
+                    const exclusiveMinReply = await dwn.processMessage(alice.did, exclusiveMinRecord.message, { dataStream: exclusiveMinRecord.dataStream });
                     expect(exclusiveMinReply.status.code).toBe(400);
                     expect(exclusiveMinReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(exclusiveMinReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/hours must be > 0`);
                     // write a foo record with an `hour` value within the range.
-                    const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -745,11 +736,11 @@ export function testRecordsTags() {
                         }
                     });
                     // should pass
-                    const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                    const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                     expect(validFooRecordReply.status.code).toBe(202);
-                }));
-                it('should reject tag values that are not within the `minLength` and `maxLength` values', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should reject tag values that are not within the `minLength` and `maxLength` values', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with minLength and maxLength for a string
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -770,14 +761,14 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition,
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // write a foo record with a `stringWithLimit` value less than the minimum length
-                    const minLengthRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const minLengthRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -787,13 +778,13 @@ export function testRecordsTags() {
                         }
                     });
                     // should fail
-                    const minLengthReply = yield dwn.processMessage(alice.did, minLengthRecord.message, { dataStream: minLengthRecord.dataStream });
+                    const minLengthReply = await dwn.processMessage(alice.did, minLengthRecord.message, { dataStream: minLengthRecord.dataStream });
                     expect(minLengthReply.status.code).toBe(400);
                     expect(minLengthReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     const expectedMinMsg = `${protocolDefinition.protocol}/foo/$tags/stringWithLimit must NOT have fewer than 5 characters`;
                     expect(minLengthReply.status.detail).toContain(expectedMinMsg);
                     // write a foo record with a `stringWithLimit` value greater than the maximum length
-                    const maxLengthRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const maxLengthRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -803,13 +794,13 @@ export function testRecordsTags() {
                         }
                     });
                     // should fail
-                    const maxLengthReply = yield dwn.processMessage(alice.did, maxLengthRecord.message, { dataStream: maxLengthRecord.dataStream });
+                    const maxLengthReply = await dwn.processMessage(alice.did, maxLengthRecord.message, { dataStream: maxLengthRecord.dataStream });
                     expect(maxLengthReply.status.code).toBe(400);
                     expect(maxLengthReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     const expectedMaxMsg = `${protocolDefinition.protocol}/foo/$tags/stringWithLimit must NOT have more than 10 characters`;
                     expect(maxLengthReply.status.detail).toContain(expectedMaxMsg);
                     // write a foo record with a `stringWithLimit` value within the range
-                    const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -819,11 +810,11 @@ export function testRecordsTags() {
                         }
                     });
                     // should pass
-                    const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                    const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                     expect(validFooRecordReply.status.code).toBe(202);
-                }));
-                it('should reject tag values that do not contain the number of items within the `minItems` and `maxItems` values', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should reject tag values that do not contain the number of items within the `minItems` and `maxItems` values', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with minItems and maxItems for an array of numbers
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -847,14 +838,14 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition,
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // write a foo record with a `numberArray` value with only 1 item, less than the `minItems` specified of 2
-                    const minLengthRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const minLengthRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -864,12 +855,12 @@ export function testRecordsTags() {
                         }
                     });
                     // should fail
-                    const minLengthReply = yield dwn.processMessage(alice.did, minLengthRecord.message, { dataStream: minLengthRecord.dataStream });
+                    const minLengthReply = await dwn.processMessage(alice.did, minLengthRecord.message, { dataStream: minLengthRecord.dataStream });
                     expect(minLengthReply.status.code).toBe(400);
                     expect(minLengthReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(minLengthReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/numberArray must NOT have fewer than 2 items`);
                     // write a foo record with a `numberArray` value with 4 items, more than the `maxItems` specified of 3
-                    const maxLengthRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const maxLengthRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -879,12 +870,12 @@ export function testRecordsTags() {
                         }
                     });
                     // should fail
-                    const maxLengthReply = yield dwn.processMessage(alice.did, maxLengthRecord.message, { dataStream: maxLengthRecord.dataStream });
+                    const maxLengthReply = await dwn.processMessage(alice.did, maxLengthRecord.message, { dataStream: maxLengthRecord.dataStream });
                     expect(maxLengthReply.status.code).toBe(400);
                     expect(maxLengthReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(maxLengthReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/numberArray must NOT have more than 3 items`);
                     // write a foo record with a `numberArray` value with 3 items, within the range
-                    const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -894,11 +885,11 @@ export function testRecordsTags() {
                         }
                     });
                     // should pass
-                    const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                    const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                     expect(validFooRecordReply.status.code).toBe(202);
-                }));
-                it('should reject a value within an array that should only include numbers', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should reject a value within an array that should only include numbers', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with an array of numbers
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -920,14 +911,14 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // write a foo record with a `numberArray` value with a string
-                    const fooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -937,12 +928,12 @@ export function testRecordsTags() {
                         }
                     });
                     // should fail
-                    const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
+                    const fooRecordReply = await dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
                     expect(fooRecordReply.status.code).toBe(400);
                     expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/numberArray/0 must be number`);
                     // write a foo record with a `numberArray` value with a number (both integer and decimal)
-                    const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -952,11 +943,11 @@ export function testRecordsTags() {
                         }
                     });
                     // should pass
-                    const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                    const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                     expect(validFooRecordReply.status.code).toBe(202);
-                }));
-                it('should reject a value within an array that should only include integers', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should reject a value within an array that should only include integers', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with an array of numbers
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -978,14 +969,14 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // write a foo record with a `numberArray` value with a decimal
-                    const fooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -995,12 +986,12 @@ export function testRecordsTags() {
                         }
                     });
                     // should fail
-                    const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
+                    const fooRecordReply = await dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
                     expect(fooRecordReply.status.code).toBe(400);
                     expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags/numberArray/1 must be integer`);
                     // write a foo record with a `numberArray` value with values of integers
-                    const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -1010,11 +1001,11 @@ export function testRecordsTags() {
                         }
                     });
                     // should pass
-                    const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                    const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                     expect(validFooRecordReply.status.code).toBe(202);
-                }));
-                it('should reject tag values that do not contain the number of items within the `minContains` and `maxContains` values', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should reject tag values that do not contain the number of items within the `minContains` and `maxContains` values', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with minContains and maxContains for an array of numbers
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -1043,15 +1034,15 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition,
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // write a foo record with a `numberArray` value with only 1 item that matches contains contraint, less than the `minContains` of 2
                     // but additional items that would equal more than 2 items
-                    const minLengthRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const minLengthRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -1061,13 +1052,13 @@ export function testRecordsTags() {
                         }
                     });
                     // should fail
-                    const minLengthReply = yield dwn.processMessage(alice.did, minLengthRecord.message, { dataStream: minLengthRecord.dataStream });
+                    const minLengthReply = await dwn.processMessage(alice.did, minLengthRecord.message, { dataStream: minLengthRecord.dataStream });
                     expect(minLengthReply.status.code).toBe(400);
                     expect(minLengthReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(minLengthReply.status.detail)
                         .toContain(`${protocolDefinition.protocol}/foo/$tags/numberArray must contain at least 2 and no more than 4 valid item(s)`);
                     // write a foo record with a `numberArray` value with 4 items, more than the `maxItems` specified of 3
-                    const maxLengthRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const maxLengthRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -1077,13 +1068,13 @@ export function testRecordsTags() {
                         }
                     });
                     // should fail
-                    const maxLengthReply = yield dwn.processMessage(alice.did, maxLengthRecord.message, { dataStream: maxLengthRecord.dataStream });
+                    const maxLengthReply = await dwn.processMessage(alice.did, maxLengthRecord.message, { dataStream: maxLengthRecord.dataStream });
                     expect(maxLengthReply.status.code).toBe(400);
                     expect(maxLengthReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(maxLengthReply.status.detail)
                         .toContain(`${protocolDefinition.protocol}/foo/$tags/numberArray must contain at least 2 and no more than 4 valid item(s)`);
                     // write a foo record with a `numberArray` value with 3 items, within the range
-                    const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -1093,11 +1084,11 @@ export function testRecordsTags() {
                         }
                     });
                     // should pass
-                    const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                    const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                     expect(validFooRecordReply.status.code).toBe(202);
-                }));
-                it('should reject tag values that do not follow the constraints of the `uniqueItems` value', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should reject tag values that do not follow the constraints of the `uniqueItems` value', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with uniqueItems for an array of strings
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -1120,14 +1111,14 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition,
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // write a foo record with a `uniqueStrings` value with duplicate items
-                    const duplicateItemsRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const duplicateItemsRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -1137,10 +1128,10 @@ export function testRecordsTags() {
                         }
                     });
                     // should fail
-                    const duplicateItemsReply = yield dwn.processMessage(alice.did, duplicateItemsRecord.message, { dataStream: duplicateItemsRecord.dataStream });
+                    const duplicateItemsReply = await dwn.processMessage(alice.did, duplicateItemsRecord.message, { dataStream: duplicateItemsRecord.dataStream });
                     expect(duplicateItemsReply.status.code).toBe(400);
                     // write a foo record with a `uniqueStrings` value with unique items
-                    const uniqueItemsRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const uniqueItemsRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -1150,11 +1141,11 @@ export function testRecordsTags() {
                         }
                     });
                     // should pass
-                    const uniqueItemsReply = yield dwn.processMessage(alice.did, uniqueItemsRecord.message, { dataStream: uniqueItemsRecord.dataStream });
+                    const uniqueItemsReply = await dwn.processMessage(alice.did, uniqueItemsRecord.message, { dataStream: uniqueItemsRecord.dataStream });
                     expect(uniqueItemsReply.status.code).toBe(202);
-                }));
-                it('should only accept a record containing tags required by $requiredTags', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should only accept a record containing tags required by $requiredTags', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with a required tag
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -1174,25 +1165,25 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition,
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // write a foo record without the required tag
-                    const fooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'foo',
                     });
-                    const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
+                    const fooRecordReply = await dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
                     expect(fooRecordReply.status.code).toBe(400);
                     expect(fooRecordReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                     expect(fooRecordReply.status.detail).toContain(`${protocolDefinition.protocol}/foo/$tags must have required property 'someRequiredTag'`);
                     // write a foo record with the required tag
-                    const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -1202,11 +1193,11 @@ export function testRecordsTags() {
                         }
                     });
                     // should pass
-                    const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                    const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                     expect(validFooRecordReply.status.code).toBe(202);
-                }));
-                it('should accept any tag if $allowUndefinedTags is set to true', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('should accept any tag if $allowUndefinedTags is set to true', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
                     // protocol with no required tags
                     const protocolDefinition = {
                         protocol: 'http://example.com/protocol/withTags',
@@ -1226,14 +1217,14 @@ export function testRecordsTags() {
                         },
                     };
                     // configure tags protocol
-                    const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition,
                     });
-                    const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                    const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                     expect(configureReply.status.code).toBe(202);
                     // write a foo record without the required tag
-                    const fooRecord = yield TestDataGenerator.generateRecordsWrite({
+                    const fooRecord = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         published: true,
                         protocol: protocolDefinition.protocol,
@@ -1242,12 +1233,12 @@ export function testRecordsTags() {
                             randomTag: 'some-value'
                         }
                     });
-                    const fooRecordReply = yield dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
+                    const fooRecordReply = await dwn.processMessage(alice.did, fooRecord.message, { dataStream: fooRecord.dataStream });
                     expect(fooRecordReply.status.code).toBe(202);
-                }));
+                });
                 describe('contains', () => {
-                    it('should reject a record tag that does not contain a value specified within the `enum` definition', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    it('should reject a record tag that does not contain a value specified within the `enum` definition', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
                         // protocol with `enum` definition within `contains`
                         const protocolDefinition = {
                             protocol: 'http://example.com/protocol/withTags',
@@ -1273,14 +1264,14 @@ export function testRecordsTags() {
                             },
                         };
                         // configure tags protocol
-                        const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition,
                         });
-                        const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                        const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                         expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `status` value that is not represented in the `enum`
-                        const invalidEnumRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const invalidEnumRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1290,13 +1281,13 @@ export function testRecordsTags() {
                             }
                         });
                         // should fail
-                        const invalidEnumReply = yield dwn.processMessage(alice.did, invalidEnumRecord.message, { dataStream: invalidEnumRecord.dataStream });
+                        const invalidEnumReply = await dwn.processMessage(alice.did, invalidEnumRecord.message, { dataStream: invalidEnumRecord.dataStream });
                         expect(invalidEnumReply.status.code).toBe(400);
                         expect(invalidEnumReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(invalidEnumReply.status.detail)
                             .toContain(`${protocolDefinition.protocol}/foo/$tags/status must contain at least 1 valid item(s)`);
                         // write a foo record that now adds a valid `status` value to the array
-                        const validEnumRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const validEnumRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1306,11 +1297,11 @@ export function testRecordsTags() {
                             }
                         });
                         // should pass
-                        const validEnumReply = yield dwn.processMessage(alice.did, validEnumRecord.message, { dataStream: validEnumRecord.dataStream });
+                        const validEnumReply = await dwn.processMessage(alice.did, validEnumRecord.message, { dataStream: validEnumRecord.dataStream });
                         expect(validEnumReply.status.code).toBe(202);
-                    }));
-                    it('should reject a record tag that does not contain a value within the `minimum` and `maximum` range ', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    });
+                    it('should reject a record tag that does not contain a value within the `minimum` and `maximum` range ', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
                         // protocol with `minimum` and `maximum` definitions within `contains`
                         const protocolDefinition = {
                             protocol: 'http://example.com/protocol/withTags',
@@ -1337,14 +1328,14 @@ export function testRecordsTags() {
                             },
                         };
                         // configure tags protocol
-                        const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition,
                         });
-                        const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                        const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                         expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `containsNumbers` value that does not have a number within the range
-                        const minContainsRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const minContainsRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1354,13 +1345,13 @@ export function testRecordsTags() {
                             }
                         });
                         // should fail
-                        const minContainsReply = yield dwn.processMessage(alice.did, minContainsRecord.message, { dataStream: minContainsRecord.dataStream });
+                        const minContainsReply = await dwn.processMessage(alice.did, minContainsRecord.message, { dataStream: minContainsRecord.dataStream });
                         expect(minContainsReply.status.code).toBe(400);
                         expect(minContainsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(minContainsReply.status.detail)
                             .toContain(`${protocolDefinition.protocol}/foo/$tags/containsNumbers must contain at least 1 valid item(s)`);
                         // write a foo record with a `containsNumbers` value that has a number within the range
-                        const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1370,11 +1361,11 @@ export function testRecordsTags() {
                             }
                         });
                         // should pass
-                        const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                        const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                         expect(validFooRecordReply.status.code).toBe(202);
-                    }));
-                    it('should reject a record tag that does not contain a value within the `exclusiveMinimum` and `exclusiveMaximum` range ', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    });
+                    it('should reject a record tag that does not contain a value within the `exclusiveMinimum` and `exclusiveMaximum` range ', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
                         // protocol with `minimum` and `maximum` definitions within `contains`
                         const protocolDefinition = {
                             protocol: 'http://example.com/protocol/withTags',
@@ -1401,14 +1392,14 @@ export function testRecordsTags() {
                             },
                         };
                         // configure tags protocol
-                        const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition,
                         });
-                        const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                        const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                         expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `containsNumbers` value that does not have a number within the range
-                        const minContainsRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const minContainsRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1418,13 +1409,13 @@ export function testRecordsTags() {
                             }
                         });
                         // should fail
-                        const minContainsReply = yield dwn.processMessage(alice.did, minContainsRecord.message, { dataStream: minContainsRecord.dataStream });
+                        const minContainsReply = await dwn.processMessage(alice.did, minContainsRecord.message, { dataStream: minContainsRecord.dataStream });
                         expect(minContainsReply.status.code).toBe(400);
                         expect(minContainsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(minContainsReply.status.detail)
                             .toContain(`${protocolDefinition.protocol}/foo/$tags/containsNumbers must contain at least 1 valid item(s)`);
                         // write a foo record with a `containsNumbers` value that has a number within the range
-                        const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1434,11 +1425,11 @@ export function testRecordsTags() {
                             }
                         });
                         // should pass
-                        const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                        const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                         expect(validFooRecordReply.status.code).toBe(202);
-                    }));
-                    it('should reject a record tag that does not contain a value within the `minLength` and `maxLength` range ', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    });
+                    it('should reject a record tag that does not contain a value within the `minLength` and `maxLength` range ', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
                         // protocol with `minLength` and `maxLength` definitions within `contains`
                         const protocolDefinition = {
                             protocol: 'http://example.com/protocol/withTags',
@@ -1465,14 +1456,14 @@ export function testRecordsTags() {
                             },
                         };
                         // configure tags protocol
-                        const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition,
                         });
-                        const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                        const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                         expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `firstName` value that does not have a string within the range
-                        const minContainsRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const minContainsRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1482,13 +1473,13 @@ export function testRecordsTags() {
                             }
                         });
                         // should fail
-                        const minContainsReply = yield dwn.processMessage(alice.did, minContainsRecord.message, { dataStream: minContainsRecord.dataStream });
+                        const minContainsReply = await dwn.processMessage(alice.did, minContainsRecord.message, { dataStream: minContainsRecord.dataStream });
                         expect(minContainsReply.status.code).toBe(400);
                         expect(minContainsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         const expectedContainsMsg = `${protocolDefinition.protocol}/foo/$tags/nickNames must contain at least 1 valid item(s)`;
                         expect(minContainsReply.status.detail).toContain(expectedContainsMsg);
                         // write a foo record with a `nickNames` value that has a string within the range
-                        const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1498,13 +1489,13 @@ export function testRecordsTags() {
                             }
                         });
                         // should pass
-                        const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                        const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                         expect(validFooRecordReply.status.code).toBe(202);
-                    }));
+                    });
                 });
                 describe('items', () => {
-                    it('should reject a record tag that includes a value not specified within the `enum` definition', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    it('should reject a record tag that includes a value not specified within the `enum` definition', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
                         // protocol with `enum` definition within `items`
                         const protocolDefinition = {
                             protocol: 'http://example.com/protocol/withTags',
@@ -1527,14 +1518,14 @@ export function testRecordsTags() {
                             },
                         };
                         // configure tags protocol
-                        const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition,
                         });
-                        const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                        const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                         expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `status` value that is not represented in the `enum`
-                        const invalidEnumRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const invalidEnumRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1544,13 +1535,13 @@ export function testRecordsTags() {
                             }
                         });
                         // should fail
-                        const invalidEnumReply = yield dwn.processMessage(alice.did, invalidEnumRecord.message, { dataStream: invalidEnumRecord.dataStream });
+                        const invalidEnumReply = await dwn.processMessage(alice.did, invalidEnumRecord.message, { dataStream: invalidEnumRecord.dataStream });
                         expect(invalidEnumReply.status.code).toBe(400);
                         expect(invalidEnumReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(invalidEnumReply.status.detail)
                             .toContain(`${protocolDefinition.protocol}/foo/$tags/status/1 must be equal to one of the allowed values`);
                         // write a foo record that now includes only valid `status` values
-                        const validEnumRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const validEnumRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1560,11 +1551,11 @@ export function testRecordsTags() {
                             }
                         });
                         // should pass
-                        const validEnumReply = yield dwn.processMessage(alice.did, validEnumRecord.message, { dataStream: validEnumRecord.dataStream });
+                        const validEnumReply = await dwn.processMessage(alice.did, validEnumRecord.message, { dataStream: validEnumRecord.dataStream });
                         expect(validEnumReply.status.code).toBe(202);
-                    }));
-                    it('should reject a record tag which all items do not have a value within the `minimum` and `maximum` range ', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    });
+                    it('should reject a record tag which all items do not have a value within the `minimum` and `maximum` range ', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
                         // protocol with minContains and maxContains for an array of numbers
                         const protocolDefinition = {
                             protocol: 'http://example.com/protocol/withTags',
@@ -1588,14 +1579,14 @@ export function testRecordsTags() {
                             },
                         };
                         // configure tags protocol
-                        const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition,
                         });
-                        const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                        const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                         expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `numbers` value that is less than the minimum
-                        const minItemssRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const minItemssRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1605,13 +1596,13 @@ export function testRecordsTags() {
                             }
                         });
                         // should fail
-                        const minItemsReply = yield dwn.processMessage(alice.did, minItemssRecord.message, { dataStream: minItemssRecord.dataStream });
+                        const minItemsReply = await dwn.processMessage(alice.did, minItemssRecord.message, { dataStream: minItemssRecord.dataStream });
                         expect(minItemsReply.status.code).toBe(400);
                         expect(minItemsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(minItemsReply.status.detail)
                             .toContain(`${protocolDefinition.protocol}/foo/$tags/numbers/0 must be >= 80`);
                         // write a foo record with a `numbers` value that is more than the maximum
-                        const maxItemssRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const maxItemssRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1621,13 +1612,13 @@ export function testRecordsTags() {
                             }
                         });
                         // should fail
-                        const maxItemsReply = yield dwn.processMessage(alice.did, maxItemssRecord.message, { dataStream: maxItemssRecord.dataStream });
+                        const maxItemsReply = await dwn.processMessage(alice.did, maxItemssRecord.message, { dataStream: maxItemssRecord.dataStream });
                         expect(maxItemsReply.status.code).toBe(400);
                         expect(maxItemsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(maxItemsReply.status.detail)
                             .toContain(`${protocolDefinition.protocol}/foo/$tags/numbers/1 must be <= 100`);
                         // write a foo record with a `numbers` value that are within the range
-                        const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1637,11 +1628,11 @@ export function testRecordsTags() {
                             }
                         });
                         // should pass
-                        const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                        const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                         expect(validFooRecordReply.status.code).toBe(202);
-                    }));
-                    it('should reject a record tag which all items do not have a value within the `exclusiveMinimum` and `exclusiveMaximum` range ', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    });
+                    it('should reject a record tag which all items do not have a value within the `exclusiveMinimum` and `exclusiveMaximum` range ', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
                         // protocol with minContains and maxContains for an array of numbers
                         const protocolDefinition = {
                             protocol: 'http://example.com/protocol/withTags',
@@ -1665,14 +1656,14 @@ export function testRecordsTags() {
                             },
                         };
                         // configure tags protocol
-                        const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition,
                         });
-                        const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                        const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                         expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `numbers` value that is equal to than the exclusive minimum
-                        const minItemsRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const minItemsRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1682,13 +1673,13 @@ export function testRecordsTags() {
                             }
                         });
                         // should fail
-                        const minItemsReply = yield dwn.processMessage(alice.did, minItemsRecord.message, { dataStream: minItemsRecord.dataStream });
+                        const minItemsReply = await dwn.processMessage(alice.did, minItemsRecord.message, { dataStream: minItemsRecord.dataStream });
                         expect(minItemsReply.status.code).toBe(400);
                         expect(minItemsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(minItemsReply.status.detail)
                             .toContain(`${protocolDefinition.protocol}/foo/$tags/numbers/0 must be > 80`);
                         // write a foo record with a `numbers` value that is equal to than the exclusive maximum
-                        const maxContainsRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const maxContainsRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1698,13 +1689,13 @@ export function testRecordsTags() {
                             }
                         });
                         // should fail
-                        const maxItemsReply = yield dwn.processMessage(alice.did, maxContainsRecord.message, { dataStream: maxContainsRecord.dataStream });
+                        const maxItemsReply = await dwn.processMessage(alice.did, maxContainsRecord.message, { dataStream: maxContainsRecord.dataStream });
                         expect(maxItemsReply.status.code).toBe(400);
                         expect(maxItemsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         expect(maxItemsReply.status.detail)
                             .toContain(`${protocolDefinition.protocol}/foo/$tags/numbers/1 must be < 100`);
                         // write a foo record with a `numbers` value that are within the range
-                        const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1714,11 +1705,11 @@ export function testRecordsTags() {
                             }
                         });
                         // should pass
-                        const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                        const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                         expect(validFooRecordReply.status.code).toBe(202);
-                    }));
-                    it('should reject a record tag that does not contain a value within the `minLength` and `maxLength` range ', () => __awaiter(this, void 0, void 0, function* () {
-                        const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    });
+                    it('should reject a record tag that does not contain a value within the `minLength` and `maxLength` range ', async () => {
+                        const alice = await TestDataGenerator.generateDidKeyPersona();
                         // protocol with `minLength` and `maxLength` definitions within `contains`
                         const protocolDefinition = {
                             protocol: 'http://example.com/protocol/withTags',
@@ -1742,14 +1733,14 @@ export function testRecordsTags() {
                             },
                         };
                         // configure tags protocol
-                        const protocolConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                        const protocolConfigure = await TestDataGenerator.generateProtocolsConfigure({
                             author: alice,
                             protocolDefinition,
                         });
-                        const configureReply = yield dwn.processMessage(alice.did, protocolConfigure.message);
+                        const configureReply = await dwn.processMessage(alice.did, protocolConfigure.message);
                         expect(configureReply.status.code).toBe(202);
                         // write a foo record with a `firstName` value that does not have a string within the range
-                        const minItemsRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const minItemsRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1759,13 +1750,13 @@ export function testRecordsTags() {
                             }
                         });
                         // should fail
-                        const minItemsReply = yield dwn.processMessage(alice.did, minItemsRecord.message, { dataStream: minItemsRecord.dataStream });
+                        const minItemsReply = await dwn.processMessage(alice.did, minItemsRecord.message, { dataStream: minItemsRecord.dataStream });
                         expect(minItemsReply.status.code).toBe(400);
                         expect(minItemsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         const expectedMinItemsMsg = `${protocolDefinition.protocol}/foo/$tags/nickNames/1 must NOT have fewer than 2 characters`;
                         expect(minItemsReply.status.detail).toContain(expectedMinItemsMsg);
                         // write a foo record with a `nickname` value this is too long
-                        const maxItemsRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const maxItemsRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1775,13 +1766,13 @@ export function testRecordsTags() {
                             }
                         });
                         // should fail
-                        const maxItemsReply = yield dwn.processMessage(alice.did, maxItemsRecord.message, { dataStream: maxItemsRecord.dataStream });
+                        const maxItemsReply = await dwn.processMessage(alice.did, maxItemsRecord.message, { dataStream: maxItemsRecord.dataStream });
                         expect(maxItemsReply.status.code).toBe(400);
                         expect(maxItemsReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationTagsInvalidSchema);
                         const expectedMaxItemsMsg = `${protocolDefinition.protocol}/foo/$tags/nickNames/1 must NOT have more than 10 characters`;
                         expect(maxItemsReply.status.detail).toContain(expectedMaxItemsMsg);
                         // write a foo record with a `nickNames` value that has a string within the range
-                        const validFooRecord = yield TestDataGenerator.generateRecordsWrite({
+                        const validFooRecord = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
                             published: true,
                             protocol: protocolDefinition.protocol,
@@ -1791,20 +1782,21 @@ export function testRecordsTags() {
                             }
                         });
                         // should pass
-                        const validFooRecordReply = yield dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
+                        const validFooRecordReply = await dwn.processMessage(alice.did, validFooRecord.message, { dataStream: validFooRecord.dataStream });
                         expect(validFooRecordReply.status.code).toBe(202);
-                    }));
+                    });
                 });
             });
-            it('should be able to write a Record with tags', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            it('should be able to write a Record with tags', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // create tags that represent `string[]`, `number[]`, `string`, `number`, or `boolean` values.
                 const stringTag = 'string-value';
                 const stringArrayTag = ['string-value', 'string-value2'];
                 const numberTag = 54566975;
                 const numberArrayTag = [0, 1, 2];
                 const booleanTag = false;
-                const tagsRecord1 = yield TestDataGenerator.generateRecordsWrite({
+                const tagsRecord1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -1816,25 +1808,25 @@ export function testRecordsTags() {
                         numberArrayTag,
                     }
                 });
-                const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
+                const tagsRecord1Reply = await dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
                 expect(tagsRecord1Reply.status.code).toBe(202);
                 // verify the record was written
-                const tagsRecord1Read = yield RecordsRead.create({
+                const tagsRecord1Read = await RecordsRead.create({
                     filter: {
                         recordId: tagsRecord1.message.recordId,
                     },
                     signer: Jws.createSigner(alice)
                 });
-                const tagsRecord1ReadReply = yield dwn.processMessage(alice.did, tagsRecord1Read.message);
+                const tagsRecord1ReadReply = await dwn.processMessage(alice.did, tagsRecord1Read.message);
                 expect(tagsRecord1ReadReply.status.code).toBe(200);
                 expect(tagsRecord1ReadReply.entry.recordsWrite).toBeDefined();
                 expect(tagsRecord1ReadReply.entry.recordsWrite.descriptor.tags)
                     .toEqual({ stringTag, numberTag, booleanTag, stringArrayTag, numberArrayTag });
-            }));
-            it('should overwrite tags when updating a Record', () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const tagsRecord1 = yield TestDataGenerator.generateRecordsWrite({
+            });
+            it('should overwrite tags when updating a Record', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const tagsRecord1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -1847,16 +1839,16 @@ export function testRecordsTags() {
                     }
                 });
                 // write the record
-                const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
+                const tagsRecord1Reply = await dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
                 expect(tagsRecord1Reply.status.code).toBe(202);
                 // verify the record was written
-                const tagsRecord1Read = yield RecordsRead.create({
+                const tagsRecord1Read = await RecordsRead.create({
                     filter: {
                         recordId: tagsRecord1.message.recordId,
                     },
                     signer: Jws.createSigner(alice)
                 });
-                const tagsRecord1ReadReply = yield dwn.processMessage(alice.did, tagsRecord1Read.message);
+                const tagsRecord1ReadReply = await dwn.processMessage(alice.did, tagsRecord1Read.message);
                 expect(tagsRecord1ReadReply.status.code).toBe(200);
                 expect(tagsRecord1ReadReply.entry.recordsWrite).toBeDefined();
                 expect(tagsRecord1ReadReply.entry.recordsWrite.descriptor.tags).toEqual({
@@ -1867,7 +1859,7 @@ export function testRecordsTags() {
                     numberArrayTag: [0, 1, 2],
                 });
                 // Sanity: Query for a tag value
-                const tagsQueryMatch = yield TestDataGenerator.generateRecordsQuery({
+                const tagsQueryMatch = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -1875,33 +1867,34 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
+                const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchReply.entries?.length).toBe(1);
                 expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // update the record with new tags
-                const updatedRecord = yield TestDataGenerator.generateFromRecordsWrite({
+                const updatedRecord = await TestDataGenerator.generateFromRecordsWrite({
                     author: alice,
                     existingWrite: tagsRecord1.recordsWrite,
                     tags: { newTag: 'new-value' }
                 });
-                const updatedRecordReply = yield dwn.processMessage(alice.did, updatedRecord.message, { dataStream: updatedRecord.dataStream });
+                const updatedRecordReply = await dwn.processMessage(alice.did, updatedRecord.message, { dataStream: updatedRecord.dataStream });
                 expect(updatedRecordReply.status.code).toBe(202, updatedRecordReply.status.detail);
-                const updatedRecordReadReply = yield dwn.processMessage(alice.did, tagsRecord1Read.message);
+                const updatedRecordReadReply = await dwn.processMessage(alice.did, tagsRecord1Read.message);
                 expect(updatedRecordReadReply.status.code).toBe(200);
                 expect(updatedRecordReadReply.entry.recordsWrite).toBeDefined();
                 expect(updatedRecordReadReply.entry.recordsWrite.descriptor.tags).toEqual({ newTag: 'new-value' });
                 // Sanity: Query for the old tag value should return no results
-                const tagsQueryMatchReply2 = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
+                const tagsQueryMatchReply2 = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply2.status.code).toBe(200);
-                expect((_b = tagsQueryMatchReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
-            }));
-            it('should not index tags when the record is not `latestBaseState`', () => __awaiter(this, void 0, void 0, function* () {
+                expect(tagsQueryMatchReply2.entries?.length).toBe(0);
+            });
+            it('should not index tags when the record is not `latestBaseState`', async () => {
                 const buildTagIndexSpy = sinon.spy(Records, 'buildTagIndexes');
                 const constructIndexesSpy = sinon.spy(RecordsWrite.prototype, 'constructIndexes');
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // write a record with tags, this should trigger the `buildTagIndexes` method
-                const tagsRecord1 = yield TestDataGenerator.generateRecordsWrite({
+                const tagsRecord1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -1914,7 +1907,7 @@ export function testRecordsTags() {
                     }
                 });
                 // write the record
-                const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
+                const tagsRecord1Reply = await dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
                 expect(tagsRecord1Reply.status.code).toBe(202);
                 // verify that construct Indexes was called
                 expect(constructIndexesSpy.callCount).toBe(1);
@@ -1924,24 +1917,24 @@ export function testRecordsTags() {
                 constructIndexesSpy.resetHistory();
                 buildTagIndexSpy.resetHistory();
                 // update the record without any tags this time
-                const updatedRecord = yield TestDataGenerator.generateFromRecordsWrite({
+                const updatedRecord = await TestDataGenerator.generateFromRecordsWrite({
                     author: alice,
                     existingWrite: tagsRecord1.recordsWrite,
                 });
-                const updatedRecordReply = yield dwn.processMessage(alice.did, updatedRecord.message, { dataStream: updatedRecord.dataStream });
+                const updatedRecordReply = await dwn.processMessage(alice.did, updatedRecord.message, { dataStream: updatedRecord.dataStream });
                 expect(updatedRecordReply.status.code).toBe(202);
                 // construct Indexes should be called once for the `initialWrite` and once for the updated write
                 expect(constructIndexesSpy.callCount).toBe(2);
                 // verify that buildTagIndexes was not called at all
                 expect(buildTagIndexSpy.callCount).toBe(0);
-            }));
+            });
         });
         describe('RecordsQuery filter for tags', () => {
-            it('should be able to filter by string match', () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            it('should be able to filter by string match', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const stringTag = 'string-value';
-                const tagsRecord1 = yield TestDataGenerator.generateRecordsWrite({
+                const tagsRecord1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -1949,9 +1942,9 @@ export function testRecordsTags() {
                         stringTag,
                     }
                 });
-                const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
+                const tagsRecord1Reply = await dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
                 expect(tagsRecord1Reply.status.code).toBe(202);
-                const tagsQueryMatch = yield TestDataGenerator.generateRecordsQuery({
+                const tagsQueryMatch = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -1959,12 +1952,12 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
+                const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchReply.entries?.length).toBe(1);
                 expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // negative result same tag different value
-                let tagsQueryNegative = yield TestDataGenerator.generateRecordsQuery({
+                let tagsQueryNegative = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -1972,11 +1965,11 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                let tagsQueryNegativeReply = yield dwn.processMessage(alice.did, tagsQueryNegative.message);
+                let tagsQueryNegativeReply = await dwn.processMessage(alice.did, tagsQueryNegative.message);
                 expect(tagsQueryNegativeReply.status.code).toBe(200);
-                expect((_b = tagsQueryNegativeReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
+                expect(tagsQueryNegativeReply.entries?.length).toBe(0);
                 // negative result different tag same value
-                tagsQueryNegative = yield TestDataGenerator.generateRecordsQuery({
+                tagsQueryNegative = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -1984,16 +1977,16 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                tagsQueryNegativeReply = yield dwn.processMessage(alice.did, tagsQueryNegative.message);
+                tagsQueryNegativeReply = await dwn.processMessage(alice.did, tagsQueryNegative.message);
                 expect(tagsQueryNegativeReply.status.code).toBe(200);
-                expect((_c = tagsQueryNegativeReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(0);
-            }));
-            it('should be able to filter by number match', () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                expect(tagsQueryNegativeReply.entries?.length).toBe(0);
+            });
+            it('should be able to filter by number match', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const numberTag = 54566975;
                 // write a record with a numerical value tag
-                const tagsRecord1 = yield TestDataGenerator.generateRecordsWrite({
+                const tagsRecord1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -2001,10 +1994,10 @@ export function testRecordsTags() {
                         numberTag,
                     }
                 });
-                const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
+                const tagsRecord1Reply = await dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
                 expect(tagsRecord1Reply.status.code).toBe(202);
                 // do an exact match for the tag value
-                const tagsQueryMatch = yield TestDataGenerator.generateRecordsQuery({
+                const tagsQueryMatch = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -2012,12 +2005,12 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
+                const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchReply.entries?.length).toBe(1);
                 expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // negative result same tag different value
-                let tagsQueryNegative = yield TestDataGenerator.generateRecordsQuery({
+                let tagsQueryNegative = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -2025,11 +2018,11 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                let tagsQueryNegativeReply = yield dwn.processMessage(alice.did, tagsQueryNegative.message);
+                let tagsQueryNegativeReply = await dwn.processMessage(alice.did, tagsQueryNegative.message);
                 expect(tagsQueryNegativeReply.status.code).toBe(200);
-                expect((_b = tagsQueryNegativeReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
+                expect(tagsQueryNegativeReply.entries?.length).toBe(0);
                 // negative result different tag same value
-                tagsQueryNegative = yield TestDataGenerator.generateRecordsQuery({
+                tagsQueryNegative = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -2037,20 +2030,20 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                tagsQueryNegativeReply = yield dwn.processMessage(alice.did, tagsQueryNegative.message);
+                tagsQueryNegativeReply = await dwn.processMessage(alice.did, tagsQueryNegative.message);
                 expect(tagsQueryNegativeReply.status.code).toBe(200);
-                expect((_c = tagsQueryNegativeReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(0);
-            }));
-            it('should be able to filter by boolean match', () => __awaiter(this, void 0, void 0, function* () {
+                expect(tagsQueryNegativeReply.entries?.length).toBe(0);
+            });
+            it('should be able to filter by boolean match', async () => {
                 // 1. Write a record with a boolean tag `booleanTag` set to true
                 // 2. Write a record with a boolean tag `booleanTag` set to false.
                 // 3. Query for records with a `booleanTag` set to true, and validate the result.
                 // 4. Query for records with a `booleanTag` set to false, and validate the result.
                 // 5. Query for records with a non existent boolean tag, should not return a result.
-                var _a, _b, _c;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // write a record with a true boolean value tag
-                const tagsRecordTrue = yield TestDataGenerator.generateRecordsWrite({
+                const tagsRecordTrue = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -2058,10 +2051,10 @@ export function testRecordsTags() {
                         booleanTag: true,
                     }
                 });
-                const tagsRecordTrueReply = yield dwn.processMessage(alice.did, tagsRecordTrue.message, { dataStream: tagsRecordTrue.dataStream });
+                const tagsRecordTrueReply = await dwn.processMessage(alice.did, tagsRecordTrue.message, { dataStream: tagsRecordTrue.dataStream });
                 expect(tagsRecordTrueReply.status.code).toBe(202);
                 // write a record with a false boolean value tag
-                const tagsRecordFalse = yield TestDataGenerator.generateRecordsWrite({
+                const tagsRecordFalse = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -2069,10 +2062,10 @@ export function testRecordsTags() {
                         booleanTag: false,
                     }
                 });
-                const tagsRecordFalseReply = yield dwn.processMessage(alice.did, tagsRecordFalse.message, { dataStream: tagsRecordFalse.dataStream });
+                const tagsRecordFalseReply = await dwn.processMessage(alice.did, tagsRecordFalse.message, { dataStream: tagsRecordFalse.dataStream });
                 expect(tagsRecordFalseReply.status.code).toBe(202);
                 // query for records with a `booleanTag` set to true, should return the record with the true tag
-                const tagsQueryMatchTrue = yield TestDataGenerator.generateRecordsQuery({
+                const tagsQueryMatchTrue = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -2080,12 +2073,12 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const tagsQueryMatchTrueReply = yield dwn.processMessage(alice.did, tagsQueryMatchTrue.message);
+                const tagsQueryMatchTrueReply = await dwn.processMessage(alice.did, tagsQueryMatchTrue.message);
                 expect(tagsQueryMatchTrueReply.status.code).toBe(200);
-                expect((_a = tagsQueryMatchTrueReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchTrueReply.entries?.length).toBe(1);
                 expect(tagsQueryMatchTrueReply.entries[0].recordId).toBe(tagsRecordTrue.message.recordId);
                 // query for records with a `booleanTag` set to false, should return the record with the false tag
-                const tagsQueryMatchFalse = yield TestDataGenerator.generateRecordsQuery({
+                const tagsQueryMatchFalse = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -2093,12 +2086,12 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const tagsQueryMatchFalseReply = yield dwn.processMessage(alice.did, tagsQueryMatchFalse.message);
+                const tagsQueryMatchFalseReply = await dwn.processMessage(alice.did, tagsQueryMatchFalse.message);
                 expect(tagsQueryMatchFalseReply.status.code).toBe(200);
-                expect((_b = tagsQueryMatchFalseReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(tagsQueryMatchFalseReply.entries?.length).toBe(1);
                 expect(tagsQueryMatchFalseReply.entries[0].recordId).toBe(tagsRecordFalse.message.recordId);
                 // negative result for a non existent boolean tag.
-                const tagsQueryNegative = yield TestDataGenerator.generateRecordsQuery({
+                const tagsQueryNegative = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -2106,15 +2099,15 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const tagsQueryNegativeReply = yield dwn.processMessage(alice.did, tagsQueryNegative.message);
+                const tagsQueryNegativeReply = await dwn.processMessage(alice.did, tagsQueryNegative.message);
                 expect(tagsQueryNegativeReply.status.code).toBe(200);
-                expect((_c = tagsQueryNegativeReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(0);
-            }));
-            it('should be able to range filter by string value', () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c, _d;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                expect(tagsQueryNegativeReply.entries?.length).toBe(0);
+            });
+            it('should be able to range filter by string value', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // create four records with different first names
-                const aliceRecord = yield TestDataGenerator.generateRecordsWrite({
+                const aliceRecord = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -2122,7 +2115,7 @@ export function testRecordsTags() {
                         firstName: 'alice'
                     }
                 });
-                const bobRecord = yield TestDataGenerator.generateRecordsWrite({
+                const bobRecord = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -2130,7 +2123,7 @@ export function testRecordsTags() {
                         firstName: 'bob',
                     }
                 });
-                const carolRecord = yield TestDataGenerator.generateRecordsWrite({
+                const carolRecord = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -2138,7 +2131,7 @@ export function testRecordsTags() {
                         firstName: 'carol',
                     }
                 });
-                const danielRecord = yield TestDataGenerator.generateRecordsWrite({
+                const danielRecord = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -2146,26 +2139,26 @@ export function testRecordsTags() {
                         firstName: 'daniel',
                     }
                 });
-                const aliceReply = yield dwn.processMessage(alice.did, aliceRecord.message, { dataStream: aliceRecord.dataStream });
+                const aliceReply = await dwn.processMessage(alice.did, aliceRecord.message, { dataStream: aliceRecord.dataStream });
                 expect(aliceReply.status.code).toBe(202);
-                const bobReply = yield dwn.processMessage(alice.did, bobRecord.message, { dataStream: bobRecord.dataStream });
+                const bobReply = await dwn.processMessage(alice.did, bobRecord.message, { dataStream: bobRecord.dataStream });
                 expect(bobReply.status.code).toBe(202);
-                const carolReply = yield dwn.processMessage(alice.did, carolRecord.message, { dataStream: carolRecord.dataStream });
+                const carolReply = await dwn.processMessage(alice.did, carolRecord.message, { dataStream: carolRecord.dataStream });
                 expect(carolReply.status.code).toBe(202);
-                const danielReply = yield dwn.processMessage(alice.did, danielRecord.message, { dataStream: danielRecord.dataStream });
+                const danielReply = await dwn.processMessage(alice.did, danielRecord.message, { dataStream: danielRecord.dataStream });
                 expect(danielReply.status.code).toBe(202);
                 // sanity query for all
-                const queryForAll = yield TestDataGenerator.generateRecordsQuery({
+                const queryForAll = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         schema: 'post'
                     }
                 });
-                const queryForAllReply = yield dwn.processMessage(alice.did, queryForAll.message);
+                const queryForAllReply = await dwn.processMessage(alice.did, queryForAll.message);
                 expect(queryForAllReply.status.code).toBe(200);
-                expect((_a = queryForAllReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(4); // all 4 records
+                expect(queryForAllReply.entries?.length).toBe(4); // all 4 records
                 // query for first names that begin with 'a' and 'b'
-                const queryForAtoB = yield TestDataGenerator.generateRecordsQuery({
+                const queryForAtoB = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         schema: 'post',
@@ -2174,13 +2167,13 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const queryForAtoBReply = yield dwn.processMessage(alice.did, queryForAtoB.message);
+                const queryForAtoBReply = await dwn.processMessage(alice.did, queryForAtoB.message);
                 expect(queryForAtoBReply.status.code).toBe(200);
-                expect((_b = queryForAtoBReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(2);
+                expect(queryForAtoBReply.entries?.length).toBe(2);
                 const atobRecordIds = queryForAtoBReply.entries.map(entry => entry.recordId);
                 expect(atobRecordIds).toEqual(expect.arrayContaining([aliceRecord.message.recordId, bobRecord.message.recordId]));
                 // query for first names greater than 'bob'(exclusive of), and less than but inclusive of 'daniel'
-                const queryForBtoD = yield TestDataGenerator.generateRecordsQuery({
+                const queryForBtoD = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         schema: 'post',
@@ -2189,13 +2182,13 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const queryForBtoDReply = yield dwn.processMessage(alice.did, queryForBtoD.message);
+                const queryForBtoDReply = await dwn.processMessage(alice.did, queryForBtoD.message);
                 expect(queryForBtoDReply.status.code).toBe(200);
-                expect((_c = queryForBtoDReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(2);
+                expect(queryForBtoDReply.entries?.length).toBe(2);
                 const btodRecordIds = queryForBtoDReply.entries.map(entry => entry.recordId);
                 expect(btodRecordIds).toEqual(expect.arrayContaining([carolRecord.message.recordId, danielRecord.message.recordId]));
                 // query for first names that begin with 'carol' onward (inclusive).
-                const queryForCarolOnward = yield TestDataGenerator.generateRecordsQuery({
+                const queryForCarolOnward = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         schema: 'post',
@@ -2204,17 +2197,17 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const queryForCarolOnwardReply = yield dwn.processMessage(alice.did, queryForCarolOnward.message);
+                const queryForCarolOnwardReply = await dwn.processMessage(alice.did, queryForCarolOnward.message);
                 expect(queryForCarolOnwardReply.status.code).toBe(200);
-                expect((_d = queryForCarolOnwardReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(2);
+                expect(queryForCarolOnwardReply.entries?.length).toBe(2);
                 const onwardResults = queryForCarolOnwardReply.entries.map(entry => entry.recordId);
                 expect(onwardResults).toEqual(expect.arrayContaining([carolRecord.message.recordId, danielRecord.message.recordId]));
-            }));
-            it('should be able to filter by string prefix', () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should be able to filter by string prefix', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // create two records that match the prefix 'string-'
-                const tagsRecord1 = yield TestDataGenerator.generateRecordsWrite({
+                const tagsRecord1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -2222,7 +2215,7 @@ export function testRecordsTags() {
                         stringTag: 'string-foo',
                     }
                 });
-                const tagsRecord2 = yield TestDataGenerator.generateRecordsWrite({
+                const tagsRecord2 = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -2230,12 +2223,12 @@ export function testRecordsTags() {
                         stringTag: 'string-bar',
                     }
                 });
-                const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
+                const tagsRecord1Reply = await dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
                 expect(tagsRecord1Reply.status.code).toBe(202);
-                const tagsRecord2Reply = yield dwn.processMessage(alice.did, tagsRecord2.message, { dataStream: tagsRecord2.dataStream });
+                const tagsRecord2Reply = await dwn.processMessage(alice.did, tagsRecord2.message, { dataStream: tagsRecord2.dataStream });
                 expect(tagsRecord2Reply.status.code).toBe(202);
                 // control record that has a different prefix
-                const tagsRecord3 = yield TestDataGenerator.generateRecordsWrite({
+                const tagsRecord3 = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -2243,10 +2236,10 @@ export function testRecordsTags() {
                         stringTag: 'zaz-string', // comes after `string-` lexicographically
                     }
                 });
-                const tagsRecord3Reply = yield dwn.processMessage(alice.did, tagsRecord3.message, { dataStream: tagsRecord3.dataStream });
+                const tagsRecord3Reply = await dwn.processMessage(alice.did, tagsRecord3.message, { dataStream: tagsRecord3.dataStream });
                 expect(tagsRecord3Reply.status.code).toBe(202);
                 // a prefix search will return only the records matching the prefix
-                const tagsQueryMatch = yield TestDataGenerator.generateRecordsQuery({
+                const tagsQueryMatch = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -2254,14 +2247,14 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
+                const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
+                expect(tagsQueryMatchReply.entries?.length).toBe(2);
                 const matchedRecords = tagsQueryMatchReply.entries.map(entry => entry.recordId);
                 expect(matchedRecords).toEqual(expect.arrayContaining([tagsRecord1.message.recordId, tagsRecord2.message.recordId]));
                 // sanity/control: a regular range query will return all
                 // since `zaz-string` comes lexicographically after `string-` it will appear in the result set
-                const tagsQueryRange = yield TestDataGenerator.generateRecordsQuery({
+                const tagsQueryRange = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -2269,15 +2262,15 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const tagsQueryRangeReply = yield dwn.processMessage(alice.did, tagsQueryRange.message);
+                const tagsQueryRangeReply = await dwn.processMessage(alice.did, tagsQueryRange.message);
                 expect(tagsQueryRangeReply.status.code).toBe(200);
-                expect((_b = tagsQueryRangeReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(3); // returned all 3 records
-            }));
-            it('should be able to range filter by number value', () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c, _d, _e;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                expect(tagsQueryRangeReply.entries?.length).toBe(3); // returned all 3 records
+            });
+            it('should be able to range filter by number value', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // create four records with different test scores
-                const aliceRecord = yield TestDataGenerator.generateRecordsWrite({
+                const aliceRecord = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'test',
@@ -2286,7 +2279,7 @@ export function testRecordsTags() {
                         score: 75,
                     }
                 });
-                const bobRecord = yield TestDataGenerator.generateRecordsWrite({
+                const bobRecord = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'test',
@@ -2295,7 +2288,7 @@ export function testRecordsTags() {
                         score: 80,
                     }
                 });
-                const carolRecord = yield TestDataGenerator.generateRecordsWrite({
+                const carolRecord = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'test',
@@ -2304,7 +2297,7 @@ export function testRecordsTags() {
                         score: 65,
                     }
                 });
-                const danielRecord = yield TestDataGenerator.generateRecordsWrite({
+                const danielRecord = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'test',
@@ -2313,27 +2306,27 @@ export function testRecordsTags() {
                         score: 100,
                     }
                 });
-                const aliceReply = yield dwn.processMessage(alice.did, aliceRecord.message, { dataStream: aliceRecord.dataStream });
+                const aliceReply = await dwn.processMessage(alice.did, aliceRecord.message, { dataStream: aliceRecord.dataStream });
                 expect(aliceReply.status.code).toBe(202);
-                const bobReply = yield dwn.processMessage(alice.did, bobRecord.message, { dataStream: bobRecord.dataStream });
+                const bobReply = await dwn.processMessage(alice.did, bobRecord.message, { dataStream: bobRecord.dataStream });
                 expect(bobReply.status.code).toBe(202);
-                const carolReply = yield dwn.processMessage(alice.did, carolRecord.message, { dataStream: carolRecord.dataStream });
+                const carolReply = await dwn.processMessage(alice.did, carolRecord.message, { dataStream: carolRecord.dataStream });
                 expect(carolReply.status.code).toBe(202);
-                const danielReply = yield dwn.processMessage(alice.did, danielRecord.message, { dataStream: danielRecord.dataStream });
+                const danielReply = await dwn.processMessage(alice.did, danielRecord.message, { dataStream: danielRecord.dataStream });
                 expect(danielReply.status.code).toBe(202);
                 // sanity query for all
-                const queryForAll = yield TestDataGenerator.generateRecordsQuery({
+                const queryForAll = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         schema: 'test'
                     }
                 });
-                const queryForAllReply = yield dwn.processMessage(alice.did, queryForAll.message);
+                const queryForAllReply = await dwn.processMessage(alice.did, queryForAll.message);
                 expect(queryForAllReply.status.code).toBe(200);
-                expect((_a = queryForAllReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(4); // all 4 records
+                expect(queryForAllReply.entries?.length).toBe(4); // all 4 records
                 // query for all records that received higher than(not including) an 80
                 // only one record should match
-                const queryForHighGrade = yield TestDataGenerator.generateRecordsQuery({
+                const queryForHighGrade = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         schema: 'test',
@@ -2342,13 +2335,13 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const queryForHighReply = yield dwn.processMessage(alice.did, queryForHighGrade.message);
+                const queryForHighReply = await dwn.processMessage(alice.did, queryForHighGrade.message);
                 expect(queryForHighReply.status.code).toBe(200);
-                expect((_b = queryForHighReply.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(1);
+                expect(queryForHighReply.entries?.length).toBe(1);
                 expect(queryForHighReply.entries[0].recordId).toBe(danielRecord.message.recordId);
                 // query for all records that received higher (and including) a 75
                 // three records should match
-                const queryForPassingGrade = yield TestDataGenerator.generateRecordsQuery({
+                const queryForPassingGrade = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         schema: 'test',
@@ -2357,15 +2350,15 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const queryForPassingGradeReply = yield dwn.processMessage(alice.did, queryForPassingGrade.message);
+                const queryForPassingGradeReply = await dwn.processMessage(alice.did, queryForPassingGrade.message);
                 expect(queryForPassingGradeReply.status.code).toBe(200);
-                expect((_c = queryForPassingGradeReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(3);
+                expect(queryForPassingGradeReply.entries?.length).toBe(3);
                 const passingRecords = queryForPassingGradeReply.entries.map(entry => entry.recordId);
                 expect(passingRecords).toEqual(expect.arrayContaining([
                     danielRecord.message.recordId, bobRecord.message.recordId, aliceRecord.message.recordId
                 ]));
                 // query for poorly performing grades (65 and below, inclusive)
-                const queryForPoorGrades = yield TestDataGenerator.generateRecordsQuery({
+                const queryForPoorGrades = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         schema: 'test',
@@ -2374,12 +2367,12 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const queryForPoorGradesReply = yield dwn.processMessage(alice.did, queryForPoorGrades.message);
+                const queryForPoorGradesReply = await dwn.processMessage(alice.did, queryForPoorGrades.message);
                 expect(queryForPoorGradesReply.status.code).toBe(200);
-                expect((_d = queryForPoorGradesReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(1);
+                expect(queryForPoorGradesReply.entries?.length).toBe(1);
                 expect(queryForPoorGradesReply.entries[0].recordId).toBe(carolRecord.message.recordId);
                 // query for passing grades that were not perfect scores
-                const queryForRange = yield TestDataGenerator.generateRecordsQuery({
+                const queryForRange = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         schema: 'test',
@@ -2388,16 +2381,16 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const queryForRangeReply = yield dwn.processMessage(alice.did, queryForRange.message);
+                const queryForRangeReply = await dwn.processMessage(alice.did, queryForRange.message);
                 expect(queryForRangeReply.status.code).toBe(200);
-                expect((_e = queryForRangeReply.entries) === null || _e === void 0 ? void 0 : _e.length).toBe(2);
+                expect(queryForRangeReply.entries?.length).toBe(2);
                 const rangeRecords = queryForRangeReply.entries.map(entry => entry.recordId);
                 expect(rangeRecords).toEqual(expect.arrayContaining([bobRecord.message.recordId, aliceRecord.message.recordId]));
-            }));
-            it('should return results based on the latest tag values', () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const tagsRecord1 = yield TestDataGenerator.generateRecordsWrite({
+            });
+            it('should return results based on the latest tag values', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const tagsRecord1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -2405,9 +2398,9 @@ export function testRecordsTags() {
                         stringTag: 'string-value',
                     }
                 });
-                const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
+                const tagsRecord1Reply = await dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
                 expect(tagsRecord1Reply.status.code).toBe(202);
-                const tagsQueryMatch = yield TestDataGenerator.generateRecordsQuery({
+                const tagsQueryMatch = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -2415,27 +2408,27 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
+                const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchReply.entries?.length).toBe(1);
                 expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // update the record with new tags
-                const updatedRecord = yield TestDataGenerator.generateFromRecordsWrite({
+                const updatedRecord = await TestDataGenerator.generateFromRecordsWrite({
                     author: alice,
                     existingWrite: tagsRecord1.recordsWrite,
                     tags: { otherTag: 'other-value' } // new tags
                 });
-                const updatedRecordReply = yield dwn.processMessage(alice.did, updatedRecord.message, { dataStream: updatedRecord.dataStream });
+                const updatedRecordReply = await dwn.processMessage(alice.did, updatedRecord.message, { dataStream: updatedRecord.dataStream });
                 expect(updatedRecordReply.status.code).toBe(202);
                 // issuing the same query should return no results
-                const tagsQueryMatchReply2 = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
+                const tagsQueryMatchReply2 = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply2.status.code).toBe(200);
-                expect((_b = tagsQueryMatchReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
-            }));
-            it('should not return results if the record was updated with empty tags', () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const tagsRecord1 = yield TestDataGenerator.generateRecordsWrite({
+                expect(tagsQueryMatchReply2.entries?.length).toBe(0);
+            });
+            it('should not return results if the record was updated with empty tags', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const tagsRecord1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -2443,9 +2436,9 @@ export function testRecordsTags() {
                         stringTag: 'string-value',
                     }
                 });
-                const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
+                const tagsRecord1Reply = await dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
                 expect(tagsRecord1Reply.status.code).toBe(202);
-                const tagsQueryMatch = yield TestDataGenerator.generateRecordsQuery({
+                const tagsQueryMatch = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -2453,29 +2446,29 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
+                const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchReply.entries?.length).toBe(1);
                 expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // update the record without any tags
-                const updatedRecord = yield TestDataGenerator.generateFromRecordsWrite({
+                const updatedRecord = await TestDataGenerator.generateFromRecordsWrite({
                     author: alice,
                     existingWrite: tagsRecord1.recordsWrite,
                 });
-                const updatedRecordReply = yield dwn.processMessage(alice.did, updatedRecord.message, { dataStream: updatedRecord.dataStream });
+                const updatedRecordReply = await dwn.processMessage(alice.did, updatedRecord.message, { dataStream: updatedRecord.dataStream });
                 expect(updatedRecordReply.status.code).toBe(202);
                 // issuing the same query should return no results
-                const tagsQueryMatchReply2 = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
+                const tagsQueryMatchReply2 = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply2.status.code).toBe(200);
-                expect((_b = tagsQueryMatchReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
-            }));
+                expect(tagsQueryMatchReply2.entries?.length).toBe(0);
+            });
         });
         describe('RecordsDelete with tags', () => {
-            it('should delete record with tags', () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            it('should delete record with tags', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // create a record with a tag
-                const tagsRecord1 = yield TestDataGenerator.generateRecordsWrite({
+                const tagsRecord1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     published: true,
                     schema: 'post',
@@ -2483,10 +2476,10 @@ export function testRecordsTags() {
                         stringTag: 'string-value',
                     }
                 });
-                const tagsRecord1Reply = yield dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
+                const tagsRecord1Reply = await dwn.processMessage(alice.did, tagsRecord1.message, { dataStream: tagsRecord1.dataStream });
                 expect(tagsRecord1Reply.status.code).toBe(202);
                 //sanity: query for the record
-                const tagsQueryMatch = yield TestDataGenerator.generateRecordsQuery({
+                const tagsQueryMatch = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
                         tags: {
@@ -2494,22 +2487,22 @@ export function testRecordsTags() {
                         }
                     }
                 });
-                const tagsQueryMatchReply = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
+                const tagsQueryMatchReply = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply.status.code).toBe(200);
-                expect((_a = tagsQueryMatchReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                expect(tagsQueryMatchReply.entries?.length).toBe(1);
                 expect(tagsQueryMatchReply.entries[0].recordId).toBe(tagsRecord1.message.recordId);
                 // delete the record
-                const recordDelete = yield TestDataGenerator.generateRecordsDelete({
+                const recordDelete = await TestDataGenerator.generateRecordsDelete({
                     author: alice,
                     recordId: tagsRecord1.message.recordId,
                 });
-                const recordDeleteReply = yield dwn.processMessage(alice.did, recordDelete.message);
+                const recordDeleteReply = await dwn.processMessage(alice.did, recordDelete.message);
                 expect(recordDeleteReply.status.code).toBe(202);
                 // issue the the same query should return no results
-                const tagsQueryMatchReply2 = yield dwn.processMessage(alice.did, tagsQueryMatch.message);
+                const tagsQueryMatchReply2 = await dwn.processMessage(alice.did, tagsQueryMatch.message);
                 expect(tagsQueryMatchReply2.status.code).toBe(200);
-                expect((_b = tagsQueryMatchReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(0);
-            }));
+                expect(tagsQueryMatchReply2.entries?.length).toBe(0);
+            });
         });
     });
 }