@enbox/dwn-sdk-js 0.0.6 → 0.0.8

package/dist/esm/tests/scenarios/aggregator.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 { DataStream } from '../../src/index.js';
 import sinon from 'sinon';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
@@ -16,7 +7,7 @@ import { ProtocolsConfigure } from '../../src/interfaces/protocols-configure.js'
 import { RecordsQuery } from '../../src/interfaces/records-query.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 { DidKey, UniversalResolver } from '@enbox/dids';
 // This is a test suite that demonstrates how to use the DWN to create aggregators
@@ -30,7 +21,7 @@ describe('Aggregator Model', () => {
     let dataStore;
     let resumableTaskStore;
     let stateIndex;
-    let eventStream;
+    let eventLog;
     let dwn;
     const protocol = 'https://example.org/notes';
     // A simple protocol for the user that only allows them to write or read their own notes
@@ -76,28 +67,28 @@ describe('Aggregator Model', () => {
     };
     // important to follow the `beforeAll` and `afterAll` pattern to initialize and clean the stores in tests
     // so that different test suites can reuse the same backend store for testing
-    beforeAll(() => __awaiter(void 0, 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(void 0, 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(void 0, void 0, void 0, function* () {
-        yield dwn.close();
-    }));
-    it('should support querying from multiple authors', () => __awaiter(void 0, void 0, void 0, function* () {
+        await messageStore.clear();
+        await dataStore.clear();
+        await resumableTaskStore.clear();
+        await stateIndex.clear();
+    });
+    afterAll(async () => {
+        await dwn.close();
+    });
+    it('should support querying from multiple authors', async () => {
         // scenario: Alice, Bob, Carol are members of an aggregator.
         // Alice writes a note to Carol, Bob writes a note to Alice, Carol writes a note to Bob.
         // Daniel is not a member of the aggregator and tries to unsuccessfully write a note to Alice.
@@ -107,47 +98,46 @@ describe('Aggregator Model', () => {
         // Daniel does not see the private notes in his query.
         // Carol can see all notes from Alice and Bob in her query, including the private notes intended for her.
         // Alice can see all notes from Bob and Carol in her query, including the private notes intended for her.
-        var _a, _b, _c, _d;
         // create aggregator DID and install aggregator note protocol
-        const aggregator = yield TestDataGenerator.generateDidKeyPersona();
-        const aggregatorProtocolConfigure = yield ProtocolsConfigure.create({
+        const aggregator = await TestDataGenerator.generateDidKeyPersona();
+        const aggregatorProtocolConfigure = await ProtocolsConfigure.create({
             signer: Jws.createSigner(aggregator),
             definition: aggregatorProtocolDefinition,
         });
-        const aggregatorProtocolReply = yield dwn.processMessage(aggregator.did, aggregatorProtocolConfigure.message);
+        const aggregatorProtocolReply = await dwn.processMessage(aggregator.did, aggregatorProtocolConfigure.message);
         expect(aggregatorProtocolReply.status.code).toBe(202, 'aggregator configure');
         // create 4 users and install user note protocol
-        const alice = yield TestDataGenerator.generateDidKeyPersona();
-        const aliceProtocolConfigure = yield ProtocolsConfigure.create({
+        const alice = await TestDataGenerator.generateDidKeyPersona();
+        const aliceProtocolConfigure = await ProtocolsConfigure.create({
             signer: Jws.createSigner(alice),
             definition: userProtocolDefinition,
         });
-        const aliceProtocolReply = yield dwn.processMessage(alice.did, aliceProtocolConfigure.message);
+        const aliceProtocolReply = await dwn.processMessage(alice.did, aliceProtocolConfigure.message);
         expect(aliceProtocolReply.status.code).toBe(202, 'alice configure');
-        const bob = yield TestDataGenerator.generateDidKeyPersona();
-        const bobProtocolConfigure = yield ProtocolsConfigure.create({
+        const bob = await TestDataGenerator.generateDidKeyPersona();
+        const bobProtocolConfigure = await ProtocolsConfigure.create({
             signer: Jws.createSigner(bob),
             definition: userProtocolDefinition,
         });
-        const bobProtocolReply = yield dwn.processMessage(bob.did, bobProtocolConfigure.message);
+        const bobProtocolReply = await dwn.processMessage(bob.did, bobProtocolConfigure.message);
         expect(bobProtocolReply.status.code).toBe(202, 'bob configure');
-        const carol = yield TestDataGenerator.generateDidKeyPersona();
-        const carolProtocolConfigure = yield ProtocolsConfigure.create({
+        const carol = await TestDataGenerator.generateDidKeyPersona();
+        const carolProtocolConfigure = await ProtocolsConfigure.create({
             signer: Jws.createSigner(carol),
             definition: userProtocolDefinition,
         });
-        const carolProtocolReply = yield dwn.processMessage(carol.did, carolProtocolConfigure.message);
+        const carolProtocolReply = await dwn.processMessage(carol.did, carolProtocolConfigure.message);
         expect(carolProtocolReply.status.code).toBe(202, 'carol configure');
-        const daniel = yield TestDataGenerator.generateDidKeyPersona();
-        const danielProtocolConfigure = yield ProtocolsConfigure.create({
+        const daniel = await TestDataGenerator.generateDidKeyPersona();
+        const danielProtocolConfigure = await ProtocolsConfigure.create({
             signer: Jws.createSigner(daniel),
             definition: userProtocolDefinition,
         });
-        const danielProtocolReply = yield dwn.processMessage(daniel.did, danielProtocolConfigure.message);
+        const danielProtocolReply = await dwn.processMessage(daniel.did, danielProtocolConfigure.message);
         expect(danielProtocolReply.status.code).toBe(202, 'daniel configure');
         // The aggregator creates member records for alice, bob and carol
         const aliceMemberData = TestDataGenerator.randomBytes(256);
-        const aliceMember = yield RecordsWrite.create({
+        const aliceMember = await RecordsWrite.create({
             signer: Jws.createSigner(aggregator),
             recipient: alice.did,
             protocol: userProtocolDefinition.protocol,
@@ -156,10 +146,10 @@ describe('Aggregator Model', () => {
             dataFormat: 'application/json',
             data: aliceMemberData,
         });
-        const aliceMemberReply = yield dwn.processMessage(aggregator.did, aliceMember.message, { dataStream: DataStream.fromBytes(aliceMemberData) });
+        const aliceMemberReply = await dwn.processMessage(aggregator.did, aliceMember.message, { dataStream: DataStream.fromBytes(aliceMemberData) });
         expect(aliceMemberReply.status.code).toBe(202, 'alice member ' + aliceMemberReply.status.detail);
         const bobMemberData = TestDataGenerator.randomBytes(256);
-        const bobMember = yield RecordsWrite.create({
+        const bobMember = await RecordsWrite.create({
             signer: Jws.createSigner(aggregator),
             recipient: bob.did,
             protocol: userProtocolDefinition.protocol,
@@ -168,10 +158,10 @@ describe('Aggregator Model', () => {
             dataFormat: 'application/json',
             data: bobMemberData,
         });
-        const bobMemberReply = yield dwn.processMessage(aggregator.did, bobMember.message, { dataStream: DataStream.fromBytes(bobMemberData) });
+        const bobMemberReply = await dwn.processMessage(aggregator.did, bobMember.message, { dataStream: DataStream.fromBytes(bobMemberData) });
         expect(bobMemberReply.status.code).toBe(202, 'bob member');
         const carolMemberData = TestDataGenerator.randomBytes(256);
-        const carolMember = yield RecordsWrite.create({
+        const carolMember = await RecordsWrite.create({
             signer: Jws.createSigner(aggregator),
             recipient: carol.did,
             protocol: userProtocolDefinition.protocol,
@@ -180,11 +170,11 @@ describe('Aggregator Model', () => {
             dataFormat: 'application/json',
             data: carolMemberData,
         });
-        const carolMemberReply = yield dwn.processMessage(aggregator.did, carolMember.message, { dataStream: DataStream.fromBytes(carolMemberData) });
+        const carolMemberReply = await dwn.processMessage(aggregator.did, carolMember.message, { dataStream: DataStream.fromBytes(carolMemberData) });
         expect(carolMemberReply.status.code).toBe(202, 'carol member');
         // alice writes a public note to carol and posts it in the aggregator
         const aliceNoteData = TestDataGenerator.randomBytes(256);
-        const aliceNoteToCarol = yield RecordsWrite.create({
+        const aliceNoteToCarol = await RecordsWrite.create({
             signer: Jws.createSigner(alice),
             recipient: carol.did,
             published: true,
@@ -196,15 +186,15 @@ describe('Aggregator Model', () => {
             protocolRole: 'member'
         });
         // Alice writes it to her own DWN and the aggregator
-        const aliceLocalDWN = yield dwn.processMessage(alice.did, aliceNoteToCarol.message, { dataStream: DataStream.fromBytes(aliceNoteData) });
+        const aliceLocalDWN = await dwn.processMessage(alice.did, aliceNoteToCarol.message, { dataStream: DataStream.fromBytes(aliceNoteData) });
         expect(aliceLocalDWN.status.code).toBe(202, 'alice note');
-        const aliceAggregatorDWN = yield dwn.processMessage(aggregator.did, aliceNoteToCarol.message, {
+        const aliceAggregatorDWN = await dwn.processMessage(aggregator.did, aliceNoteToCarol.message, {
             dataStream: DataStream.fromBytes(aliceNoteData)
         });
         expect(aliceAggregatorDWN.status.code).toBe(202, 'alice note aggregator');
         // bob writes a public note to alice and posts it in the aggregator
         const bobNoteToAliceData = TestDataGenerator.randomBytes(256);
-        const bobNoteToAlice = yield RecordsWrite.create({
+        const bobNoteToAlice = await RecordsWrite.create({
             signer: Jws.createSigner(bob),
             recipient: alice.did,
             published: true,
@@ -216,15 +206,15 @@ describe('Aggregator Model', () => {
             protocolRole: 'member'
         });
         // Bob writes it to his own DWN and the aggregator
-        const bobLocalDWN = yield dwn.processMessage(bob.did, bobNoteToAlice.message, { dataStream: DataStream.fromBytes(bobNoteToAliceData) });
+        const bobLocalDWN = await dwn.processMessage(bob.did, bobNoteToAlice.message, { dataStream: DataStream.fromBytes(bobNoteToAliceData) });
         expect(bobLocalDWN.status.code).toBe(202, 'bob note');
-        const bobAggregatorDWN = yield dwn.processMessage(aggregator.did, bobNoteToAlice.message, {
+        const bobAggregatorDWN = await dwn.processMessage(aggregator.did, bobNoteToAlice.message, {
             dataStream: DataStream.fromBytes(bobNoteToAliceData)
         });
         expect(bobAggregatorDWN.status.code).toBe(202, 'bob note aggregator');
         // carol writes a public note to bob and posts it in the aggregator
         const carolNoteToBobData = TestDataGenerator.randomBytes(256);
-        const carolNoteToBob = yield RecordsWrite.create({
+        const carolNoteToBob = await RecordsWrite.create({
             signer: Jws.createSigner(carol),
             recipient: bob.did,
             published: true,
@@ -236,17 +226,17 @@ describe('Aggregator Model', () => {
             protocolRole: 'member'
         });
         // Carol writes it to her own DWN and the aggregator
-        const carolLocalDWN = yield dwn.processMessage(carol.did, carolNoteToBob.message, {
+        const carolLocalDWN = await dwn.processMessage(carol.did, carolNoteToBob.message, {
             dataStream: DataStream.fromBytes(carolNoteToBobData)
         });
         expect(carolLocalDWN.status.code).toBe(202, 'carol note');
-        const carolAggregatorDWN = yield dwn.processMessage(aggregator.did, carolNoteToBob.message, {
+        const carolAggregatorDWN = await dwn.processMessage(aggregator.did, carolNoteToBob.message, {
             dataStream: DataStream.fromBytes(carolNoteToBobData)
         });
         expect(carolAggregatorDWN.status.code).toBe(202, 'carol note aggregator');
         // daniel writes a public note to alice and posts it in the aggregator (which will reject it as he is not a member)
         const danielNoteToAlice = TestDataGenerator.randomBytes(256);
-        const danielNote = yield RecordsWrite.create({
+        const danielNote = await RecordsWrite.create({
             signer: Jws.createSigner(daniel),
             recipient: alice.did,
             published: true,
@@ -258,12 +248,12 @@ describe('Aggregator Model', () => {
             protocolRole: 'member'
         });
         // Daniel writes it to his own DWN and the aggregator
-        const danielLocalDWN = yield dwn.processMessage(daniel.did, danielNote.message, { dataStream: DataStream.fromBytes(danielNoteToAlice) });
+        const danielLocalDWN = await dwn.processMessage(daniel.did, danielNote.message, { dataStream: DataStream.fromBytes(danielNoteToAlice) });
         expect(danielLocalDWN.status.code).toBe(202, 'daniel note');
-        const danielAggregatorDWN = yield dwn.processMessage(aggregator.did, danielNote.message, { dataStream: DataStream.fromBytes(danielNoteToAlice) });
+        const danielAggregatorDWN = await dwn.processMessage(aggregator.did, danielNote.message, { dataStream: DataStream.fromBytes(danielNoteToAlice) });
         expect(danielAggregatorDWN.status.code).toBe(401, 'daniel note aggregator');
         // daniel can read public notes from multiple authors in a single query
-        const danielRead = yield RecordsQuery.create({
+        const danielRead = await RecordsQuery.create({
             signer: Jws.createSigner(daniel),
             filter: {
                 protocol: userProtocolDefinition.protocol,
@@ -271,14 +261,14 @@ describe('Aggregator Model', () => {
                 author: [alice.did, bob.did],
             }
         });
-        const danielReadReply = yield dwn.processMessage(aggregator.did, danielRead.message);
+        const danielReadReply = await dwn.processMessage(aggregator.did, danielRead.message);
         expect(danielReadReply.status.code).toBe(200, 'daniel read');
-        expect((_a = danielReadReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2, 'daniel read records');
+        expect(danielReadReply.entries?.length).toBe(2, 'daniel read records');
         expect(danielReadReply.entries[0].recordId).toBe(aliceNoteToCarol.message.recordId, 'daniel read alice note');
         expect(danielReadReply.entries[1].recordId).toBe(bobNoteToAlice.message.recordId, 'daniel read bob note');
         // create  private notes to carol from alice and bob
         const alicePrivateNoteToCarol = TestDataGenerator.randomBytes(256);
-        const aliceNoteToCarolPrivate = yield RecordsWrite.create({
+        const aliceNoteToCarolPrivate = await RecordsWrite.create({
             signer: Jws.createSigner(alice),
             recipient: carol.did,
             published: false,
@@ -289,16 +279,16 @@ describe('Aggregator Model', () => {
             data: alicePrivateNoteToCarol,
             protocolRole: 'member'
         });
-        const aliceNoteToCarolLocal = yield dwn.processMessage(alice.did, aliceNoteToCarolPrivate.message, {
+        const aliceNoteToCarolLocal = await dwn.processMessage(alice.did, aliceNoteToCarolPrivate.message, {
             dataStream: DataStream.fromBytes(alicePrivateNoteToCarol)
         });
         expect(aliceNoteToCarolLocal.status.code).toBe(202, 'alice private note');
-        const aliceNoteToCarolAggregator = yield dwn.processMessage(aggregator.did, aliceNoteToCarolPrivate.message, {
+        const aliceNoteToCarolAggregator = await dwn.processMessage(aggregator.did, aliceNoteToCarolPrivate.message, {
             dataStream: DataStream.fromBytes(alicePrivateNoteToCarol)
         });
         expect(aliceNoteToCarolAggregator.status.code).toBe(202, 'alice private note aggregator');
         const bobPrivateNoteToCarol = TestDataGenerator.randomBytes(256);
-        const bobNoteToCarolPrivate = yield RecordsWrite.create({
+        const bobNoteToCarolPrivate = await RecordsWrite.create({
             signer: Jws.createSigner(bob),
             recipient: carol.did,
             published: false,
@@ -309,17 +299,17 @@ describe('Aggregator Model', () => {
             data: bobPrivateNoteToCarol,
             protocolRole: 'member'
         });
-        const bobNoteToCarolLocal = yield dwn.processMessage(bob.did, bobNoteToCarolPrivate.message, {
+        const bobNoteToCarolLocal = await dwn.processMessage(bob.did, bobNoteToCarolPrivate.message, {
             dataStream: DataStream.fromBytes(bobPrivateNoteToCarol)
         });
         expect(bobNoteToCarolLocal.status.code).toBe(202, 'bob private note');
-        const bobNoteToCarolAggregator = yield dwn.processMessage(aggregator.did, bobNoteToCarolPrivate.message, {
+        const bobNoteToCarolAggregator = await dwn.processMessage(aggregator.did, bobNoteToCarolPrivate.message, {
             dataStream: DataStream.fromBytes(bobPrivateNoteToCarol)
         });
         expect(bobNoteToCarolAggregator.status.code).toBe(202, 'bob private note aggregator');
         // create a private note from bob to alice
         const bobNoteToAlicePrivateData = TestDataGenerator.randomBytes(256);
-        const bobNoteToAlicePrivate = yield RecordsWrite.create({
+        const bobNoteToAlicePrivate = await RecordsWrite.create({
             signer: Jws.createSigner(bob),
             recipient: alice.did,
             published: false,
@@ -330,16 +320,16 @@ describe('Aggregator Model', () => {
             data: bobNoteToAlicePrivateData,
             protocolRole: 'member'
         });
-        const bobNoteToAliceLocal = yield dwn.processMessage(bob.did, bobNoteToAlicePrivate.message, {
+        const bobNoteToAliceLocal = await dwn.processMessage(bob.did, bobNoteToAlicePrivate.message, {
             dataStream: DataStream.fromBytes(bobNoteToAlicePrivateData)
         });
         expect(bobNoteToAliceLocal.status.code).toBe(202, 'alice private note to bob');
-        const bobNoteToAliceAggregator = yield dwn.processMessage(aggregator.did, bobNoteToAlicePrivate.message, {
+        const bobNoteToAliceAggregator = await dwn.processMessage(aggregator.did, bobNoteToAlicePrivate.message, {
             dataStream: DataStream.fromBytes(bobNoteToAlicePrivateData)
         });
         expect(bobNoteToAliceAggregator.status.code).toBe(202, 'alice private note to bob aggregator');
         // confirm daniel can still only read the public notes
-        const danielRead2 = yield RecordsQuery.create({
+        const danielRead2 = await RecordsQuery.create({
             signer: Jws.createSigner(daniel),
             filter: {
                 protocol: userProtocolDefinition.protocol,
@@ -347,14 +337,14 @@ describe('Aggregator Model', () => {
                 author: [alice.did, bob.did],
             }
         });
-        const danielReadReply2 = yield dwn.processMessage(aggregator.did, danielRead2.message);
+        const danielReadReply2 = await dwn.processMessage(aggregator.did, danielRead2.message);
         expect(danielReadReply2.status.code).toBe(200, 'daniel read 2');
-        expect((_b = danielReadReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(2, 'daniel read records 2');
+        expect(danielReadReply2.entries?.length).toBe(2, 'daniel read records 2');
         expect(danielReadReply2.entries[0].recordId).toBe(aliceNoteToCarol.message.recordId, 'daniel read alice note 2');
         expect(danielReadReply2.entries[1].recordId).toBe(bobNoteToAlice.message.recordId, 'daniel read bob note 2');
         // carol queries for notes from alice and bob and gets the public notes and private notes destined for her
         // carol does not see the private note from alice to bob
-        const carolRead = yield RecordsQuery.create({
+        const carolRead = await RecordsQuery.create({
             signer: Jws.createSigner(carol),
             filter: {
                 protocol: userProtocolDefinition.protocol,
@@ -362,15 +352,15 @@ describe('Aggregator Model', () => {
                 author: [alice.did, bob.did],
             }
         });
-        const carolReadReply = yield dwn.processMessage(aggregator.did, carolRead.message);
+        const carolReadReply = await dwn.processMessage(aggregator.did, carolRead.message);
         expect(carolReadReply.status.code).toBe(200, 'carol read');
-        expect((_c = carolReadReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(4, 'carol read records');
+        expect(carolReadReply.entries?.length).toBe(4, 'carol read records');
         expect(carolReadReply.entries[0].recordId).toBe(aliceNoteToCarol.message.recordId, 'carol read alice note');
         expect(carolReadReply.entries[1].recordId).toBe(bobNoteToAlice.message.recordId, 'carol read bob note');
         expect(carolReadReply.entries[2].recordId).toBe(aliceNoteToCarolPrivate.message.recordId, 'carol read alice private note');
         expect(carolReadReply.entries[3].recordId).toBe(bobNoteToCarolPrivate.message.recordId, 'carol read bob private note');
         // alice queries for notes from bob and carol and gets the public notes and private notes destined for her
-        const aliceRead = yield RecordsQuery.create({
+        const aliceRead = await RecordsQuery.create({
             signer: Jws.createSigner(alice),
             filter: {
                 protocol: userProtocolDefinition.protocol,
@@ -378,55 +368,54 @@ describe('Aggregator Model', () => {
                 author: [bob.did, carol.did],
             }
         });
-        const aliceReadReply = yield dwn.processMessage(aggregator.did, aliceRead.message);
+        const aliceReadReply = await dwn.processMessage(aggregator.did, aliceRead.message);
         expect(aliceReadReply.status.code).toBe(200, 'alice read');
-        expect((_d = aliceReadReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(3, 'alice read records');
+        expect(aliceReadReply.entries?.length).toBe(3, 'alice read records');
         expect(aliceReadReply.entries[0].recordId).toBe(bobNoteToAlice.message.recordId, 'alice note to carol public');
         expect(aliceReadReply.entries[1].recordId).toBe(carolNoteToBob.message.recordId, 'carol note to bob public');
         expect(aliceReadReply.entries[2].recordId).toBe(bobNoteToAlicePrivate.message.recordId, 'bob note to alice private');
-    }));
-    it('should support querying from multiple recipients', () => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
+    });
+    it('should support querying from multiple recipients', async () => {
         // create aggregator DID and install aggregator note protocol
-        const aggregator = yield TestDataGenerator.generateDidKeyPersona();
-        const aggregatorProtocolConfigure = yield ProtocolsConfigure.create({
+        const aggregator = await TestDataGenerator.generateDidKeyPersona();
+        const aggregatorProtocolConfigure = await ProtocolsConfigure.create({
             signer: Jws.createSigner(aggregator),
             definition: aggregatorProtocolDefinition,
         });
-        const aggregatorProtocolReply = yield dwn.processMessage(aggregator.did, aggregatorProtocolConfigure.message);
+        const aggregatorProtocolReply = await dwn.processMessage(aggregator.did, aggregatorProtocolConfigure.message);
         expect(aggregatorProtocolReply.status.code).toBe(202, 'aggregator configure');
         // create 4 users and install user note protocol
-        const alice = yield TestDataGenerator.generateDidKeyPersona();
-        const aliceProtocolConfigure = yield ProtocolsConfigure.create({
+        const alice = await TestDataGenerator.generateDidKeyPersona();
+        const aliceProtocolConfigure = await ProtocolsConfigure.create({
             signer: Jws.createSigner(alice),
             definition: userProtocolDefinition,
         });
-        const aliceProtocolReply = yield dwn.processMessage(alice.did, aliceProtocolConfigure.message);
+        const aliceProtocolReply = await dwn.processMessage(alice.did, aliceProtocolConfigure.message);
         expect(aliceProtocolReply.status.code).toBe(202, 'alice configure');
-        const bob = yield TestDataGenerator.generateDidKeyPersona();
-        const bobProtocolConfigure = yield ProtocolsConfigure.create({
+        const bob = await TestDataGenerator.generateDidKeyPersona();
+        const bobProtocolConfigure = await ProtocolsConfigure.create({
             signer: Jws.createSigner(bob),
             definition: userProtocolDefinition,
         });
-        const bobProtocolReply = yield dwn.processMessage(bob.did, bobProtocolConfigure.message);
+        const bobProtocolReply = await dwn.processMessage(bob.did, bobProtocolConfigure.message);
         expect(bobProtocolReply.status.code).toBe(202, 'bob configure');
-        const carol = yield TestDataGenerator.generateDidKeyPersona();
-        const carolProtocolConfigure = yield ProtocolsConfigure.create({
+        const carol = await TestDataGenerator.generateDidKeyPersona();
+        const carolProtocolConfigure = await ProtocolsConfigure.create({
             signer: Jws.createSigner(carol),
             definition: userProtocolDefinition,
         });
-        const carolProtocolReply = yield dwn.processMessage(carol.did, carolProtocolConfigure.message);
+        const carolProtocolReply = await dwn.processMessage(carol.did, carolProtocolConfigure.message);
         expect(carolProtocolReply.status.code).toBe(202, 'carol configure');
-        const daniel = yield TestDataGenerator.generateDidKeyPersona();
-        const danielProtocolConfigure = yield ProtocolsConfigure.create({
+        const daniel = await TestDataGenerator.generateDidKeyPersona();
+        const danielProtocolConfigure = await ProtocolsConfigure.create({
             signer: Jws.createSigner(daniel),
             definition: userProtocolDefinition,
         });
-        const danielProtocolReply = yield dwn.processMessage(daniel.did, danielProtocolConfigure.message);
+        const danielProtocolReply = await dwn.processMessage(daniel.did, danielProtocolConfigure.message);
         expect(danielProtocolReply.status.code).toBe(202, 'daniel configure');
         // The aggregator creates member records for alice, bob and carol
         const aliceMemberData = TestDataGenerator.randomBytes(256);
-        const aliceMember = yield RecordsWrite.create({
+        const aliceMember = await RecordsWrite.create({
             signer: Jws.createSigner(aggregator),
             recipient: alice.did,
             protocol: userProtocolDefinition.protocol,
@@ -435,10 +424,10 @@ describe('Aggregator Model', () => {
             dataFormat: 'application/json',
             data: aliceMemberData,
         });
-        const aliceMemberReply = yield dwn.processMessage(aggregator.did, aliceMember.message, { dataStream: DataStream.fromBytes(aliceMemberData) });
+        const aliceMemberReply = await dwn.processMessage(aggregator.did, aliceMember.message, { dataStream: DataStream.fromBytes(aliceMemberData) });
         expect(aliceMemberReply.status.code).toBe(202, 'alice member ' + aliceMemberReply.status.detail);
         const bobMemberData = TestDataGenerator.randomBytes(256);
-        const bobMember = yield RecordsWrite.create({
+        const bobMember = await RecordsWrite.create({
             signer: Jws.createSigner(aggregator),
             recipient: bob.did,
             protocol: userProtocolDefinition.protocol,
@@ -447,10 +436,10 @@ describe('Aggregator Model', () => {
             dataFormat: 'application/json',
             data: bobMemberData,
         });
-        const bobMemberReply = yield dwn.processMessage(aggregator.did, bobMember.message, { dataStream: DataStream.fromBytes(bobMemberData) });
+        const bobMemberReply = await dwn.processMessage(aggregator.did, bobMember.message, { dataStream: DataStream.fromBytes(bobMemberData) });
         expect(bobMemberReply.status.code).toBe(202, 'bob member');
         const carolMemberData = TestDataGenerator.randomBytes(256);
-        const carolMember = yield RecordsWrite.create({
+        const carolMember = await RecordsWrite.create({
             signer: Jws.createSigner(aggregator),
             recipient: carol.did,
             protocol: userProtocolDefinition.protocol,
@@ -459,11 +448,11 @@ describe('Aggregator Model', () => {
             dataFormat: 'application/json',
             data: carolMemberData,
         });
-        const carolMemberReply = yield dwn.processMessage(aggregator.did, carolMember.message, { dataStream: DataStream.fromBytes(carolMemberData) });
+        const carolMemberReply = await dwn.processMessage(aggregator.did, carolMember.message, { dataStream: DataStream.fromBytes(carolMemberData) });
         expect(carolMemberReply.status.code).toBe(202, 'carol member');
         // alice writes a public note to carol and posts it in the aggregator
         const aliceNoteData = TestDataGenerator.randomBytes(256);
-        const aliceNoteToCarol = yield RecordsWrite.create({
+        const aliceNoteToCarol = await RecordsWrite.create({
             signer: Jws.createSigner(alice),
             recipient: carol.did,
             published: true,
@@ -475,15 +464,15 @@ describe('Aggregator Model', () => {
             protocolRole: 'member'
         });
         // Alice writes it to her own DWN and the aggregator
-        const aliceLocalDWN = yield dwn.processMessage(alice.did, aliceNoteToCarol.message, { dataStream: DataStream.fromBytes(aliceNoteData) });
+        const aliceLocalDWN = await dwn.processMessage(alice.did, aliceNoteToCarol.message, { dataStream: DataStream.fromBytes(aliceNoteData) });
         expect(aliceLocalDWN.status.code).toBe(202, 'alice note');
-        const aliceAggregatorDWN = yield dwn.processMessage(aggregator.did, aliceNoteToCarol.message, {
+        const aliceAggregatorDWN = await dwn.processMessage(aggregator.did, aliceNoteToCarol.message, {
             dataStream: DataStream.fromBytes(aliceNoteData)
         });
         expect(aliceAggregatorDWN.status.code).toBe(202, 'alice note aggregator');
         // bob writes a public note to alice and posts it in the aggregator
         const bobNoteToAliceData = TestDataGenerator.randomBytes(256);
-        const bobNoteToAlice = yield RecordsWrite.create({
+        const bobNoteToAlice = await RecordsWrite.create({
             signer: Jws.createSigner(bob),
             recipient: alice.did,
             published: true,
@@ -495,15 +484,15 @@ describe('Aggregator Model', () => {
             protocolRole: 'member'
         });
         // Bob writes it to his own DWN and the aggregator
-        const bobLocalDWN = yield dwn.processMessage(bob.did, bobNoteToAlice.message, { dataStream: DataStream.fromBytes(bobNoteToAliceData) });
+        const bobLocalDWN = await dwn.processMessage(bob.did, bobNoteToAlice.message, { dataStream: DataStream.fromBytes(bobNoteToAliceData) });
         expect(bobLocalDWN.status.code).toBe(202, 'bob note');
-        const bobAggregatorDWN = yield dwn.processMessage(aggregator.did, bobNoteToAlice.message, {
+        const bobAggregatorDWN = await dwn.processMessage(aggregator.did, bobNoteToAlice.message, {
             dataStream: DataStream.fromBytes(bobNoteToAliceData)
         });
         expect(bobAggregatorDWN.status.code).toBe(202, 'bob note aggregator');
         // carol writes a public note to bob and posts it in the aggregator
         const carolNoteToBobData = TestDataGenerator.randomBytes(256);
-        const carolNoteToBob = yield RecordsWrite.create({
+        const carolNoteToBob = await RecordsWrite.create({
             signer: Jws.createSigner(carol),
             recipient: bob.did,
             published: true,
@@ -515,17 +504,17 @@ describe('Aggregator Model', () => {
             protocolRole: 'member'
         });
         // Carol writes it to her own DWN and the aggregator
-        const carolLocalDWN = yield dwn.processMessage(carol.did, carolNoteToBob.message, {
+        const carolLocalDWN = await dwn.processMessage(carol.did, carolNoteToBob.message, {
             dataStream: DataStream.fromBytes(carolNoteToBobData)
         });
         expect(carolLocalDWN.status.code).toBe(202, 'carol note');
-        const carolAggregatorDWN = yield dwn.processMessage(aggregator.did, carolNoteToBob.message, {
+        const carolAggregatorDWN = await dwn.processMessage(aggregator.did, carolNoteToBob.message, {
             dataStream: DataStream.fromBytes(carolNoteToBobData)
         });
         expect(carolAggregatorDWN.status.code).toBe(202, 'carol note aggregator');
         // daniel writes a public note to alice and posts it in the aggregator (which will reject it as he is not a member)
         const danielNoteToAlice = TestDataGenerator.randomBytes(256);
-        const danielNote = yield RecordsWrite.create({
+        const danielNote = await RecordsWrite.create({
             signer: Jws.createSigner(daniel),
             recipient: alice.did,
             published: true,
@@ -537,12 +526,12 @@ describe('Aggregator Model', () => {
             protocolRole: 'member'
         });
         // Daniel writes it to his own DWN and the aggregator
-        const danielLocalDWN = yield dwn.processMessage(daniel.did, danielNote.message, { dataStream: DataStream.fromBytes(danielNoteToAlice) });
+        const danielLocalDWN = await dwn.processMessage(daniel.did, danielNote.message, { dataStream: DataStream.fromBytes(danielNoteToAlice) });
         expect(danielLocalDWN.status.code).toBe(202, 'daniel note');
-        const danielAggregatorDWN = yield dwn.processMessage(aggregator.did, danielNote.message, { dataStream: DataStream.fromBytes(danielNoteToAlice) });
+        const danielAggregatorDWN = await dwn.processMessage(aggregator.did, danielNote.message, { dataStream: DataStream.fromBytes(danielNoteToAlice) });
         expect(danielAggregatorDWN.status.code).toBe(401, 'daniel note aggregator');
         // daniel can read public notes from multiple authors in a single query
-        const danielRead = yield RecordsQuery.create({
+        const danielRead = await RecordsQuery.create({
             signer: Jws.createSigner(daniel),
             filter: {
                 protocol: userProtocolDefinition.protocol,
@@ -550,14 +539,14 @@ describe('Aggregator Model', () => {
                 recipient: [alice.did, carol.did],
             }
         });
-        const danielReadReply = yield dwn.processMessage(aggregator.did, danielRead.message);
+        const danielReadReply = await dwn.processMessage(aggregator.did, danielRead.message);
         expect(danielReadReply.status.code).toBe(200, 'daniel read');
-        expect((_a = danielReadReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2, 'daniel read records');
+        expect(danielReadReply.entries?.length).toBe(2, 'daniel read records');
         expect(danielReadReply.entries[0].recordId).toBe(aliceNoteToCarol.message.recordId, 'daniel read alice note');
         expect(danielReadReply.entries[1].recordId).toBe(bobNoteToAlice.message.recordId, 'daniel read bob note');
         // create  private notes to carol from alice and bob
         const alicePrivateNoteToCarol = TestDataGenerator.randomBytes(256);
-        const aliceNoteToCarolPrivate = yield RecordsWrite.create({
+        const aliceNoteToCarolPrivate = await RecordsWrite.create({
             signer: Jws.createSigner(alice),
             recipient: carol.did,
             published: false,
@@ -568,16 +557,16 @@ describe('Aggregator Model', () => {
             data: alicePrivateNoteToCarol,
             protocolRole: 'member'
         });
-        const aliceNoteToCarolLocal = yield dwn.processMessage(alice.did, aliceNoteToCarolPrivate.message, {
+        const aliceNoteToCarolLocal = await dwn.processMessage(alice.did, aliceNoteToCarolPrivate.message, {
             dataStream: DataStream.fromBytes(alicePrivateNoteToCarol)
         });
         expect(aliceNoteToCarolLocal.status.code).toBe(202, 'alice private note');
-        const aliceNoteToCarolAggregator = yield dwn.processMessage(aggregator.did, aliceNoteToCarolPrivate.message, {
+        const aliceNoteToCarolAggregator = await dwn.processMessage(aggregator.did, aliceNoteToCarolPrivate.message, {
             dataStream: DataStream.fromBytes(alicePrivateNoteToCarol)
         });
         expect(aliceNoteToCarolAggregator.status.code).toBe(202, 'alice private note aggregator');
         const bobPrivateNoteToCarol = TestDataGenerator.randomBytes(256);
-        const bobNoteToCarolPrivate = yield RecordsWrite.create({
+        const bobNoteToCarolPrivate = await RecordsWrite.create({
             signer: Jws.createSigner(bob),
             recipient: carol.did,
             published: false,
@@ -588,17 +577,17 @@ describe('Aggregator Model', () => {
             data: bobPrivateNoteToCarol,
             protocolRole: 'member'
         });
-        const bobNoteToCarolLocal = yield dwn.processMessage(bob.did, bobNoteToCarolPrivate.message, {
+        const bobNoteToCarolLocal = await dwn.processMessage(bob.did, bobNoteToCarolPrivate.message, {
             dataStream: DataStream.fromBytes(bobPrivateNoteToCarol)
         });
         expect(bobNoteToCarolLocal.status.code).toBe(202, 'bob private note');
-        const bobNoteToCarolAggregator = yield dwn.processMessage(aggregator.did, bobNoteToCarolPrivate.message, {
+        const bobNoteToCarolAggregator = await dwn.processMessage(aggregator.did, bobNoteToCarolPrivate.message, {
             dataStream: DataStream.fromBytes(bobPrivateNoteToCarol)
         });
         expect(bobNoteToCarolAggregator.status.code).toBe(202, 'bob private note aggregator');
         // create a private note from bob to alice
         const bobNoteToAlicePrivateData = TestDataGenerator.randomBytes(256);
-        const bobNoteToAlicePrivate = yield RecordsWrite.create({
+        const bobNoteToAlicePrivate = await RecordsWrite.create({
             signer: Jws.createSigner(bob),
             recipient: alice.did,
             published: false,
@@ -609,16 +598,16 @@ describe('Aggregator Model', () => {
             data: bobNoteToAlicePrivateData,
             protocolRole: 'member'
         });
-        const bobNoteToAliceLocal = yield dwn.processMessage(bob.did, bobNoteToAlicePrivate.message, {
+        const bobNoteToAliceLocal = await dwn.processMessage(bob.did, bobNoteToAlicePrivate.message, {
             dataStream: DataStream.fromBytes(bobNoteToAlicePrivateData)
         });
         expect(bobNoteToAliceLocal.status.code).toBe(202, 'alice private note to bob');
-        const bobNoteToAliceAggregator = yield dwn.processMessage(aggregator.did, bobNoteToAlicePrivate.message, {
+        const bobNoteToAliceAggregator = await dwn.processMessage(aggregator.did, bobNoteToAlicePrivate.message, {
             dataStream: DataStream.fromBytes(bobNoteToAlicePrivateData)
         });
         expect(bobNoteToAliceAggregator.status.code).toBe(202, 'alice private note to bob aggregator');
         // confirm daniel can still only read the public notes
-        const danielRead2 = yield RecordsQuery.create({
+        const danielRead2 = await RecordsQuery.create({
             signer: Jws.createSigner(daniel),
             filter: {
                 protocol: userProtocolDefinition.protocol,
@@ -626,14 +615,14 @@ describe('Aggregator Model', () => {
                 recipient: [alice.did, carol.did],
             }
         });
-        const danielReadReply2 = yield dwn.processMessage(aggregator.did, danielRead2.message);
+        const danielReadReply2 = await dwn.processMessage(aggregator.did, danielRead2.message);
         expect(danielReadReply2.status.code).toBe(200, 'daniel read 2');
-        expect((_b = danielReadReply2.entries) === null || _b === void 0 ? void 0 : _b.length).toBe(2, 'daniel read records 2');
+        expect(danielReadReply2.entries?.length).toBe(2, 'daniel read records 2');
         expect(danielReadReply2.entries[0].recordId).toBe(aliceNoteToCarol.message.recordId, 'daniel read alice note 2');
         expect(danielReadReply2.entries[1].recordId).toBe(bobNoteToAlice.message.recordId, 'daniel read bob note 2');
         // carol queries for notes from alice and bob and gets the public notes and private notes destined for her
         // carol does not see the private note from alice to bob
-        const carolRead = yield RecordsQuery.create({
+        const carolRead = await RecordsQuery.create({
             signer: Jws.createSigner(carol),
             filter: {
                 protocol: userProtocolDefinition.protocol,
@@ -641,15 +630,15 @@ describe('Aggregator Model', () => {
                 recipient: [alice.did, carol.did],
             }
         });
-        const carolReadReply = yield dwn.processMessage(aggregator.did, carolRead.message);
+        const carolReadReply = await dwn.processMessage(aggregator.did, carolRead.message);
         expect(carolReadReply.status.code).toBe(200, 'carol read');
-        expect((_c = carolReadReply.entries) === null || _c === void 0 ? void 0 : _c.length).toBe(4, 'carol read records');
+        expect(carolReadReply.entries?.length).toBe(4, 'carol read records');
         expect(carolReadReply.entries[0].recordId).toBe(aliceNoteToCarol.message.recordId, 'carol read alice note');
         expect(carolReadReply.entries[1].recordId).toBe(bobNoteToAlice.message.recordId, 'carol read bob note');
         expect(carolReadReply.entries[2].recordId).toBe(aliceNoteToCarolPrivate.message.recordId, 'carol read alice private note');
         expect(carolReadReply.entries[3].recordId).toBe(bobNoteToCarolPrivate.message.recordId, 'carol read bob private note');
         // alice queries for notes from bob and carol and gets the public notes and private notes destined for her
-        const aliceRead = yield RecordsQuery.create({
+        const aliceRead = await RecordsQuery.create({
             signer: Jws.createSigner(alice),
             filter: {
                 protocol: userProtocolDefinition.protocol,
@@ -657,12 +646,12 @@ describe('Aggregator Model', () => {
                 recipient: [carol.did, bob.did],
             }
         });
-        const aliceReadReply = yield dwn.processMessage(aggregator.did, aliceRead.message);
+        const aliceReadReply = await dwn.processMessage(aggregator.did, aliceRead.message);
         expect(aliceReadReply.status.code).toBe(200, 'alice read');
-        expect((_d = aliceReadReply.entries) === null || _d === void 0 ? void 0 : _d.length).toBe(3, 'alice read records');
+        expect(aliceReadReply.entries?.length).toBe(3, 'alice read records');
         expect(aliceReadReply.entries[0].recordId).toBe(aliceNoteToCarol.message.recordId, 'alice note to carol public');
         expect(aliceReadReply.entries[1].recordId).toBe(carolNoteToBob.message.recordId, 'carol note to bob public');
         expect(aliceReadReply.entries[2].recordId).toBe(aliceNoteToCarolPrivate.message.recordId, 'alice to carol private');
-    }));
+    });
 });
 //# sourceMappingURL=aggregator.spec.js.map