@enbox/dwn-sdk-js 0.0.6 → 0.0.8

package/dist/esm/tests/handlers/messages-sync.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 freeForAll from '../vectors/protocol-definitions/free-for-all.json' with { type: 'json' };
 import { Jws } from '../../src/utils/jws.js';
 import { Message } from '../../src/core/message.js';
@@ -14,7 +5,7 @@ import { MessagesSync } from '../../src/interfaces/messages-sync.js';
 import { MessagesSyncHandler } from '../../src/handlers/messages-sync.js';
 import sinon from 'sinon';
 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 { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import { DidKey, UniversalResolver } from '@enbox/dids';
@@ -26,246 +17,254 @@ export function testMessagesSyncHandler() {
         let dataStore;
         let resumableTaskStore;
         let stateIndex;
-        let eventStream;
+        let eventLog;
         let dwn;
-        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* () {
-            yield messageStore.clear();
-            yield dataStore.clear();
-            yield resumableTaskStore.clear();
-            yield stateIndex.clear();
-        }));
-        afterAll(() => __awaiter(this, void 0, void 0, function* () {
-            yield dwn.close();
-        }));
+            eventLog = TestEventLog.get();
+            dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventLog, resumableTaskStore });
+        });
+        beforeEach(async () => {
+            await messageStore.clear();
+            await dataStore.clear();
+            await resumableTaskStore.clear();
+            await stateIndex.clear();
+        });
+        afterAll(async () => {
+            await dwn.close();
+        });
         describe('root action', () => {
-            it('returns the empty root hash for a tenant with no messages', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const { message } = yield MessagesSync.create({
+            it('returns the empty root hash for a tenant with no messages', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const { message } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'root',
                 });
-                const reply = yield dwn.processMessage(alice.did, message);
+                const reply = await dwn.processMessage(alice.did, message);
                 expect(reply.status.code).toBe(200);
                 expect(typeof reply.root).toBe('string');
                 expect(reply.root.length).toBe(64); // hex-encoded 32-byte hash
-            }));
-            it('returns a different root hash after writing a message', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('returns a different root hash after writing a message', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // get the empty root
-                const { message: rootMsg1 } = yield MessagesSync.create({
+                const { message: rootMsg1 } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'root',
                 });
-                const reply1 = yield dwn.processMessage(alice.did, rootMsg1);
+                const reply1 = await dwn.processMessage(alice.did, rootMsg1);
                 expect(reply1.status.code).toBe(200);
                 const emptyRoot = reply1.root;
                 // write a record
-                const { message: recordMessage, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                const writeReply = yield dwn.processMessage(alice.did, recordMessage, { dataStream });
+                const { message: recordMessage, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                const writeReply = await dwn.processMessage(alice.did, recordMessage, { dataStream });
                 expect(writeReply.status.code).toBe(202);
                 // get the root again
-                const { message: rootMsg2 } = yield MessagesSync.create({
+                const { message: rootMsg2 } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'root',
                 });
-                const reply2 = yield dwn.processMessage(alice.did, rootMsg2);
+                const reply2 = await dwn.processMessage(alice.did, rootMsg2);
                 expect(reply2.status.code).toBe(200);
                 expect(reply2.root).not.toBe(emptyRoot);
-            }));
-            it('returns protocol-scoped root hash when protocol is specified', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const protocolDefinition = Object.assign(Object.assign({}, freeForAll), { published: true });
+            });
+            it('returns protocol-scoped root hash when protocol is specified', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const protocolDefinition = { ...freeForAll, published: true };
                 // configure the protocol
-                const { message: protocolMessage } = yield TestDataGenerator.generateProtocolsConfigure({
+                const { message: protocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition,
                 });
-                const configureReply = yield dwn.processMessage(alice.did, protocolMessage);
+                const configureReply = await dwn.processMessage(alice.did, protocolMessage);
                 expect(configureReply.status.code).toBe(202);
                 // write a record for this protocol
-                const { message: recordMessage, dataStream } = yield TestDataGenerator.generateRecordsWrite({
+                const { message: recordMessage, dataStream } = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: protocolDefinition.protocol,
                     protocolPath: 'post',
                     schema: protocolDefinition.types.post.schema,
                 });
-                const writeReply = yield dwn.processMessage(alice.did, recordMessage, { dataStream });
+                const writeReply = await dwn.processMessage(alice.did, recordMessage, { dataStream });
                 expect(writeReply.status.code).toBe(202);
-                // write a flat-space (non-protocol) record to diverge the global root
-                const { message: flatRecord, dataStream: flatDataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                const flatWriteReply = yield dwn.processMessage(alice.did, flatRecord, { dataStream: flatDataStream });
-                expect(flatWriteReply.status.code).toBe(202);
+                // write a record under a different protocol to diverge the global root
+                const { message: otherRecord, dataStream: otherDataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                const otherWriteReply = await dwn.processMessage(alice.did, otherRecord, { dataStream: otherDataStream });
+                expect(otherWriteReply.status.code).toBe(202);
                 // get the global root
-                const { message: globalRootMsg } = yield MessagesSync.create({
+                const { message: globalRootMsg } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'root',
                 });
-                const globalReply = yield dwn.processMessage(alice.did, globalRootMsg);
+                const globalReply = await dwn.processMessage(alice.did, globalRootMsg);
                 expect(globalReply.status.code).toBe(200);
                 // get the protocol-scoped root
-                const { message: protoRootMsg } = yield MessagesSync.create({
+                const { message: protoRootMsg } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'root',
                     protocol: protocolDefinition.protocol,
                 });
-                const protoReply = yield dwn.processMessage(alice.did, protoRootMsg);
+                const protoReply = await dwn.processMessage(alice.did, protoRootMsg);
                 expect(protoReply.status.code).toBe(200);
                 // global root and protocol root should be different
-                // (global includes the flat-space record which is not in any protocol)
+                // (global includes the record from the other protocol)
                 expect(protoReply.root).not.toBe(globalReply.root);
                 // both should be non-empty roots
                 expect(protoReply.root.length).toBe(64);
-            }));
+            });
         });
         describe('subtree action', () => {
-            it('returns a subtree hash for a given bit prefix', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            it('returns a subtree hash for a given bit prefix', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // write a record so the tree is non-empty
-                const { message: recordMessage, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                const writeReply = yield dwn.processMessage(alice.did, recordMessage, { dataStream });
+                const { message: recordMessage, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                const writeReply = await dwn.processMessage(alice.did, recordMessage, { dataStream });
                 expect(writeReply.status.code).toBe(202);
-                const { message } = yield MessagesSync.create({
+                const { message } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'subtree',
                     prefix: '0',
                 });
-                const reply = yield dwn.processMessage(alice.did, message);
+                const reply = await dwn.processMessage(alice.did, message);
                 expect(reply.status.code).toBe(200);
                 expect(typeof reply.hash).toBe('string');
                 expect(reply.hash.length).toBe(64);
-            }));
-            it('returns different hashes for different prefixes', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('returns different hashes for different prefixes', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // write several records to populate various subtrees
                 for (let i = 0; i < 10; i++) {
-                    const { message: recordMessage, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                    const writeReply = yield dwn.processMessage(alice.did, recordMessage, { dataStream });
+                    const { message: recordMessage, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                    const writeReply = await dwn.processMessage(alice.did, recordMessage, { dataStream });
                     expect(writeReply.status.code).toBe(202);
                 }
-                const { message: msg0 } = yield MessagesSync.create({
+                const { message: msg0 } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'subtree',
                     prefix: '0',
                 });
-                const reply0 = yield dwn.processMessage(alice.did, msg0);
-                const { message: msg1 } = yield MessagesSync.create({
+                const reply0 = await dwn.processMessage(alice.did, msg0);
+                const { message: msg1 } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'subtree',
                     prefix: '1',
                 });
-                const reply1 = yield dwn.processMessage(alice.did, msg1);
+                const reply1 = await dwn.processMessage(alice.did, msg1);
                 expect(reply0.status.code).toBe(200);
                 expect(reply1.status.code).toBe(200);
                 // With 10 messages, it's very likely the two halves of the tree differ
                 // (not guaranteed but probabilistically near-certain)
-            }));
+            });
         });
         describe('leaves action', () => {
-            it('returns all message CIDs for an empty prefix', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            it('returns all message CIDs for an empty prefix', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // write some messages
                 const expectedCids = [];
                 for (let i = 0; i < 3; i++) {
-                    const { message: recordMessage, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                    const writeReply = yield dwn.processMessage(alice.did, recordMessage, { dataStream });
+                    const { message: recordMessage, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                    const writeReply = await dwn.processMessage(alice.did, recordMessage, { dataStream });
                     expect(writeReply.status.code).toBe(202);
-                    expectedCids.push(yield Message.getCid(recordMessage));
+                    expectedCids.push(await Message.getCid(recordMessage));
                 }
-                const { message } = yield MessagesSync.create({
+                const { message } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'leaves',
                     prefix: '',
                 });
-                const reply = yield dwn.processMessage(alice.did, message);
+                const reply = await dwn.processMessage(alice.did, message);
                 expect(reply.status.code).toBe(200);
                 expect(Array.isArray(reply.entries)).toBe(true);
-                expect(reply.entries.length).toBe(3);
+                // 3 RecordsWrite messages + 1 ProtocolsConfigure for the default test protocol
+                expect(reply.entries.length).toBe(4);
                 for (const cid of expectedCids) {
                     expect(reply.entries).toContain(cid);
                 }
-            }));
-            it('returns protocol-scoped leaves when protocol is specified', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const protocolDefinition = Object.assign(Object.assign({}, freeForAll), { published: true });
+            });
+            it('returns protocol-scoped leaves when protocol is specified', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const protocolDefinition = { ...freeForAll, published: true };
                 // configure the protocol
-                const { message: protocolMessage } = yield TestDataGenerator.generateProtocolsConfigure({
+                const { message: protocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition,
                 });
-                const configureReply = yield dwn.processMessage(alice.did, protocolMessage);
+                const configureReply = await dwn.processMessage(alice.did, protocolMessage);
                 expect(configureReply.status.code).toBe(202);
                 // write a protocol-scoped record
-                const { message: protoRecord, dataStream: protoDataStream } = yield TestDataGenerator.generateRecordsWrite({
+                const { message: protoRecord, dataStream: protoDataStream } = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: protocolDefinition.protocol,
                     protocolPath: 'post',
                     schema: protocolDefinition.types.post.schema,
                 });
-                const protoWriteReply = yield dwn.processMessage(alice.did, protoRecord, { dataStream: protoDataStream });
+                const protoWriteReply = await dwn.processMessage(alice.did, protoRecord, { dataStream: protoDataStream });
                 expect(protoWriteReply.status.code).toBe(202);
-                // write a non-protocol record
-                const { message: flatRecord, dataStream: flatDataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                const flatWriteReply = yield dwn.processMessage(alice.did, flatRecord, { dataStream: flatDataStream });
-                expect(flatWriteReply.status.code).toBe(202);
+                // write a record under a different protocol
+                const { message: otherRecord, dataStream: otherDataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                const otherWriteReply = await dwn.processMessage(alice.did, otherRecord, { dataStream: otherDataStream });
+                expect(otherWriteReply.status.code).toBe(202);
                 // query protocol-scoped leaves
-                const { message } = yield MessagesSync.create({
+                const { message } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'leaves',
                     prefix: '',
                     protocol: protocolDefinition.protocol,
                 });
-                const reply = yield dwn.processMessage(alice.did, message);
+                const reply = await dwn.processMessage(alice.did, message);
                 expect(reply.status.code).toBe(200);
-                // should contain the ProtocolsConfigure and the protocol-scoped record, but not the flat record
+                // should contain the ProtocolsConfigure and the protocol-scoped record, but not the other-protocol record
                 expect(reply.entries.length).toBe(2);
-                const protocolCid = yield Message.getCid(protocolMessage);
-                const recordCid = yield Message.getCid(protoRecord);
+                const protocolCid = await Message.getCid(protocolMessage);
+                const recordCid = await Message.getCid(protoRecord);
                 expect(reply.entries).toContain(protocolCid);
                 expect(reply.entries).toContain(recordCid);
-            }));
+            });
         });
         describe('authorization', () => {
-            it('returns 401 if tenant is not the author', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                const { message } = yield MessagesSync.create({
+            it('returns 401 if tenant is not the author', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const { message } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'root',
                 });
-                const reply = yield dwn.processMessage(bob.did, message);
+                const reply = await dwn.processMessage(bob.did, message);
                 expect(reply.status.code).toBe(401);
-            }));
-            it('returns 400 if message is invalid', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const { message } = yield MessagesSync.create({
+            });
+            it('returns 400 if message is invalid', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const { message } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'root',
                 });
                 message['descriptor']['troll'] = 'hehe';
-                const handler = new MessagesSyncHandler(didResolver, messageStore, stateIndex);
-                const reply = yield handler.handle({ tenant: alice.did, message });
+                const handler = new MessagesSyncHandler({ didResolver, messageStore, stateIndex });
+                const reply = await handler.handle({ tenant: alice.did, message });
                 expect(reply.status.code).toBe(400);
-            }));
+            });
             describe('grant-based sync', () => {
-                it('allows sync with a matching MessagesSync grant scope', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                it('allows sync with a matching MessagesSync grant scope', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     // write a record so the tree is non-empty
-                    const { message: recordMessage, dataStream } = yield TestDataGenerator.generateRecordsWrite({ author: alice });
-                    const writeReply = yield dwn.processMessage(alice.did, recordMessage, { dataStream });
+                    const { message: recordMessage, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                    const writeReply = await dwn.processMessage(alice.did, recordMessage, { dataStream });
                     expect(writeReply.status.code).toBe(202);
                     // grant bob permission to sync Alice's messages
-                    const { message: grantMessage, dataStream: grantDataStream } = yield TestDataGenerator.generateGrantCreate({
+                    const { message: grantMessage, dataStream: grantDataStream } = await TestDataGenerator.generateGrantCreate({
                         author: alice,
                         grantedTo: bob,
                         scope: {
@@ -273,38 +272,112 @@ export function testMessagesSyncHandler() {
                             method: DwnMethodName.Sync,
                         },
                     });
-                    const grantReply = yield dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream });
+                    const grantReply = await dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream });
                     expect(grantReply.status.code).toBe(202);
                     // bob syncs using the grant — root action
-                    const { message: syncMsg } = yield MessagesSync.create({
+                    const { message: syncMsg } = await MessagesSync.create({
                         signer: Jws.createSigner(bob),
                         action: 'root',
                         permissionGrantId: grantMessage.recordId,
                     });
-                    const reply = yield dwn.processMessage(alice.did, syncMsg);
+                    const reply = await dwn.processMessage(alice.did, syncMsg);
                     expect(reply.status.code).toBe(200);
                     expect(typeof reply.root).toBe('string');
                     expect(reply.root.length).toBe(64);
-                }));
-                it('allows sync with a protocol-scoped grant', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
-                    const protocolDefinition = Object.assign(Object.assign({}, freeForAll), { published: true });
+                });
+                it('allows sync with a unified MessagesRead grant scope', async () => {
+                    // scenario: A Messages.Read grant should also authorize MessagesSync operations
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                    // write a record so the tree is non-empty
+                    const { message: recordMessage, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
+                    const writeReply = await dwn.processMessage(alice.did, recordMessage, { dataStream });
+                    expect(writeReply.status.code).toBe(202);
+                    // grant bob permission with Messages.Read scope (unified)
+                    const { message: grantMessage, dataStream: grantDataStream } = await TestDataGenerator.generateGrantCreate({
+                        author: alice,
+                        grantedTo: bob,
+                        scope: {
+                            interface: DwnInterfaceName.Messages,
+                            method: DwnMethodName.Read,
+                        },
+                    });
+                    const grantReply = await dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream });
+                    expect(grantReply.status.code).toBe(202);
+                    // bob syncs using the Messages.Read grant — root action
+                    const { message: syncMsg } = await MessagesSync.create({
+                        signer: Jws.createSigner(bob),
+                        action: 'root',
+                        permissionGrantId: grantMessage.recordId,
+                    });
+                    const reply2 = await dwn.processMessage(alice.did, syncMsg);
+                    expect(reply2.status.code).toBe(200);
+                    expect(typeof reply2.root).toBe('string');
+                    expect(reply2.root.length).toBe(64);
+                });
+                it('allows sync with a protocol-scoped MessagesRead grant', async () => {
+                    // scenario: A Messages.Read grant scoped to a protocol should authorize protocol-scoped MessagesSync
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
+                    const protocolDefinition = { ...freeForAll, published: true };
                     // configure and write a protocol record
-                    const { message: protocolMessage } = yield TestDataGenerator.generateProtocolsConfigure({
+                    const { message: protocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
                         author: alice,
                         protocolDefinition,
                     });
-                    yield dwn.processMessage(alice.did, protocolMessage);
-                    const { message: recordMessage, dataStream } = yield TestDataGenerator.generateRecordsWrite({
+                    await dwn.processMessage(alice.did, protocolMessage);
+                    const { message: recordMessage, dataStream } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         protocol: protocolDefinition.protocol,
                         protocolPath: 'post',
                         schema: protocolDefinition.types.post.schema,
                     });
-                    yield dwn.processMessage(alice.did, recordMessage, { dataStream });
+                    await dwn.processMessage(alice.did, recordMessage, { dataStream });
+                    // grant bob permission with Messages.Read scope scoped to this protocol
+                    const { message: grantMessage, dataStream: grantDataStream } = await TestDataGenerator.generateGrantCreate({
+                        author: alice,
+                        grantedTo: bob,
+                        scope: {
+                            interface: DwnInterfaceName.Messages,
+                            method: DwnMethodName.Read,
+                            protocol: protocolDefinition.protocol,
+                        },
+                    });
+                    const grantReply = await dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream });
+                    expect(grantReply.status.code).toBe(202);
+                    // bob syncs leaves with the protocol-scoped Messages.Read grant
+                    const { message: syncMsg } = await MessagesSync.create({
+                        signer: Jws.createSigner(bob),
+                        action: 'leaves',
+                        prefix: '',
+                        protocol: protocolDefinition.protocol,
+                        permissionGrantId: grantMessage.recordId,
+                    });
+                    const reply2 = await dwn.processMessage(alice.did, syncMsg);
+                    expect(reply2.status.code).toBe(200);
+                    expect(Array.isArray(reply2.entries)).toBe(true);
+                    expect(reply2.entries.length).toBe(2);
+                });
+                it('allows sync with a protocol-scoped grant', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
+                    const protocolDefinition = { ...freeForAll, published: true };
+                    // configure and write a protocol record
+                    const { message: protocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
+                        author: alice,
+                        protocolDefinition,
+                    });
+                    await dwn.processMessage(alice.did, protocolMessage);
+                    const { message: recordMessage, dataStream } = await TestDataGenerator.generateRecordsWrite({
+                        author: alice,
+                        protocol: protocolDefinition.protocol,
+                        protocolPath: 'post',
+                        schema: protocolDefinition.types.post.schema,
+                    });
+                    await dwn.processMessage(alice.did, recordMessage, { dataStream });
                     // grant bob permission to sync Alice's messages scoped to this protocol
-                    const { message: grantMessage, dataStream: grantDataStream } = yield TestDataGenerator.generateGrantCreate({
+                    const { message: grantMessage, dataStream: grantDataStream } = await TestDataGenerator.generateGrantCreate({
                         author: alice,
                         grantedTo: bob,
                         scope: {
@@ -313,31 +386,31 @@ export function testMessagesSyncHandler() {
                             protocol: protocolDefinition.protocol,
                         },
                     });
-                    const grantReply = yield dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream });
+                    const grantReply = await dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream });
                     expect(grantReply.status.code).toBe(202);
                     // bob syncs leaves with the protocol-scoped grant
-                    const { message: syncMsg } = yield MessagesSync.create({
+                    const { message: syncMsg } = await MessagesSync.create({
                         signer: Jws.createSigner(bob),
                         action: 'leaves',
                         prefix: '',
                         protocol: protocolDefinition.protocol,
                         permissionGrantId: grantMessage.recordId,
                     });
-                    const reply = yield dwn.processMessage(alice.did, syncMsg);
+                    const reply = await dwn.processMessage(alice.did, syncMsg);
                     expect(reply.status.code).toBe(200);
                     expect(Array.isArray(reply.entries)).toBe(true);
                     // includes both the ProtocolsConfigure and the RecordsWrite
                     expect(reply.entries.length).toBe(2);
-                    const protocolCid = yield Message.getCid(protocolMessage);
-                    const recordCid = yield Message.getCid(recordMessage);
+                    const protocolCid = await Message.getCid(protocolMessage);
+                    const recordCid = await Message.getCid(recordMessage);
                     expect(reply.entries).toContain(protocolCid);
                     expect(reply.entries).toContain(recordCid);
-                }));
-                it('rejects sync with mismatching interface grant scope', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('rejects sync with mismatching interface grant scope', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     // create a RecordsWrite grant (wrong interface for MessagesSync)
-                    const { message: grantMessage, dataStream } = yield TestDataGenerator.generateGrantCreate({
+                    const { message: grantMessage, dataStream } = await TestDataGenerator.generateGrantCreate({
                         author: alice,
                         grantedTo: bob,
                         scope: {
@@ -346,22 +419,22 @@ export function testMessagesSyncHandler() {
                             protocol: freeForAll.protocol,
                         },
                     });
-                    const grantReply = yield dwn.processMessage(alice.did, grantMessage, { dataStream });
+                    const grantReply = await dwn.processMessage(alice.did, grantMessage, { dataStream });
                     expect(grantReply.status.code).toBe(202);
-                    const { message: syncMsg } = yield MessagesSync.create({
+                    const { message: syncMsg } = await MessagesSync.create({
                         signer: Jws.createSigner(bob),
                         action: 'root',
                         permissionGrantId: grantMessage.recordId,
                     });
-                    const reply = yield dwn.processMessage(alice.did, syncMsg);
+                    const reply = await dwn.processMessage(alice.did, syncMsg);
                     expect(reply.status.code).toBe(401);
                     expect(reply.status.detail).toContain(DwnErrorCode.GrantAuthorizationInterfaceMismatch);
-                }));
-                it('rejects sync with mismatching method grant scope', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('rejects sync with mismatching method grant scope', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     // create a MessagesSubscribe grant (wrong method for MessagesSync)
-                    const { message: grantMessage, dataStream } = yield TestDataGenerator.generateGrantCreate({
+                    const { message: grantMessage, dataStream } = await TestDataGenerator.generateGrantCreate({
                         author: alice,
                         grantedTo: bob,
                         scope: {
@@ -369,22 +442,22 @@ export function testMessagesSyncHandler() {
                             method: DwnMethodName.Subscribe,
                         },
                     });
-                    const grantReply = yield dwn.processMessage(alice.did, grantMessage, { dataStream });
+                    const grantReply = await dwn.processMessage(alice.did, grantMessage, { dataStream });
                     expect(grantReply.status.code).toBe(202);
-                    const { message: syncMsg } = yield MessagesSync.create({
+                    const { message: syncMsg } = await MessagesSync.create({
                         signer: Jws.createSigner(bob),
                         action: 'root',
                         permissionGrantId: grantMessage.recordId,
                     });
-                    const reply = yield dwn.processMessage(alice.did, syncMsg);
+                    const reply = await dwn.processMessage(alice.did, syncMsg);
                     expect(reply.status.code).toBe(401);
                     expect(reply.status.detail).toContain(DwnErrorCode.GrantAuthorizationMethodMismatch);
-                }));
-                it('rejects sync with mismatching protocol grant scope', () => __awaiter(this, void 0, void 0, function* () {
-                    const alice = yield TestDataGenerator.generateDidKeyPersona();
-                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                });
+                it('rejects sync with mismatching protocol grant scope', async () => {
+                    const alice = await TestDataGenerator.generateDidKeyPersona();
+                    const bob = await TestDataGenerator.generateDidKeyPersona();
                     // grant bob permission to sync protocol1
-                    const { message: grantMessage, dataStream } = yield TestDataGenerator.generateGrantCreate({
+                    const { message: grantMessage, dataStream } = await TestDataGenerator.generateGrantCreate({
                         author: alice,
                         grantedTo: bob,
                         scope: {
@@ -393,39 +466,39 @@ export function testMessagesSyncHandler() {
                             protocol: 'http://protocol1',
                         },
                     });
-                    const grantReply = yield dwn.processMessage(alice.did, grantMessage, { dataStream });
+                    const grantReply = await dwn.processMessage(alice.did, grantMessage, { dataStream });
                     expect(grantReply.status.code).toBe(202);
                     // bob attempts to sync protocol2 using the protocol1 grant
-                    const { message: syncMsg } = yield MessagesSync.create({
+                    const { message: syncMsg } = await MessagesSync.create({
                         signer: Jws.createSigner(bob),
                         action: 'root',
                         protocol: 'http://protocol2',
                         permissionGrantId: grantMessage.recordId,
                     });
-                    const reply = yield dwn.processMessage(alice.did, syncMsg);
+                    const reply = await dwn.processMessage(alice.did, syncMsg);
                     expect(reply.status.code).toBe(401);
                     expect(reply.status.detail).toContain(DwnErrorCode.MessagesGrantAuthorizationMismatchedProtocol);
-                }));
+                });
             });
         });
         describe('input validation', () => {
-            it('returns 400 for an unknown action', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const { message } = yield MessagesSync.create({
+            it('returns 400 for an unknown action', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const { message } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'root',
                 });
                 // manually override to an invalid action
                 message.descriptor.action = 'invalid';
-                const handler = new MessagesSyncHandler(didResolver, messageStore, stateIndex);
-                const reply = yield handler.handle({ tenant: alice.did, message });
+                const handler = new MessagesSyncHandler({ didResolver, messageStore, stateIndex });
+                const reply = await handler.handle({ tenant: alice.did, message });
                 expect(reply.status.code).toBe(400);
                 // the JSON schema validator catches the invalid action before the handler switch/case
                 expect(reply.status.detail).toContain('SchemaValidatorFailure');
-            }));
-            it('returns 400 for unknown action that bypasses schema validation (default case)', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const { message } = yield MessagesSync.create({
+            });
+            it('returns 400 for unknown action that bypasses schema validation (default case)', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const { message } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'root',
                 });
@@ -438,18 +511,18 @@ export function testMessagesSyncHandler() {
                 try {
                     // Override action to something that passes the stub but hits the default case
                     message.descriptor.action = 'bogusAction';
-                    const handler = new MessagesSyncHandler(didResolver, messageStore, stateIndex);
-                    const reply = yield handler.handle({ tenant: alice.did, message });
+                    const handler = new MessagesSyncHandler({ didResolver, messageStore, stateIndex });
+                    const reply = await handler.handle({ tenant: alice.did, message });
                     expect(reply.status.code).toBe(400);
                     expect(reply.status.detail).toContain('Unknown action');
                 }
                 finally {
                     parseStub.restore();
                 }
-            }));
-            it('returns 500 for invalid prefix with non-binary characters (via stubbed parse)', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const { message } = yield MessagesSync.create({
+            });
+            it('returns 500 for invalid prefix with non-binary characters (via stubbed parse)', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const { message } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'subtree',
                     prefix: '0',
@@ -463,18 +536,18 @@ export function testMessagesSyncHandler() {
                 try {
                     // Override prefix to contain invalid characters
                     message.descriptor.prefix = 'abc';
-                    const handler = new MessagesSyncHandler(didResolver, messageStore, stateIndex);
-                    const reply = yield handler.handle({ tenant: alice.did, message });
+                    const handler = new MessagesSyncHandler({ didResolver, messageStore, stateIndex });
+                    const reply = await handler.handle({ tenant: alice.did, message });
                     expect(reply.status.code).toBe(500);
                     expect(reply.status.detail).toContain('MessagesSyncInvalidPrefix');
                 }
                 finally {
                     parseStub.restore();
                 }
-            }));
-            it('returns 500 for prefix exceeding 256 characters (via stubbed parse)', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const { message } = yield MessagesSync.create({
+            });
+            it('returns 500 for prefix exceeding 256 characters (via stubbed parse)', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const { message } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'subtree',
                     prefix: '0',
@@ -488,40 +561,40 @@ export function testMessagesSyncHandler() {
                 try {
                     // Override prefix to be too long
                     message.descriptor.prefix = '0'.repeat(257);
-                    const handler = new MessagesSyncHandler(didResolver, messageStore, stateIndex);
-                    const reply = yield handler.handle({ tenant: alice.did, message });
+                    const handler = new MessagesSyncHandler({ didResolver, messageStore, stateIndex });
+                    const reply = await handler.handle({ tenant: alice.did, message });
                     expect(reply.status.code).toBe(500);
                     expect(reply.status.detail).toContain('MessagesSyncInvalidPrefix');
                 }
                 finally {
                     parseStub.restore();
                 }
-            }));
+            });
         });
         describe('error handling', () => {
-            it('returns 500 when stateIndex throws an unexpected error', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            it('returns 500 when stateIndex throws an unexpected error', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const failingStateIndex = {
-                    open: () => __awaiter(this, void 0, void 0, function* () { }),
-                    close: () => __awaiter(this, void 0, void 0, function* () { }),
-                    clear: () => __awaiter(this, void 0, void 0, function* () { }),
-                    insert: () => __awaiter(this, void 0, void 0, function* () { }),
-                    delete: () => __awaiter(this, void 0, void 0, function* () { }),
-                    getRoot: () => __awaiter(this, void 0, void 0, function* () { throw new Error('Unexpected DB failure'); }),
-                    getProtocolRoot: () => __awaiter(this, void 0, void 0, function* () { throw new Error('Unexpected DB failure'); }),
-                    getSubtreeHash: () => __awaiter(this, void 0, void 0, function* () { throw new Error('Unexpected DB failure'); }),
-                    getProtocolSubtreeHash: () => __awaiter(this, void 0, void 0, function* () { throw new Error('Unexpected DB failure'); }),
-                    getLeaves: () => __awaiter(this, void 0, void 0, function* () { throw new Error('Unexpected DB failure'); }),
-                    getProtocolLeaves: () => __awaiter(this, void 0, void 0, function* () { throw new Error('Unexpected DB failure'); }),
+                    open: async () => { },
+                    close: async () => { },
+                    clear: async () => { },
+                    insert: async () => { },
+                    delete: async () => { },
+                    getRoot: async () => { throw new Error('Unexpected DB failure'); },
+                    getProtocolRoot: async () => { throw new Error('Unexpected DB failure'); },
+                    getSubtreeHash: async () => { throw new Error('Unexpected DB failure'); },
+                    getProtocolSubtreeHash: async () => { throw new Error('Unexpected DB failure'); },
+                    getLeaves: async () => { throw new Error('Unexpected DB failure'); },
+                    getProtocolLeaves: async () => { throw new Error('Unexpected DB failure'); },
                 };
-                const handler = new MessagesSyncHandler(didResolver, messageStore, failingStateIndex);
-                const { message } = yield MessagesSync.create({
+                const handler = new MessagesSyncHandler({ didResolver, messageStore, stateIndex: failingStateIndex });
+                const { message } = await MessagesSync.create({
                     signer: Jws.createSigner(alice),
                     action: 'root',
                 });
-                const reply = yield handler.handle({ tenant: alice.did, message });
+                const reply = await handler.handle({ tenant: alice.did, message });
                 expect(reply.status.code).toBe(500);
-            }));
+            });
         });
     });
 }