@enbox/dwn-sdk-js 0.0.1 → 0.0.3

package/dist/esm/tests/handlers/protocols-configure.spec.js

@@ -7,11 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import chaiAsPromised from 'chai-as-promised';
+import dexProtocolDefinition from '../vectors/protocol-definitions/dex.json' with { type: 'json' };
+import minimalProtocolDefinition from '../vectors/protocol-definitions/minimal.json' with { type: 'json' };
 import sinon from 'sinon';
-import chai, { expect } from 'chai';
-import dexProtocolDefinition from '../vectors/protocol-definitions/dex.json' assert { type: 'json' };
-import minimalProtocolDefinition from '../vectors/protocol-definitions/minimal.json' assert { type: 'json' };
 import { GeneralJwsBuilder } from '../../src/jose/jws/general/builder.js';
 import { lexicographicalCompare } from '../../src/utils/string.js';
 import { Message } from '../../src/core/message.js';
@@ -21,30 +19,30 @@ import { TestEventStream } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
 import { TestStubGenerator } from '../utils/test-stub-generator.js';
 import { Time } from '../../src/utils/time.js';
-import { DataStream, Dwn, DwnErrorCode, DwnInterfaceName, DwnMethodName, Encoder, Jws, PermissionGrant, PermissionsProtocol } from '../../src/index.js';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
+import { DataStream, Dwn, DwnErrorCode, DwnInterfaceName, DwnMethodName, Encoder, Jws, PermissionGrant, PermissionsProtocol, RecordsDelete, RecordsRead, RecordsWrite } from '../../src/index.js';
 import { DidKey, UniversalResolver } from '@enbox/dids';
-chai.use(chaiAsPromised);
 export function testProtocolsConfigureHandler() {
     describe('ProtocolsConfigureHandler.handle()', () => {
         let didResolver;
         let messageStore;
         let dataStore;
         let resumableTaskStore;
-        let eventLog;
+        let stateIndex;
         let eventStream;
         let dwn;
         describe('functional tests', () => {
             // important to follow the `before` and `after` pattern to initialize and clean the stores in tests
             // so that different test suites can reuse the same backend store for testing
-            before(() => __awaiter(this, void 0, void 0, function* () {
+            beforeAll(() => __awaiter(this, void 0, void 0, function* () {
                 didResolver = new UniversalResolver({ didResolvers: [DidKey] });
                 const stores = TestStores.get();
                 messageStore = stores.messageStore;
                 dataStore = stores.dataStore;
                 resumableTaskStore = stores.resumableTaskStore;
-                eventLog = stores.eventLog;
+                stateIndex = stores.stateIndex;
                 eventStream = TestEventStream.get();
-                dwn = yield Dwn.create({ didResolver, messageStore, dataStore, eventLog, eventStream, resumableTaskStore });
+                dwn = yield Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
             }));
             beforeEach(() => __awaiter(this, void 0, void 0, function* () {
                 sinon.restore(); // wipe all previous stubs/spies/mocks/fakes
@@ -52,9 +50,9 @@ export function testProtocolsConfigureHandler() {
                 yield messageStore.clear();
                 yield dataStore.clear();
                 yield resumableTaskStore.clear();
-                yield eventLog.clear();
+                yield stateIndex.clear();
             }));
-            after(() => __awaiter(this, void 0, void 0, function* () {
+            afterAll(() => __awaiter(this, void 0, void 0, function* () {
                 yield dwn.close();
             }));
             it('should allow a protocol definition with schema or dataFormat omitted', () => __awaiter(this, void 0, void 0, function* () {
@@ -65,7 +63,7 @@ export function testProtocolsConfigureHandler() {
                     protocolDefinition,
                 });
                 const reply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                expect(reply.status.code).to.equal(202);
+                expect(reply.status.code).toBe(202);
             }));
             it('should return 400 if more than 1 signature is provided in `authorization`', () => __awaiter(this, void 0, void 0, function* () {
                 const { author, message, protocolsConfigure } = yield TestDataGenerator.generateProtocolsConfigure();
@@ -79,8 +77,8 @@ export function testProtocolsConfigureHandler() {
                 message.authorization = { signature: jwsBuilder.getJws() };
                 TestStubGenerator.stubDidResolver(didResolver, [author]);
                 const reply = yield dwn.processMessage(tenant, message);
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain('expected no more than 1 signature');
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain('expected no more than 1 signature');
             }));
             it('should return 401 if auth fails', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -89,10 +87,10 @@ export function testProtocolsConfigureHandler() {
                 const badSignature = yield TestDataGenerator.randomSignatureString();
                 message.authorization.signature.signatures[0].signature = badSignature;
                 const reply = yield dwn.processMessage(alice.did, message);
-                expect(reply.status.code).to.equal(401);
-                expect(reply.status.detail).to.contain(DwnErrorCode.GeneralJwsVerifierInvalidSignature);
+                expect(reply.status.code).toBe(401);
+                expect(reply.status.detail).toContain(DwnErrorCode.GeneralJwsVerifierInvalidSignature);
             }));
-            it('should be able to overwrite existing protocol if timestamp is newer', () => __awaiter(this, void 0, void 0, function* () {
+            it('should store all protocol versions and query should only return the latest', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 const protocolDefinition = minimalProtocolDefinition;
@@ -107,27 +105,27 @@ export function testProtocolsConfigureHandler() {
                 });
                 // first ProtocolsConfigure
                 const reply1 = yield dwn.processMessage(alice.did, middleProtocolsConfigure.message);
-                expect(reply1.status.code).to.equal(202);
-                // older messages will not overwrite the existing
+                expect(reply1.status.code).toBe(202);
+                // older messages are also accepted (stored as historical versions)
                 const reply2 = yield dwn.processMessage(alice.did, oldProtocolsConfigure.message);
-                expect(reply2.status.code).to.equal(409);
-                // newer message can overwrite the existing message
+                expect(reply2.status.code).toBe(202);
+                // newer message is also accepted and becomes the latest
                 const newProtocolsConfigure = yield TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
                     protocolDefinition,
                 });
                 const reply3 = yield dwn.processMessage(alice.did, newProtocolsConfigure.message);
-                expect(reply3.status.code).to.equal(202);
-                // only the newest protocol should remain
+                expect(reply3.status.code).toBe(202);
+                // only the newest protocol should be returned by query (ProtocolsQuery returns only latest)
                 const queryMessageData = yield TestDataGenerator.generateProtocolsQuery({
                     author: alice,
                     filter: { protocol: protocolDefinition.protocol }
                 });
                 const queryReply = yield dwn.processMessage(alice.did, queryMessageData.message);
-                expect(queryReply.status.code).to.equal(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+                expect(queryReply.status.code).toBe(200);
+                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
             }));
-            it('should only be able to overwrite existing protocol if new protocol is lexicographically larger and timestamps are identical', () => __awaiter(this, void 0, void 0, function* () {
+            it('should store all protocol versions with identical timestamps and query should only return the newest (by CID tiebreak)', () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
                 // Alter each protocol slightly to create lexicographic difference between them
@@ -158,21 +156,21 @@ export function testProtocolsConfigureHandler() {
                 const [lowestProtocolsConfigure, middleProtocolsConfigure, highestProtocolsConfigure] = messageDataWithCid.sort((messageDataA, messageDataB) => { return lexicographicalCompare(messageDataA.cid, messageDataB.cid); });
                 // write the protocol with the middle lexicographic value
                 const reply1 = yield dwn.processMessage(alice.did, middleProtocolsConfigure.message);
-                expect(reply1.status.code).to.equal(202);
-                // test that the protocol with the smallest lexicographic value cannot be written
+                expect(reply1.status.code).toBe(202);
+                // all versions are accepted (stored as historical versions)
                 const reply2 = yield dwn.processMessage(alice.did, lowestProtocolsConfigure.message);
-                expect(reply2.status.code).to.equal(409);
-                // test that the protocol with the largest lexicographic value can be written
+                expect(reply2.status.code).toBe(202);
+                // highest lexicographic value is also accepted and becomes the latest
                 const reply3 = yield dwn.processMessage(alice.did, highestProtocolsConfigure.message);
-                expect(reply3.status.code).to.equal(202);
-                // test that lower lexicographic protocol message is removed from DB and only the newer protocol message remains
+                expect(reply3.status.code).toBe(202);
+                // query should only return the latest protocol definition (highest by CID tiebreak)
                 const queryMessageData = yield TestDataGenerator.generateProtocolsQuery({
                     author: alice,
                     filter: { protocol: protocolDefinition1.protocol }
                 });
                 const queryReply = yield dwn.processMessage(alice.did, queryMessageData.message);
-                expect(queryReply.status.code).to.equal(200);
-                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).to.equal(1);
+                expect(queryReply.status.code).toBe(200);
+                expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
             }));
             it('should return 400 if protocol is not normalized', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -190,8 +188,8 @@ export function testProtocolsConfigureHandler() {
                 });
                 // Send records write message
                 const reply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain(DwnErrorCode.UrlProtocolNotNormalized);
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain(DwnErrorCode.UrlProtocolNotNormalized);
             }));
             it('should return 400 if schema is not normalized', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -209,8 +207,8 @@ export function testProtocolsConfigureHandler() {
                 });
                 // Send records write message
                 const reply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                expect(reply.status.code).to.equal(400);
-                expect(reply.status.detail).to.contain(DwnErrorCode.UrlSchemaNotNormalized);
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain(DwnErrorCode.UrlSchemaNotNormalized);
             }));
             it('rejects non-tenant non-granted ProtocolsConfigures with 401', () => __awaiter(this, void 0, void 0, function* () {
                 // Bob tries to ProtocolsConfigure to Alice's DWN without a permission grant
@@ -222,8 +220,8 @@ export function testProtocolsConfigureHandler() {
                     protocolDefinition,
                 });
                 const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
-                expect(protocolsConfigureReply.status.code).to.equal(401);
-                expect(protocolsConfigureReply.status.detail).to.contain(DwnErrorCode.ProtocolsConfigureAuthorizationFailed);
+                expect(protocolsConfigureReply.status.code).toBe(401);
+                expect(protocolsConfigureReply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureAuthorizationFailed);
             }));
             it('should reject ProtocolsConfigure with action rule containing duplicated actor (`who` or `who` + `of` combination) within a rule set', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -262,8 +260,8 @@ export function testProtocolsConfigureHandler() {
                 });
                 const protocolsConfigureMessage = { descriptor, authorization };
                 const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
-                expect(protocolsConfigureReply.status.code).to.equal(400);
-                expect(protocolsConfigureReply.status.detail).to.contain(DwnErrorCode.ProtocolsConfigureDuplicateActorInRuleSet);
+                expect(protocolsConfigureReply.status.code).toBe(400);
+                expect(protocolsConfigureReply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureDuplicateActorInRuleSet);
                 // similar test as above but with `of` property
                 const protocolDefinition2 = {
                     protocol: 'http://foo-bar',
@@ -304,8 +302,8 @@ export function testProtocolsConfigureHandler() {
                 });
                 const protocolsConfigureMessage2 = { descriptor: descriptor2, authorization: authorization2 };
                 const protocolsConfigure2Reply = yield dwn.processMessage(alice.did, protocolsConfigureMessage2);
-                expect(protocolsConfigure2Reply.status.code).to.equal(400);
-                expect(protocolsConfigure2Reply.status.detail).to.contain(DwnErrorCode.ProtocolsConfigureDuplicateActorInRuleSet);
+                expect(protocolsConfigure2Reply.status.code).toBe(400);
+                expect(protocolsConfigure2Reply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureDuplicateActorInRuleSet);
             }));
             it('should reject ProtocolsConfigure with action rule containing duplicated role within a rule set', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -348,145 +346,163 @@ export function testProtocolsConfigureHandler() {
                 });
                 const protocolsConfigureMessage = { descriptor, authorization };
                 const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
-                expect(protocolsConfigureReply.status.code).to.equal(400);
-                expect(protocolsConfigureReply.status.detail).to.contain(DwnErrorCode.ProtocolsConfigureDuplicateRoleInRuleSet);
+                expect(protocolsConfigureReply.status.code).toBe(400);
+                expect(protocolsConfigureReply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureDuplicateRoleInRuleSet);
             }));
-            it('should reject ProtocolsConfigure with role action rule that contain a read action(`read` || `query` || `subscribe`) but not all of the read actions', () => __awaiter(this, void 0, void 0, function* () {
+            it('should reject ProtocolsConfigure with action rule `of` pointing to a sibling type (not an ancestor)', () => __awaiter(this, void 0, void 0, function* () {
                 const alice = yield TestDataGenerator.generateDidKeyPersona();
-                // without 'subscribe' action
-                const protocolDefinitionWithoutSubscribe = {
-                    protocol: 'http://foo',
+                // `bar` and `baz` are siblings under `foo`, so `baz` action rule cannot reference `of: 'foo/bar'`
+                const protocolDefinition = {
+                    protocol: 'http://example.com/sibling-of-test',
                     published: true,
                     types: {
-                        friend: {},
                         foo: {},
+                        bar: {},
+                        baz: {},
                     },
                     structure: {
-                        friend: {
-                            $role: true
-                        },
                         foo: {
-                            $actions: [
-                                {
-                                    role: 'friend',
-                                    can: [ProtocolAction.Read, ProtocolAction.Query] // missing `subscribe`
-                                }
-                            ]
+                            bar: {},
+                            baz: {
+                                $actions: [
+                                    {
+                                        who: 'author',
+                                        of: 'foo/bar', // sibling, not ancestor
+                                        can: [ProtocolAction.Create]
+                                    }
+                                ]
+                            }
                         }
                     }
                 };
                 // manually craft the invalid ProtocolsConfigure message because our library will not let you create an invalid definition
-                let descriptor = {
+                const descriptor = {
                     interface: DwnInterfaceName.Protocols,
                     method: DwnMethodName.Configure,
                     messageTimestamp: Time.getCurrentTimestamp(),
-                    definition: protocolDefinitionWithoutSubscribe
+                    definition: protocolDefinition
                 };
-                let authorization = yield Message.createAuthorization({
+                const authorization = yield Message.createAuthorization({
                     descriptor,
                     signer: Jws.createSigner(alice)
                 });
-                let protocolsConfigureMessage = { descriptor, authorization };
-                const withoutSubscribeResponse = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
-                expect(withoutSubscribeResponse.status.code).to.equal(400);
-                // without 'query' action
-                const protocolDefinitionWithoutQuery = {
-                    protocol: 'http://foo',
+                const protocolsConfigureMessage = { descriptor, authorization };
+                const reply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureInvalidActionOfNotAnAncestor);
+            }));
+            it('should reject ProtocolsConfigure with action rule `of` pointing to an unrelated type', () => __awaiter(this, void 0, void 0, function* () {
+                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                // `comment` is a top-level type unrelated to the nested `thread/reply` path
+                const protocolDefinition = {
+                    protocol: 'http://example.com/unrelated-of-test',
                     published: true,
                     types: {
-                        friend: {},
-                        foo: {},
+                        thread: {},
+                        reply: {},
+                        comment: {},
                     },
                     structure: {
-                        friend: {
-                            $role: true
+                        thread: {
+                            reply: {
+                                $actions: [
+                                    {
+                                        who: 'author',
+                                        of: 'comment', // unrelated type, not an ancestor of 'thread/reply'
+                                        can: [ProtocolAction.Create]
+                                    }
+                                ]
+                            }
                         },
-                        foo: {
-                            $actions: [
-                                {
-                                    role: 'friend',
-                                    can: [ProtocolAction.Read, ProtocolAction.Subscribe] // missing `query`
-                                }
-                            ]
-                        }
+                        comment: {}
                     }
                 };
-                descriptor = {
+                const descriptor = {
                     interface: DwnInterfaceName.Protocols,
                     method: DwnMethodName.Configure,
                     messageTimestamp: Time.getCurrentTimestamp(),
-                    definition: protocolDefinitionWithoutQuery
+                    definition: protocolDefinition
                 };
-                authorization = yield Message.createAuthorization({
+                const authorization = yield Message.createAuthorization({
                     descriptor,
                     signer: Jws.createSigner(alice)
                 });
-                protocolsConfigureMessage = { descriptor, authorization };
-                const withoutQueryResponse = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
-                expect(withoutQueryResponse.status.code).to.equal(400);
-                // without 'read' action
-                const protocolDefinitionWithoutRead = {
-                    protocol: 'http://foo',
+                const protocolsConfigureMessage = { descriptor, authorization };
+                const reply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
+                expect(reply.status.code).toBe(400);
+                expect(reply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureInvalidActionOfNotAnAncestor);
+            }));
+            it('should accept ProtocolsConfigure with action rule `of` pointing to itself (same protocol path)', () => __awaiter(this, void 0, void 0, function* () {
+                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                // `of` pointing to the same protocol path is valid: "the author of this record can update it"
+                const protocolDefinition = {
+                    protocol: 'http://example.com/self-of-test',
                     published: true,
                     types: {
-                        friend: {},
                         foo: {},
+                        bar: {},
                     },
                     structure: {
-                        friend: {
-                            $role: true
-                        },
                         foo: {
-                            $actions: [
-                                {
-                                    role: 'friend',
-                                    can: [ProtocolAction.Query, ProtocolAction.Subscribe] // missing `read`
-                                }
-                            ]
+                            bar: {
+                                $actions: [
+                                    {
+                                        who: 'author',
+                                        of: 'foo/bar', // same as current protocol path — valid self-reference
+                                        can: [ProtocolAction.Create]
+                                    }
+                                ]
+                            }
                         }
                     }
                 };
-                descriptor = {
-                    interface: DwnInterfaceName.Protocols,
-                    method: DwnMethodName.Configure,
-                    messageTimestamp: Time.getCurrentTimestamp(),
-                    definition: protocolDefinitionWithoutRead
-                };
-                authorization = yield Message.createAuthorization({
-                    descriptor,
-                    signer: Jws.createSigner(alice)
+                const protocolsConfigure = yield TestDataGenerator.generateProtocolsConfigure({
+                    author: alice,
+                    protocolDefinition,
                 });
-                protocolsConfigureMessage = { descriptor, authorization };
-                const withoutReadResponse = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
-                expect(withoutReadResponse.status.code).to.equal(400);
-                // sanity, all read actions exist
-                const protocolDefinitionWithAllReadActions = {
-                    protocol: 'http://foo',
+                const reply = yield dwn.processMessage(alice.did, protocolsConfigure.message);
+                expect(reply.status.code).toBe(202);
+            }));
+            it('should accept ProtocolsConfigure with action rule `of` pointing to a valid ancestor', () => __awaiter(this, void 0, void 0, function* () {
+                const alice = yield TestDataGenerator.generateDidKeyPersona();
+                // `of: 'thread'` is a valid ancestor of `thread/reply/reaction`
+                const protocolDefinition = {
+                    protocol: 'http://example.com/valid-ancestor-of-test',
                     published: true,
                     types: {
-                        friend: {},
-                        foo: {},
+                        thread: {},
+                        reply: {},
+                        reaction: {},
                     },
                     structure: {
-                        friend: {
-                            $role: true
-                        },
-                        foo: {
-                            $actions: [
-                                {
-                                    role: 'friend',
-                                    can: [ProtocolAction.Read, ProtocolAction.Query, ProtocolAction.Subscribe]
+                        thread: {
+                            reply: {
+                                $actions: [
+                                    {
+                                        who: 'author',
+                                        of: 'thread', // valid ancestor
+                                        can: [ProtocolAction.Create]
+                                    }
+                                ],
+                                reaction: {
+                                    $actions: [
+                                        {
+                                            who: 'author',
+                                            of: 'thread/reply', // valid immediate parent ancestor
+                                            can: [ProtocolAction.Create]
+                                        }
+                                    ]
                                 }
-                            ]
+                            }
                         }
                     }
                 };
-                const withAllReadActions = yield TestDataGenerator.generateProtocolsConfigure({
+                const protocolsConfigure = yield TestDataGenerator.generateProtocolsConfigure({
                     author: alice,
-                    protocolDefinition: protocolDefinitionWithAllReadActions,
+                    protocolDefinition,
                 });
-                const withAllReadActionsResponse = yield dwn.processMessage(alice.did, withAllReadActions.message);
-                expect(withAllReadActionsResponse.status.code).to.equal(202);
+                const reply = yield dwn.processMessage(alice.did, protocolsConfigure.message);
+                expect(reply.status.code).toBe(202);
             }));
             describe('Grant authorization', () => {
                 it('allows an external party to ProtocolsConfigure only if they have a valid grant', () => __awaiter(this, void 0, void 0, function* () {
@@ -508,7 +524,7 @@ export function testProtocolsConfigureHandler() {
                     });
                     const dataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                     const grantRecordsWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream });
-                    expect(grantRecordsWriteReply.status.code).to.equal(202);
+                    expect(grantRecordsWriteReply.status.code).toBe(202);
                     // 2. Verify Bob can perform a ProtocolsConfigure
                     const permissionGrantId = permissionGrant.recordsWrite.message.recordId;
                     const protocolsConfigure = yield TestDataGenerator.generateProtocolsConfigure({
@@ -517,7 +533,7 @@ export function testProtocolsConfigureHandler() {
                         protocolDefinition: minimalProtocolDefinition
                     });
                     const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigure.message);
-                    expect(protocolsConfigureReply.status.code).to.equal(202);
+                    expect(protocolsConfigureReply.status.code).toBe(202);
                     // 3. Verify that Mallory cannot to use Bob's permission grant to gain access to Alice's DWN
                     const malloryProtocolsQuery = yield TestDataGenerator.generateProtocolsConfigure({
                         permissionGrantId,
@@ -525,8 +541,8 @@ export function testProtocolsConfigureHandler() {
                         protocolDefinition: minimalProtocolDefinition
                     });
                     const malloryProtocolsQueryReply = yield dwn.processMessage(alice.did, malloryProtocolsQuery.message);
-                    expect(malloryProtocolsQueryReply.status.code).to.equal(401);
-                    expect(malloryProtocolsQueryReply.status.detail).to.contain(DwnErrorCode.GrantAuthorizationNotGrantedToAuthor);
+                    expect(malloryProtocolsQueryReply.status.code).toBe(401);
+                    expect(malloryProtocolsQueryReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationNotGrantedToAuthor);
                     // 4. Alice revokes Bob's grant
                     const revokeWrite = yield PermissionsProtocol.createRevocation({
                         signer: Jws.createSigner(alice),
@@ -534,7 +550,7 @@ export function testProtocolsConfigureHandler() {
                         dateRevoked: Time.getCurrentTimestamp()
                     });
                     const revokeWriteReply = yield dwn.processMessage(alice.did, revokeWrite.recordsWrite.message, { dataStream: DataStream.fromBytes(revokeWrite.permissionRevocationBytes) });
-                    expect(revokeWriteReply.status.code).to.equal(202);
+                    expect(revokeWriteReply.status.code).toBe(202);
                     // 5. Verify Bob cannot perform ProtocolsQuery with the revoked grant
                     const unauthorizedProtocolsConfigure = yield TestDataGenerator.generateProtocolsConfigure({
                         permissionGrantId,
@@ -542,8 +558,8 @@ export function testProtocolsConfigureHandler() {
                         protocolDefinition: Object.assign(Object.assign({}, minimalProtocolDefinition), { protocol: 'https://example.com/protocol/another-protocol' })
                     });
                     const unauthorizedProtocolsConfigureReply = yield dwn.processMessage(alice.did, unauthorizedProtocolsConfigure.message);
-                    expect(unauthorizedProtocolsConfigureReply.status.code).to.equal(401);
-                    expect(unauthorizedProtocolsConfigureReply.status.detail).to.contain(DwnErrorCode.GrantAuthorizationGrantRevoked);
+                    expect(unauthorizedProtocolsConfigureReply.status.code).toBe(401);
+                    expect(unauthorizedProtocolsConfigureReply.status.detail).toContain(DwnErrorCode.GrantAuthorizationGrantRevoked);
                 }));
                 it('should allow to scope a ProtocolsConfigure to a specific protocol', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
@@ -557,7 +573,7 @@ export function testProtocolsConfigureHandler() {
                     });
                     const dataStream = DataStream.fromBytes(permissionGrant.permissionGrantBytes);
                     const grantRecordsWriteReply = yield dwn.processMessage(alice.did, permissionGrant.recordsWrite.message, { dataStream });
-                    expect(grantRecordsWriteReply.status.code).to.equal(202);
+                    expect(grantRecordsWriteReply.status.code).toBe(202);
                     // Bob tries to ProtocolsConfigure to Alice's DWN for the allowed protocol
                     const protocolConfigureAllowed = yield TestDataGenerator.generateProtocolsConfigure({
                         author: bob,
@@ -565,7 +581,7 @@ export function testProtocolsConfigureHandler() {
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId
                     });
                     const protocolConfigureAllowedReply = yield dwn.processMessage(alice.did, protocolConfigureAllowed.message);
-                    expect(protocolConfigureAllowedReply.status.code).to.equal(202);
+                    expect(protocolConfigureAllowedReply.status.code).toBe(202);
                     // Bob tries to ProtocolsConfigure to Alice's DWN for a different protocol
                     const protocolConfigureNotAllowed = yield TestDataGenerator.generateProtocolsConfigure({
                         author: bob,
@@ -573,33 +589,410 @@ export function testProtocolsConfigureHandler() {
                         permissionGrantId: permissionGrant.recordsWrite.message.recordId
                     });
                     const protocolConfigureNotAllowedReply = yield dwn.processMessage(alice.did, protocolConfigureNotAllowed.message);
-                    expect(protocolConfigureNotAllowedReply.status.code).to.equal(401);
+                    expect(protocolConfigureNotAllowedReply.status.code).toBe(401);
                 }));
             });
-            describe('event log', () => {
+            describe('state index', () => {
                 it('should add event for ProtocolsConfigure', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
                     const { message } = yield TestDataGenerator.generateProtocolsConfigure({ author: alice });
                     const reply = yield dwn.processMessage(alice.did, message);
-                    expect(reply.status.code).to.equal(202);
-                    const { events } = yield eventLog.getEvents(alice.did);
-                    expect(events.length).to.equal(1);
+                    expect(reply.status.code).toBe(202);
+                    const events = yield stateIndex.getLeaves(alice.did, []);
+                    expect(events.length).toBe(1);
                     const messageCid = yield Message.getCid(message);
-                    expect(events[0]).to.equal(messageCid);
+                    expect(events[0]).toBe(messageCid);
                 }));
-                it('should delete older ProtocolsConfigure events when one is overwritten', () => __awaiter(this, void 0, void 0, function* () {
+                it('should retain all ProtocolsConfigure events for protocol versioning', () => __awaiter(this, void 0, void 0, function* () {
                     const alice = yield TestDataGenerator.generateDidKeyPersona();
                     const oldestWrite = yield TestDataGenerator.generateProtocolsConfigure({ author: alice, protocolDefinition: minimalProtocolDefinition });
                     yield Time.minimalSleep();
                     const newestWrite = yield TestDataGenerator.generateProtocolsConfigure({ author: alice, protocolDefinition: minimalProtocolDefinition });
                     let reply = yield dwn.processMessage(alice.did, oldestWrite.message);
-                    expect(reply.status.code).to.equal(202);
+                    expect(reply.status.code).toBe(202);
                     reply = yield dwn.processMessage(alice.did, newestWrite.message);
-                    expect(reply.status.code).to.equal(202);
-                    const { events } = yield eventLog.getEvents(alice.did);
-                    expect(events.length).to.equal(1);
+                    expect(reply.status.code).toBe(202);
+                    const events = yield stateIndex.getLeaves(alice.did, []);
+                    expect(events.length).toBe(2);
+                    const oldestMessageCid = yield Message.getCid(oldestWrite.message);
                     const newestMessageCid = yield Message.getCid(newestWrite.message);
-                    expect(events[0]).to.equal(newestMessageCid);
+                    expect(events).toContain(oldestMessageCid);
+                    expect(events).toContain(newestMessageCid);
+                }));
+            });
+            describe('temporal protocol versioning', () => {
+                it('should authorize records created under v1 even after re-configuring to v2 that removes the type', () => __awaiter(this, void 0, void 0, function* () {
+                    // scenario:
+                    // 1. Alice installs protocol v1 with types `post` and `comment`
+                    // 2. Alice writes a `post` record under v1
+                    // 3. Alice re-configures the protocol to v2 which removes the `comment` type
+                    // 4. Alice should still be able to read the v1 `post` record
+                    // 5. Alice should still be able to update the v1 `post` record (governed by v1 definition)
+                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    // v1: has `post` and `comment` types
+                    const protocolUri = 'https://example.com/versioned-protocol';
+                    const protocolDefinitionV1 = {
+                        protocol: protocolUri,
+                        published: true,
+                        types: {
+                            post: { schema: 'https://example.com/post', dataFormats: ['application/json'] },
+                            comment: { schema: 'https://example.com/comment', dataFormats: ['application/json'] },
+                        },
+                        structure: {
+                            post: {
+                                $actions: [{ who: 'anyone', can: [ProtocolAction.Create, ProtocolAction.Read, ProtocolAction.Update] }],
+                                comment: {
+                                    $actions: [{ who: 'anyone', can: [ProtocolAction.Create, ProtocolAction.Read] }],
+                                }
+                            }
+                        }
+                    };
+                    const configureV1 = yield TestDataGenerator.generateProtocolsConfigure({
+                        author: alice,
+                        protocolDefinition: protocolDefinitionV1,
+                    });
+                    const configureV1Reply = yield dwn.processMessage(alice.did, configureV1.message);
+                    expect(configureV1Reply.status.code).toBe(202);
+                    // write a `post` record under v1
+                    const postRecord = yield TestDataGenerator.generateRecordsWrite({
+                        author: alice,
+                        protocol: protocolUri,
+                        protocolPath: 'post',
+                        schema: 'https://example.com/post',
+                        dataFormat: 'application/json',
+                    });
+                    const postReply = yield dwn.processMessage(alice.did, postRecord.message, { dataStream: postRecord.dataStream });
+                    expect(postReply.status.code).toBe(202);
+                    // write a `comment` record under v1
+                    const commentRecord = yield TestDataGenerator.generateRecordsWrite({
+                        author: alice,
+                        protocol: protocolUri,
+                        protocolPath: 'post/comment',
+                        schema: 'https://example.com/comment',
+                        dataFormat: 'application/json',
+                        parentContextId: postRecord.message.contextId,
+                    });
+                    const commentReply = yield dwn.processMessage(alice.did, commentRecord.message, { dataStream: commentRecord.dataStream });
+                    expect(commentReply.status.code).toBe(202);
+                    yield Time.minimalSleep();
+                    // v2: removes the `comment` type entirely, changes `post` schema
+                    const protocolDefinitionV2 = {
+                        protocol: protocolUri,
+                        published: true,
+                        types: {
+                            post: { schema: 'https://example.com/post-v2', dataFormats: ['application/json'] },
+                        },
+                        structure: {
+                            post: {
+                                $actions: [{ who: 'anyone', can: [ProtocolAction.Create, ProtocolAction.Read, ProtocolAction.Update] }],
+                            }
+                        }
+                    };
+                    const configureV2 = yield TestDataGenerator.generateProtocolsConfigure({
+                        author: alice,
+                        protocolDefinition: protocolDefinitionV2,
+                    });
+                    const configureV2Reply = yield dwn.processMessage(alice.did, configureV2.message);
+                    expect(configureV2Reply.status.code).toBe(202);
+                    // read the v1 `post` record — should succeed because read authorization uses v1 definition
+                    const readPost = yield RecordsRead.create({
+                        filter: { recordId: postRecord.message.recordId },
+                        signer: Jws.createSigner(alice),
+                    });
+                    const readPostReply = yield dwn.processMessage(alice.did, readPost.message);
+                    expect(readPostReply.status.code).toBe(200);
+                    // read the v1 `comment` record — should succeed (governed by v1 definition where `comment` exists)
+                    const readComment = yield RecordsRead.create({
+                        filter: { recordId: commentRecord.message.recordId },
+                        signer: Jws.createSigner(alice),
+                    });
+                    const readCommentReply = yield dwn.processMessage(alice.did, readComment.message);
+                    expect(readCommentReply.status.code).toBe(200);
+                    // update the v1 `post` record — should succeed (governed by v1 definition)
+                    const updatedData = new TextEncoder().encode('{"title":"updated post"}');
+                    const updatePost = yield RecordsWrite.createFrom({
+                        recordsWriteMessage: postRecord.message,
+                        data: updatedData,
+                        signer: Jws.createSigner(alice),
+                    });
+                    const updatePostReply = yield dwn.processMessage(alice.did, updatePost.message, { dataStream: DataStream.fromBytes(updatedData) });
+                    expect(updatePostReply.status.code).toBe(202);
+                }));
+                it('should authorize new records against the latest protocol definition, not an older one', () => __awaiter(this, void 0, void 0, function* () {
+                    // scenario:
+                    // 1. Alice installs protocol v1 with type `post`
+                    // 2. Alice re-configures to v2 that changes `post` schema to 'https://example.com/post-v2'
+                    // 3. A new record with v1 schema should be rejected (not matching the latest definition)
+                    // 4. A new record with v2 schema should be accepted
+                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    const protocolUri = 'https://example.com/versioned-protocol-2';
+                    const protocolDefinitionV1 = {
+                        protocol: protocolUri,
+                        published: true,
+                        types: {
+                            post: { schema: 'https://example.com/post-v1', dataFormats: ['application/json'] },
+                        },
+                        structure: {
+                            post: {
+                                $actions: [{ who: 'anyone', can: [ProtocolAction.Create, ProtocolAction.Read] }],
+                            }
+                        }
+                    };
+                    const configureV1 = yield TestDataGenerator.generateProtocolsConfigure({
+                        author: alice,
+                        protocolDefinition: protocolDefinitionV1,
+                    });
+                    const configureV1Reply = yield dwn.processMessage(alice.did, configureV1.message);
+                    expect(configureV1Reply.status.code).toBe(202);
+                    yield Time.minimalSleep();
+                    // v2: changes `post` schema
+                    const protocolDefinitionV2 = {
+                        protocol: protocolUri,
+                        published: true,
+                        types: {
+                            post: { schema: 'https://example.com/post-v2', dataFormats: ['application/json'] },
+                        },
+                        structure: {
+                            post: {
+                                $actions: [{ who: 'anyone', can: [ProtocolAction.Create, ProtocolAction.Read] }],
+                            }
+                        }
+                    };
+                    const configureV2 = yield TestDataGenerator.generateProtocolsConfigure({
+                        author: alice,
+                        protocolDefinition: protocolDefinitionV2,
+                    });
+                    const configureV2Reply = yield dwn.processMessage(alice.did, configureV2.message);
+                    expect(configureV2Reply.status.code).toBe(202);
+                    // write a new record with v1 schema — should fail (latest definition requires v2 schema)
+                    const postV1 = yield TestDataGenerator.generateRecordsWrite({
+                        author: alice,
+                        protocol: protocolUri,
+                        protocolPath: 'post',
+                        schema: 'https://example.com/post-v1',
+                        dataFormat: 'application/json',
+                    });
+                    const postV1Reply = yield dwn.processMessage(alice.did, postV1.message, { dataStream: postV1.dataStream });
+                    expect(postV1Reply.status.code).toBe(400);
+                    expect(postV1Reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationInvalidSchema);
+                    // write a new record with v2 schema — should succeed
+                    const postV2 = yield TestDataGenerator.generateRecordsWrite({
+                        author: alice,
+                        protocol: protocolUri,
+                        protocolPath: 'post',
+                        schema: 'https://example.com/post-v2',
+                        dataFormat: 'application/json',
+                    });
+                    const postV2Reply = yield dwn.processMessage(alice.did, postV2.message, { dataStream: postV2.dataStream });
+                    expect(postV2Reply.status.code).toBe(202);
+                }));
+                it('should authorize deletes of v1 records after re-configuring to v2 that removes the type', () => __awaiter(this, void 0, void 0, function* () {
+                    // scenario:
+                    // 1. Alice installs protocol v1 with types `post` (with delete action) and `comment`
+                    // 2. Alice writes a `post/comment` record
+                    // 3. Alice re-configures to v2 which removes the `comment` type
+                    // 4. Alice should still be able to delete the v1 `comment` record (governed by v1 definition)
+                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    const protocolUri = 'https://example.com/versioned-protocol-3';
+                    const protocolDefinitionV1 = {
+                        protocol: protocolUri,
+                        published: true,
+                        types: {
+                            post: {},
+                            comment: {},
+                        },
+                        structure: {
+                            post: {
+                                $actions: [{ who: 'anyone', can: [ProtocolAction.Create, ProtocolAction.Read] }],
+                                comment: {
+                                    $actions: [{ who: 'anyone', can: [ProtocolAction.Create, ProtocolAction.Read, ProtocolAction.Delete] }],
+                                }
+                            }
+                        }
+                    };
+                    const configureV1 = yield TestDataGenerator.generateProtocolsConfigure({
+                        author: alice,
+                        protocolDefinition: protocolDefinitionV1,
+                    });
+                    const configureV1Reply = yield dwn.processMessage(alice.did, configureV1.message);
+                    expect(configureV1Reply.status.code).toBe(202);
+                    // write a `post` record
+                    const postRecord = yield TestDataGenerator.generateRecordsWrite({
+                        author: alice,
+                        protocol: protocolUri,
+                        protocolPath: 'post',
+                    });
+                    const postReply = yield dwn.processMessage(alice.did, postRecord.message, { dataStream: postRecord.dataStream });
+                    expect(postReply.status.code).toBe(202);
+                    // write a `comment` record under the post
+                    const commentRecord = yield TestDataGenerator.generateRecordsWrite({
+                        author: alice,
+                        protocol: protocolUri,
+                        protocolPath: 'post/comment',
+                        parentContextId: postRecord.message.contextId,
+                    });
+                    const commentReply = yield dwn.processMessage(alice.did, commentRecord.message, { dataStream: commentRecord.dataStream });
+                    expect(commentReply.status.code).toBe(202);
+                    yield Time.minimalSleep();
+                    // v2: removes the `comment` type
+                    const protocolDefinitionV2 = {
+                        protocol: protocolUri,
+                        published: true,
+                        types: {
+                            post: {},
+                        },
+                        structure: {
+                            post: {
+                                $actions: [{ who: 'anyone', can: [ProtocolAction.Create, ProtocolAction.Read] }],
+                            }
+                        }
+                    };
+                    const configureV2 = yield TestDataGenerator.generateProtocolsConfigure({
+                        author: alice,
+                        protocolDefinition: protocolDefinitionV2,
+                    });
+                    const configureV2Reply = yield dwn.processMessage(alice.did, configureV2.message);
+                    expect(configureV2Reply.status.code).toBe(202);
+                    // delete the v1 `comment` record — should succeed (governed by v1 definition)
+                    const deleteComment = yield RecordsDelete.create({
+                        signer: Jws.createSigner(alice),
+                        recordId: commentRecord.message.recordId,
+                    });
+                    const deleteReply = yield dwn.processMessage(alice.did, deleteComment.message);
+                    expect(deleteReply.status.code).toBe(202);
+                }));
+                it('should not retroactively apply v2 action rules to records created under v1', () => __awaiter(this, void 0, void 0, function* () {
+                    // scenario:
+                    // 1. Alice installs protocol v1 where anyone can create and update `post` records
+                    // 2. Bob writes a `post` to Alice's DWN
+                    // 3. Alice re-configures to v2 that restricts `post` updates to author-only (removes co-update)
+                    // 4. Bob should still be able to update his own record (governed by v1 definition which had update)
+                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    const bob = yield TestDataGenerator.generateDidKeyPersona();
+                    const protocolUri = 'https://example.com/versioned-protocol-4';
+                    const protocolDefinitionV1 = {
+                        protocol: protocolUri,
+                        published: true,
+                        types: {
+                            post: {},
+                        },
+                        structure: {
+                            post: {
+                                $actions: [{ who: 'anyone', can: [ProtocolAction.Create, ProtocolAction.Read, ProtocolAction.Update] }],
+                            }
+                        }
+                    };
+                    const configureV1 = yield TestDataGenerator.generateProtocolsConfigure({
+                        author: alice,
+                        protocolDefinition: protocolDefinitionV1,
+                    });
+                    const configureV1Reply = yield dwn.processMessage(alice.did, configureV1.message);
+                    expect(configureV1Reply.status.code).toBe(202);
+                    // Bob writes a `post` record to Alice's DWN under v1
+                    const postRecord = yield TestDataGenerator.generateRecordsWrite({
+                        author: bob,
+                        protocol: protocolUri,
+                        protocolPath: 'post',
+                    });
+                    const postReply = yield dwn.processMessage(alice.did, postRecord.message, { dataStream: postRecord.dataStream });
+                    expect(postReply.status.code).toBe(202);
+                    yield Time.minimalSleep();
+                    // v2: restricts actions (only create, no update for anyone)
+                    const protocolDefinitionV2 = {
+                        protocol: protocolUri,
+                        published: true,
+                        types: {
+                            post: {},
+                        },
+                        structure: {
+                            post: {
+                                $actions: [{ who: 'anyone', can: [ProtocolAction.Create, ProtocolAction.Read] }],
+                            }
+                        }
+                    };
+                    const configureV2 = yield TestDataGenerator.generateProtocolsConfigure({
+                        author: alice,
+                        protocolDefinition: protocolDefinitionV2,
+                    });
+                    const configureV2Reply = yield dwn.processMessage(alice.did, configureV2.message);
+                    expect(configureV2Reply.status.code).toBe(202);
+                    // Bob updates his v1 record — should succeed because v1 definition (which governs this record) allowed update
+                    const updatedData = new TextEncoder().encode('updated-post-data');
+                    const updatePost = yield RecordsWrite.createFrom({
+                        recordsWriteMessage: postRecord.message,
+                        data: updatedData,
+                        signer: Jws.createSigner(bob),
+                    });
+                    const updateReply = yield dwn.processMessage(alice.did, updatePost.message, { dataStream: DataStream.fromBytes(updatedData) });
+                    expect(updateReply.status.code).toBe(202);
+                }));
+                it('should handle out-of-order protocol configure processing correctly', () => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    // scenario:
+                    // 1. Create v1 and v2 ProtocolsConfigure messages (v2 has a newer timestamp)
+                    // 2. Process v2 first, then v1
+                    // 3. Both should be stored; query should return only v2 (the latest)
+                    // 4. A record written under v2 schema should succeed
+                    const alice = yield TestDataGenerator.generateDidKeyPersona();
+                    const protocolUri = 'https://example.com/versioned-protocol-5';
+                    const protocolDefinitionV1 = {
+                        protocol: protocolUri,
+                        published: true,
+                        types: {
+                            post: { schema: 'https://example.com/post-v1', dataFormats: ['application/json'] },
+                        },
+                        structure: {
+                            post: {
+                                $actions: [{ who: 'anyone', can: [ProtocolAction.Create, ProtocolAction.Read] }],
+                            }
+                        }
+                    };
+                    const configureV1 = yield TestDataGenerator.generateProtocolsConfigure({
+                        author: alice,
+                        protocolDefinition: protocolDefinitionV1,
+                    });
+                    yield Time.minimalSleep();
+                    const protocolDefinitionV2 = {
+                        protocol: protocolUri,
+                        published: true,
+                        types: {
+                            post: { schema: 'https://example.com/post-v2', dataFormats: ['application/json'] },
+                        },
+                        structure: {
+                            post: {
+                                $actions: [{ who: 'anyone', can: [ProtocolAction.Create, ProtocolAction.Read] }],
+                            }
+                        }
+                    };
+                    const configureV2 = yield TestDataGenerator.generateProtocolsConfigure({
+                        author: alice,
+                        protocolDefinition: protocolDefinitionV2,
+                    });
+                    // process v2 first (out of order)
+                    const configureV2Reply = yield dwn.processMessage(alice.did, configureV2.message);
+                    expect(configureV2Reply.status.code).toBe(202);
+                    // process v1 second (older, arrives later)
+                    const configureV1Reply = yield dwn.processMessage(alice.did, configureV1.message);
+                    expect(configureV1Reply.status.code).toBe(202);
+                    // query should return only v2 (the latest)
+                    const queryMessageData = yield TestDataGenerator.generateProtocolsQuery({
+                        author: alice,
+                        filter: { protocol: protocolUri }
+                    });
+                    const queryReply = yield dwn.processMessage(alice.did, queryMessageData.message);
+                    expect(queryReply.status.code).toBe(200);
+                    expect((_a = queryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(1);
+                    expect(queryReply.entries[0].descriptor.definition.types.post.schema).toBe('https://example.com/post-v2');
+                    // writing a new record with v2 schema should succeed (latest definition)
+                    const postV2 = yield TestDataGenerator.generateRecordsWrite({
+                        author: alice,
+                        protocol: protocolUri,
+                        protocolPath: 'post',
+                        schema: 'https://example.com/post-v2',
+                        dataFormat: 'application/json',
+                    });
+                    const postV2Reply = yield dwn.processMessage(alice.did, postV2.message, { dataStream: postV2.dataStream });
+                    expect(postV2Reply.status.code).toBe(202);
                 }));
             });
         });