@enbox/dwn-sdk-js 0.0.7 → 0.1.0

package/dist/esm/tests/handlers/records-write.spec.js

@@ -12,6 +12,7 @@ import recipientCanProtocol from '../vectors/protocol-definitions/recipient-can.
 import sinon from 'sinon';
 import socialMediaProtocolDefinition from '../vectors/protocol-definitions/social-media.json' with { type: 'json' };
 import threadRoleProtocolDefinition from '../vectors/protocol-definitions/thread-role.json' with { type: 'json' };
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import { ArrayUtility } from '../../src/utils/array.js';
 import { base64url } from 'multiformats/bases/base64';
 import { Cid } from '../../src/utils/cid.js';
@@ -22,18 +23,18 @@ import { GeneralJwsBuilder } from '../../src/jose/jws/general/builder.js';
 import { Jws } from '../../src/utils/jws.js';
 import { Message } from '../../src/core/message.js';
 import { PermissionConditionPublication } from '../../src/types/permission-types.js';
+import { ProtocolAuthorization } from '../../src/core/protocol-authorization.js';
 import { RecordsRead } from '../../src/interfaces/records-read.js';
 import { RecordsWrite } from '../../src/interfaces/records-write.js';
 import { RecordsWriteHandler } from '../../src/handlers/records-write.js';
-import { TestDataGenerator } from '../utils/test-data-generator.js';
-import { TestEventStream } from '../test-event-stream.js';
+import { TestEventLog } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
 import { TestStubGenerator } from '../utils/test-stub-generator.js';
 import { Time } from '../../src/utils/time.js';
 import { X25519 } from '@enbox/crypto';
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import { ContentEncryptionAlgorithm, Encryption } from '../../src/utils/encryption.js';
-import { DataStoreLevel, DwnConstant, DwnInterfaceName, DwnMethodName, KeyDerivationScheme, MessageStoreLevel, PermissionsProtocol, RecordsDelete, RecordsQuery } from '../../src/index.js';
+import { CoreProtocolRegistry, DataStoreLevel, DwnConstant, DwnInterfaceName, DwnMethodName, KeyDerivationScheme, MessageStoreLevel, PermissionsProtocol, RecordsDelete, RecordsQuery } from '../../src/index.js';
+import { defaultTestProtocolDefinition, TestDataGenerator } from '../utils/test-data-generator.js';
 import { DidKey, UniversalResolver } from '@enbox/dids';
 import { DwnError, DwnErrorCode } from '../../src/core/dwn-error.js';
 export function testRecordsWriteHandler() {
@@ -43,7 +44,7 @@ export function testRecordsWriteHandler() {
         let dataStore;
         let resumableTaskStore;
         let stateIndex;
-        let eventStream;
+        let eventLog;
         let dwn;
         beforeEach(() => {
             sinon.restore();
@@ -58,8 +59,9 @@ export function testRecordsWriteHandler() {
                 dataStore = stores.dataStore;
                 resumableTaskStore = stores.resumableTaskStore;
                 stateIndex = stores.stateIndex;
-                eventStream = TestEventStream.get();
-                dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
+                eventLog = TestEventLog.get();
+                eventLog = TestEventLog.get();
+                dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventLog, resumableTaskStore });
             });
             beforeEach(async () => {
                 // clean up before each test rather than after so that a test does not depend on other tests to do the clean up
@@ -71,26 +73,38 @@ export function testRecordsWriteHandler() {
             afterAll(async () => {
                 await dwn.close();
             });
-            it('should call preProcessingForCoreRecordsWrite after authorization and before storage', async () => {
-                // We create spy or stub for authorization, preProcessingForCoreRecordsWrite and processMessageWithDataStream methods
-                // When we trigger a failure for `preProcessingForCoreRecordsWrite`, we expect the `processMessageWithDataStream` method to not be called
-                const authorizationSpy = sinon.spy(RecordsWriteHandler, 'authorizeRecordsWrite');
-                const processDataStreamSpy = sinon.spy(RecordsWriteHandler.prototype, 'processMessageWithDataStream');
-                const preProcessingForCoreRecordsWriteSpy = sinon.stub(RecordsWriteHandler.prototype, 'preProcessingForCoreRecordsWrite')
-                    .throws(new DwnError(DwnErrorCode.PermissionsProtocolValidateScopeProtocolMismatch, 'Some Error'));
+            it('should dispatch preProcessWrite hook via CoreProtocolRegistry and abort before storage on failure', async () => {
+                // Register a mock core protocol whose preProcessWrite hook throws.
+                // Verify that authorization completes but processMessageWithDataStream is never reached.
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                const authorizationSpy = sinon.spy(RecordsWriteHandler.prototype, 'authorizeRecordsWrite');
+                const processDataStreamSpy = sinon.spy(RecordsWriteHandler.prototype, 'processMessageWithDataStream');
+                // Register a mock core protocol that matches the default test protocol's URI
+                const coreProtocols = dwn._coreProtocols;
+                const protocolUri = defaultTestProtocolDefinition.protocol;
+                coreProtocols.register({
+                    uri: protocolUri,
+                    definition: defaultTestProtocolDefinition,
+                    preProcessWrite: () => {
+                        throw new DwnError(DwnErrorCode.PermissionsProtocolValidateScopeProtocolMismatch, 'mock pre-process failure');
+                    },
+                    mapErrorToStatusCode: (code) => {
+                        return code.startsWith('PermissionsProtocolValidate') ? 400 : undefined;
+                    },
+                });
                 const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
                 const reply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(reply.status.code).toBe(400);
-                // expect that authorization and preProcessingForCoreRecordsWrite are both called once
                 expect(authorizationSpy.calledOnce).toBe(true);
-                expect(preProcessingForCoreRecordsWriteSpy.calledOnce).toBe(true);
-                // expect that processMessageWithDataStream is NOT called since preProcessingForCoreRecordsWrite failed before reaching it
                 expect(processDataStreamSpy.called).toBe(false);
+                // Cleanup: unregister the mock so it doesn't affect other tests
+                coreProtocols._protocols.delete(protocolUri);
             });
             it('should only be able to overwrite existing record if new record has a later `messageTimestamp` value', async () => {
                 // write a message into DB
                 const author = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, author);
                 const data1 = new TextEncoder().encode('data1');
                 const recordsWriteMessageData = await TestDataGenerator.generateRecordsWrite({ author, data: data1 });
                 const tenant = author.did;
@@ -137,12 +151,13 @@ export function testRecordsWriteHandler() {
                 // start by writing an originating message
                 const author = await TestDataGenerator.generatePersona();
                 const tenant = author.did;
+                // setting up a stub DID resolver
+                TestStubGenerator.stubDidResolver(didResolver, [author]);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, author);
                 const originatingMessageData = await TestDataGenerator.generateRecordsWrite({
                     author,
                     data: Encoder.stringToBytes('unused')
                 });
-                // setting up a stub DID resolver
-                TestStubGenerator.stubDidResolver(didResolver, [author]);
                 const originatingMessageWriteReply = await dwn.processMessage(tenant, originatingMessageData.message, { dataStream: originatingMessageData.dataStream });
                 expect(originatingMessageWriteReply.status.code).toBe(202);
                 // generate two new RecordsWrite messages with the same `messageTimestamp` value
@@ -204,10 +219,12 @@ export function testRecordsWriteHandler() {
                 expect(thirdRecordsQueryReply.entries[0].descriptor.dataCid)
                     .toBe(newerWrite.message.descriptor.dataCid); // expecting unchanged
             });
-            it('#690 - should allow data format of a flat-space record to be updated to any value', async () => {
-                const initialWriteData = await TestDataGenerator.generateRecordsWrite();
-                const tenant = initialWriteData.author.did;
-                TestStubGenerator.stubDidResolver(didResolver, [initialWriteData.author]);
+            it('#690 - should allow data format of a record to be updated to any value', async () => {
+                const author = await TestDataGenerator.generatePersona();
+                const tenant = author.did;
+                TestStubGenerator.stubDidResolver(didResolver, [author]);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, author);
+                const initialWriteData = await TestDataGenerator.generateRecordsWrite({ author });
                 const initialWriteReply = await dwn.processMessage(tenant, initialWriteData.message, { dataStream: initialWriteData.dataStream });
                 expect(initialWriteReply.status.code).toBe(202);
                 const newDataFormat = 'any-new-data-format';
@@ -215,7 +232,7 @@ export function testRecordsWriteHandler() {
                 const updateWrite = await RecordsWrite.createFrom({
                     recordsWriteMessage: initialWriteData.message,
                     dataFormat: newDataFormat,
-                    signer: Jws.createSigner(initialWriteData.author),
+                    signer: Jws.createSigner(author),
                     data: newDataBytes
                 });
                 const newDataStream = DataStream.fromBytes(newDataBytes);
@@ -224,16 +241,18 @@ export function testRecordsWriteHandler() {
                 // verify the data format of the record is updated
                 const recordsRead = await RecordsRead.create({
                     filter: { recordId: initialWriteData.message.recordId },
-                    signer: Jws.createSigner(initialWriteData.author),
+                    signer: Jws.createSigner(author),
                 });
                 const recordsReadReply = await dwn.processMessage(tenant, recordsRead.message);
                 expect(recordsReadReply.status.code).toBe(200);
                 expect(recordsReadReply.entry.recordsWrite?.descriptor.dataFormat).toBe(newDataFormat);
             });
             it('should not allow changes to immutable properties', async () => {
-                const initialWriteData = await TestDataGenerator.generateRecordsWrite();
-                const tenant = initialWriteData.author.did;
-                TestStubGenerator.stubDidResolver(didResolver, [initialWriteData.author]);
+                const author = await TestDataGenerator.generatePersona();
+                const tenant = author.did;
+                TestStubGenerator.stubDidResolver(didResolver, [author]);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, author);
+                const initialWriteData = await TestDataGenerator.generateRecordsWrite({ author });
                 const initialWriteReply = await dwn.processMessage(tenant, initialWriteData.message, { dataStream: initialWriteData.dataStream });
                 expect(initialWriteReply.status.code).toBe(202);
                 const recordId = initialWriteData.message.recordId;
@@ -241,7 +260,7 @@ export function testRecordsWriteHandler() {
                 const schema = initialWriteData.message.descriptor.schema;
                 // dateCreated test
                 let childMessageData = await TestDataGenerator.generateRecordsWrite({
-                    author: initialWriteData.author,
+                    author,
                     recordId,
                     schema,
                     dateCreated: Time.getCurrentTimestamp(), // should not be allowed to be modified
@@ -252,7 +271,7 @@ export function testRecordsWriteHandler() {
                 expect(reply.status.detail).toContain('dateCreated is an immutable property');
                 // schema test
                 childMessageData = await TestDataGenerator.generateRecordsWrite({
-                    author: initialWriteData.author,
+                    author,
                     recordId,
                     schema: 'should-not-allowed-to-be-modified',
                     dateCreated,
@@ -263,11 +282,14 @@ export function testRecordsWriteHandler() {
                 expect(reply.status.detail).toContain('schema is an immutable property');
             });
             it('should inherit data from previous RecordsWrite given a matching dataCid and dataSize and no dataStream', async () => {
-                const { message, author, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
-                    published: false
-                });
+                const author = await TestDataGenerator.generatePersona();
                 const tenant = author.did;
                 TestStubGenerator.stubDidResolver(didResolver, [author]);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, author);
+                const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
+                    author,
+                    published: false
+                });
                 const initialWriteReply = await dwn.processMessage(tenant, message, { dataStream });
                 expect(initialWriteReply.status.code).toBe(202);
                 const write2 = await RecordsWrite.createFrom({
@@ -292,6 +314,7 @@ export function testRecordsWriteHandler() {
                 //scenario:  you have an initial write without the data and a subsequent write with data to be able to write.
                 // the DWN should accept an initial write without data, however prevent the user from querying for it until it's updated.
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const { recordsWrite } = await TestDataGenerator.generateRecordsWrite({ author: alice });
                 // simulate synchronize of pruned initial `RecordsWrite`
                 const reply = await dwn.processMessage(alice.did, recordsWrite.message);
@@ -324,6 +347,7 @@ export function testRecordsWriteHandler() {
                 //scenario:  you have an initial write without the data and a subsequent write with data to be able to write.
                 // the DWN should accept an initial write without data, however prevent the user from querying for it until it's updated.
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // write a record into the dwn
                 const { recordsWrite, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({ author: alice });
                 const reply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
@@ -356,12 +380,15 @@ export function testRecordsWriteHandler() {
             });
             describe('should inherit data from previous RecordsWrite given a matching dataCid and dataSize and no dataStream', () => {
                 it('with data above the threshold for encodedData', async () => {
-                    const { message, author, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
+                    const author = await TestDataGenerator.generatePersona();
+                    const tenant = author.did;
+                    TestStubGenerator.stubDidResolver(didResolver, [author]);
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, author);
+                    const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
+                        author,
                         data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1),
                         published: false
                     });
-                    const tenant = author.did;
-                    TestStubGenerator.stubDidResolver(didResolver, [author]);
                     const initialWriteReply = await dwn.processMessage(tenant, message, { dataStream });
                     expect(initialWriteReply.status.code).toBe(202);
                     const write2 = await RecordsWrite.createFrom({
@@ -383,12 +410,15 @@ export function testRecordsWriteHandler() {
                     expect(data).toEqual(dataBytes);
                 });
                 it('with data equal to or below the threshold for encodedData', async () => {
-                    const { message, author, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
+                    const author = await TestDataGenerator.generatePersona();
+                    const tenant = author.did;
+                    TestStubGenerator.stubDidResolver(didResolver, [author]);
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, author);
+                    const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
+                        author,
                         data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded),
                         published: false
                     });
-                    const tenant = author.did;
-                    TestStubGenerator.stubDidResolver(didResolver, [author]);
                     const initialWriteReply = await dwn.processMessage(tenant, message, { dataStream });
                     expect(initialWriteReply.status.code).toBe(202);
                     const write2 = await RecordsWrite.createFrom({
@@ -413,24 +443,27 @@ export function testRecordsWriteHandler() {
             describe('should return 400 if actual data size mismatches with `dataSize` in descriptor', () => {
                 it('with dataStream and `dataSize` larger than encodedData threshold', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1)
                     });
-                    // replace the dataSize to simulate mismatch, will need to generate `recordId` and `authorization` property again
+                    // replace the dataSize to simulate mismatch, will need to generate `recordId`, `contextId`, and `authorization` property again
                     message.descriptor.dataSize = DwnConstant.maxDataSizeAllowedToBeEncoded + 100;
                     const descriptorCid = await Cid.computeCid(message.descriptor);
                     const recordId = await RecordsWrite.getEntryId(alice.did, message.descriptor);
+                    const contextId = recordId; // contextId is deterministic: for root records it equals recordId
                     const signer = Jws.createSigner(alice);
                     const signature = await RecordsWrite.createSignerSignature({
                         recordId,
-                        contextId: message.contextId,
+                        contextId,
                         descriptorCid,
                         attestation: message.attestation,
                         encryption: message.encryption,
                         signer
                     });
                     message.recordId = recordId;
+                    message.contextId = contextId;
                     message.authorization = { signature };
                     const reply = await dwn.processMessage(alice.did, message, { dataStream });
                     expect(reply.status.code).toBe(400);
@@ -438,24 +471,27 @@ export function testRecordsWriteHandler() {
                 });
                 it('with only `dataSize` larger than encodedData threshold', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded)
                     });
-                    // replace the dataSize to simulate mismatch, will need to generate `recordId` and `authorization` property again
+                    // replace the dataSize to simulate mismatch, will need to generate `recordId`, `contextId`, and `authorization` property again
                     message.descriptor.dataSize = DwnConstant.maxDataSizeAllowedToBeEncoded + 100;
                     const descriptorCid = await Cid.computeCid(message.descriptor);
                     const recordId = await RecordsWrite.getEntryId(alice.did, message.descriptor);
+                    const contextId = recordId; // contextId is deterministic: for root records it equals recordId
                     const signer = Jws.createSigner(alice);
                     const signature = await RecordsWrite.createSignerSignature({
                         recordId,
-                        contextId: message.contextId,
+                        contextId,
                         descriptorCid,
                         attestation: message.attestation,
                         encryption: message.encryption,
                         signer
                     });
                     message.recordId = recordId;
+                    message.contextId = contextId;
                     message.authorization = { signature };
                     const reply = await dwn.processMessage(alice.did, message, { dataStream });
                     expect(reply.status.code).toBe(400);
@@ -463,24 +499,27 @@ export function testRecordsWriteHandler() {
                 });
                 it('with only dataStream larger than encodedData threshold', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
                         data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1)
                     });
-                    // replace the dataSize to simulate mismatch, will need to generate `recordId` and `authorization` property again
+                    // replace the dataSize to simulate mismatch, will need to generate `recordId`, `contextId`, and `authorization` property again
                     message.descriptor.dataSize = 1;
                     const descriptorCid = await Cid.computeCid(message.descriptor);
                     const recordId = await RecordsWrite.getEntryId(alice.did, message.descriptor);
+                    const contextId = recordId; // contextId is deterministic: for root records it equals recordId
                     const signer = Jws.createSigner(alice);
                     const signature = await RecordsWrite.createSignerSignature({
                         recordId,
-                        contextId: message.contextId,
+                        contextId,
                         descriptorCid,
                         attestation: message.attestation,
                         encryption: message.encryption,
                         signer
                     });
                     message.recordId = recordId;
+                    message.contextId = contextId;
                     message.authorization = { signature };
                     const reply = await dwn.processMessage(alice.did, message, { dataStream });
                     expect(reply.status.code).toBe(400);
@@ -488,23 +527,26 @@ export function testRecordsWriteHandler() {
                 });
                 it('with both `dataSize` and dataStream below than encodedData threshold', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({
                         author: alice
                     });
-                    // replace the dataSize to simulate mismatch, will need to generate `recordId` and `authorization` property again
+                    // replace the dataSize to simulate mismatch, will need to generate `recordId`, `contextId`, and `authorization` property again
                     message.descriptor.dataSize = 1;
                     const descriptorCid = await Cid.computeCid(message.descriptor);
                     const recordId = await RecordsWrite.getEntryId(alice.did, message.descriptor);
+                    const contextId = recordId; // contextId is deterministic: for root records it equals recordId
                     const signer = Jws.createSigner(alice);
                     const signature = await RecordsWrite.createSignerSignature({
                         recordId,
-                        contextId: message.contextId,
+                        contextId,
                         descriptorCid,
                         attestation: message.attestation,
                         encryption: message.encryption,
                         signer
                     });
                     message.recordId = recordId;
+                    message.contextId = contextId;
                     message.authorization = { signature };
                     const reply = await dwn.processMessage(alice.did, message, { dataStream });
                     expect(reply.status.code).toBe(400);
@@ -513,6 +555,7 @@ export function testRecordsWriteHandler() {
             });
             it('should return 400 for data CID mismatch with both dataStream and `dataSize` larger than encodedData threshold', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const { message } = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1)
@@ -524,6 +567,7 @@ export function testRecordsWriteHandler() {
             });
             it('should return 400 for data CID mismatch with `dataSize` larger than encodedData threshold', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const { message } = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1)
@@ -535,6 +579,7 @@ export function testRecordsWriteHandler() {
             });
             it('should return 400 for data CID mismatch with dataStream larger than encodedData threshold', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const { message } = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded)
@@ -546,6 +591,7 @@ export function testRecordsWriteHandler() {
             });
             it('should return 400 for data CID mismatch with both dataStream and `dataSize` below than encodedData threshold', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const { message } = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded)
@@ -557,6 +603,7 @@ export function testRecordsWriteHandler() {
             });
             it('#359 - should not allow access of data by referencing a different`dataCid` in "modify" `RecordsWrite` with large data', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // alice writes a record
                 const dataString = TestDataGenerator.randomString(DwnConstant.maxDataSizeAllowedToBeEncoded + 1);
                 const dataSize = dataString.length;
@@ -602,6 +649,7 @@ export function testRecordsWriteHandler() {
             });
             it('#359 - should not allow access of data by referencing a different`dataCid` in "modify" `RecordsWrite`', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // alice writes a record
                 const dataString = TestDataGenerator.randomString(DwnConstant.maxDataSizeAllowedToBeEncoded);
                 const dataSize = dataString.length;
@@ -650,14 +698,17 @@ export function testRecordsWriteHandler() {
                     it('should accept a published RecordsWrite using createFrom() without specifying `data` or `datePublished`', async () => {
                         const data = Encoder.stringToBytes('test');
                         const encodedData = Encoder.bytesToBase64Url(data);
+                        const author = await TestDataGenerator.generatePersona();
+                        const tenant = author.did;
+                        // setting up a stub DID resolver
+                        TestStubGenerator.stubDidResolver(didResolver, [author]);
+                        await TestDataGenerator.installDefaultTestProtocol(dwn, author);
                         // new record
-                        const { message, author, recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
+                        const { message, recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
+                            author,
                             published: false,
                             data,
                         });
-                        const tenant = author.did;
-                        // setting up a stub DID resolver
-                        TestStubGenerator.stubDidResolver(didResolver, [author]);
                         const reply = await dwn.processMessage(tenant, message, { dataStream });
                         expect(reply.status.code).toBe(202);
                         // changing the `published` property
@@ -681,12 +732,15 @@ export function testRecordsWriteHandler() {
                         expect(recordsQueryReply.entries[0].encodedData).toBe(encodedData);
                     });
                     it('should inherit parent published state when using createFrom() to create RecordsWrite', async () => {
-                        const { message, author, recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
-                            published: true
-                        });
+                        const author = await TestDataGenerator.generatePersona();
                         const tenant = author.did;
                         // setting up a stub DID resolver
                         TestStubGenerator.stubDidResolver(didResolver, [author]);
+                        await TestDataGenerator.installDefaultTestProtocol(dwn, author);
+                        const { message, recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
+                            author,
+                            published: true
+                        });
                         const reply = await dwn.processMessage(tenant, message, { dataStream });
                         expect(reply.status.code).toBe(202);
                         const newData = Encoder.stringToBytes('new data');
@@ -719,6 +773,7 @@ export function testRecordsWriteHandler() {
                     });
                     const tenant = author.did;
                     TestStubGenerator.stubDidResolver(didResolver, [author]);
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, author);
                     const reply = await dwn.processMessage(tenant, message, { dataStream });
                     expect(reply.status.code).toBe(400);
                     expect(reply.status.detail).toContain(DwnErrorCode.RecordsWriteGetInitialWriteNotFound);
@@ -730,6 +785,7 @@ export function testRecordsWriteHandler() {
                     });
                     const tenant = author.did;
                     TestStubGenerator.stubDidResolver(didResolver, [author]);
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, author);
                     const reply = await dwn.processMessage(tenant, message, { dataStream });
                     expect(reply.status.code).toBe(400);
                     expect(reply.status.detail).toContain('must match dateCreated');
@@ -745,18 +801,22 @@ export function testRecordsWriteHandler() {
                 });
                 describe('state index', () => {
                     it('should add an entry to the state index on initial write', async () => {
-                        const { message, author, dataStream } = await TestDataGenerator.generateRecordsWrite();
+                        const author = await TestDataGenerator.generatePersona();
                         TestStubGenerator.stubDidResolver(didResolver, [author]);
+                        await TestDataGenerator.installDefaultTestProtocol(dwn, author);
+                        const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author });
                         const reply = await dwn.processMessage(author.did, message, { dataStream });
                         expect(reply.status.code).toBe(202);
                         const events = await stateIndex.getLeaves(author.did, []);
-                        expect(events.length).toBe(1);
+                        expect(events.length).toBe(2); // 1 for protocol configure + 1 for record write
                         const messageCid = await Message.getCid(message);
-                        expect(events[0]).toBe(messageCid);
+                        expect(events).toContain(messageCid);
                     });
                     it('should only keep first write and latest write when subsequent writes happen', async () => {
-                        const { message, author, dataStream, recordsWrite } = await TestDataGenerator.generateRecordsWrite();
+                        const author = await TestDataGenerator.generatePersona();
                         TestStubGenerator.stubDidResolver(didResolver, [author]);
+                        await TestDataGenerator.installDefaultTestProtocol(dwn, author);
+                        const { message, dataStream, recordsWrite } = await TestDataGenerator.generateRecordsWrite({ author });
                         const reply = await dwn.processMessage(author.did, message, { dataStream });
                         expect(reply.status.code).toBe(202);
                         const newWrite = await RecordsWrite.createFrom({
@@ -774,7 +834,7 @@ export function testRecordsWriteHandler() {
                         const newestWriteReply = await dwn.processMessage(author.did, newestWrite.message);
                         expect(newestWriteReply.status.code).toBe(202);
                         const events = await stateIndex.getLeaves(author.did, []);
-                        expect(events.length).toBe(2);
+                        expect(events.length).toBe(3); // 1 for protocol configure + 2 for record writes (first + latest)
                         const deletedMessageCid = await Message.getCid(newWrite.message);
                         for (const messageCid of events) {
                             if (messageCid === deletedMessageCid) {
@@ -2463,7 +2523,9 @@ export function testRecordsWriteHandler() {
                     });
                     // replace valid `encryption` property with a mismatching one — mutate the iv to cause CID mismatch
                     message.encryption.iv = Encoder.stringToBase64Url('any value which will result in a different CID');
-                    const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, stateIndex, eventStream);
+                    const recordsWriteHandler = new RecordsWriteHandler({
+                        didResolver, messageStore, dataStore, stateIndex, coreProtocols: new CoreProtocolRegistry(), eventLog,
+                    });
                     const writeReply = await recordsWriteHandler.handle({ tenant: alice.did, message, dataStream: dataStream });
                     expect(writeReply.status.code).toBe(400);
                     expect(writeReply.status.detail).toContain(DwnErrorCode.RecordsWriteValidateIntegrityEncryptionCidMismatch);
@@ -2505,6 +2567,7 @@ export function testRecordsWriteHandler() {
                 it('#359 - should not allow access of data by referencing `dataCid` in protocol authorized `RecordsWrite`', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
                     const bob = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     // alice writes a private record
                     const dataString = TestDataGenerator.randomString(DwnConstant.maxDataSizeAllowedToBeEncoded);
                     const dataSize = dataString.length;
@@ -2586,6 +2649,7 @@ export function testRecordsWriteHandler() {
                 it('#359 - should not allow access of data by referencing `dataCid` in protocol authorized `RecordsWrite` with large data', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
                     const bob = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     // alice writes a private record
                     const dataString = TestDataGenerator.randomString(DwnConstant.maxDataSizeAllowedToBeEncoded + 1);
                     const dataSize = dataString.length;
@@ -3394,6 +3458,7 @@ export function testRecordsWriteHandler() {
                 // Pruned RecordsWrite
                 // Data large enough to use the DataStore
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const data = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1);
                 const prunedRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -3419,6 +3484,7 @@ export function testRecordsWriteHandler() {
                 // Pruned RecordsWrite
                 // Data that would be encoded within the message
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const data = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded);
                 const prunedRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -3439,12 +3505,15 @@ export function testRecordsWriteHandler() {
                 expect(recordsWriteReply.status.detail).toContain(DwnErrorCode.RecordsWriteMissingEncodedDataInPrevious);
             });
             it('should return 400 if attempting a write after a delete', async () => {
-                const { message, author, dataStream } = await TestDataGenerator.generateRecordsWrite({
+                const author = await TestDataGenerator.generatePersona();
+                const tenant = author.did;
+                TestStubGenerator.stubDidResolver(didResolver, [author]);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, author);
+                const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({
+                    author,
                     data: TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded),
                     published: false
                 });
-                const tenant = author.did;
-                TestStubGenerator.stubDidResolver(didResolver, [author]);
                 const initialWriteReply = await dwn.processMessage(tenant, message, { dataStream });
                 expect(initialWriteReply.status.code).toBe(202);
                 const recordsDelete = await RecordsDelete.create({
@@ -3466,6 +3535,8 @@ export function testRecordsWriteHandler() {
             it('should not allow referencing data across tenants', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
                 const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, bob);
                 const data = Encoder.stringToBytes('test');
                 const dataCid = await Cid.computeDagPbCidFromBytes(data);
                 const encodedData = Encoder.bytesToBase64Url(data);
@@ -3512,6 +3583,7 @@ export function testRecordsWriteHandler() {
             describe('encodedData threshold', () => {
                 it('should call cloneAndAddEncodedData if dataSize is less than or equal to the threshold', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     const dataBytes = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded);
                     const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice, data: dataBytes });
                     const processEncoded = sinon.spy(RecordsWriteHandler.prototype, 'cloneAndAddEncodedData');
@@ -3521,6 +3593,7 @@ export function testRecordsWriteHandler() {
                 });
                 it('should not call cloneAndAddEncodedData if dataSize is greater than the threshold', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     const dataBytes = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1);
                     const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice, data: dataBytes });
                     const processEncoded = sinon.spy(RecordsWriteHandler.prototype, 'cloneAndAddEncodedData');
@@ -3530,6 +3603,7 @@ export function testRecordsWriteHandler() {
                 });
                 it('should have encodedData field if dataSize is less than or equal to the threshold', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     const dataBytes = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded);
                     const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice, data: dataBytes });
                     const writeMessage = await dwn.processMessage(alice.did, message, { dataStream });
@@ -3540,6 +3614,7 @@ export function testRecordsWriteHandler() {
                 });
                 it('should not have encodedData field if dataSize greater than threshold', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     const dataBytes = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1);
                     const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice, data: dataBytes });
                     const writeMessage = await dwn.processMessage(alice.did, message, { dataStream });
@@ -3550,6 +3625,7 @@ export function testRecordsWriteHandler() {
                 });
                 it('should retain original RecordsWrite message but without the encodedData if data is under threshold', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     const dataBytes = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded);
                     const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice, data: dataBytes });
                     const writeMessage = await dwn.processMessage(alice.did, message, { dataStream });
@@ -3588,7 +3664,9 @@ export function testRecordsWriteHandler() {
                 const didResolver = TestStubGenerator.createDidResolverStub(author);
                 const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
                 const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, stateIndex, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler({
+                    didResolver, messageStore: messageStoreStub, dataStore: dataStoreStub, stateIndex, coreProtocols: new CoreProtocolRegistry(), eventLog,
+                });
                 const reply = await recordsWriteHandler.handle({ tenant, message, dataStream: dataStream });
                 expect(reply.status.code).toBe(400);
                 expect(reply.status.detail).toContain('does not match recordId in authorization');
@@ -3607,7 +3685,9 @@ export function testRecordsWriteHandler() {
                 const didResolver = sinon.createStubInstance(UniversalResolver);
                 const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
                 const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, stateIndex, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler({
+                    didResolver, messageStore: messageStoreStub, dataStore: dataStoreStub, stateIndex, coreProtocols: new CoreProtocolRegistry(), eventLog,
+                });
                 const reply = await recordsWriteHandler.handle({ tenant, message, dataStream: dataStream });
                 expect(reply.status.code).toBe(400);
                 expect(reply.status.detail).toContain('does not match contextId in authorization');
@@ -3621,7 +3701,11 @@ export function testRecordsWriteHandler() {
                 const didResolver = TestStubGenerator.createDidResolverStub(mismatchingPersona);
                 const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
                 const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, stateIndex, eventStream);
+                // stub protocol validation so the handler reaches authentication/authorization
+                sinon.stub(ProtocolAuthorization, 'validateReferentialIntegrity').resolves();
+                const recordsWriteHandler = new RecordsWriteHandler({
+                    didResolver, messageStore: messageStoreStub, dataStore: dataStoreStub, stateIndex, coreProtocols: new CoreProtocolRegistry(), eventLog,
+                });
                 const reply = await recordsWriteHandler.handle({ tenant, message, dataStream: dataStream });
                 expect(reply.status.code).toBe(401);
             });
@@ -3632,7 +3716,11 @@ export function testRecordsWriteHandler() {
                 const didResolver = TestStubGenerator.createDidResolverStub(author);
                 const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
                 const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, stateIndex, eventStream);
+                // stub protocol validation so the handler reaches authentication/authorization
+                sinon.stub(ProtocolAuthorization, 'validateReferentialIntegrity').resolves();
+                const recordsWriteHandler = new RecordsWriteHandler({
+                    didResolver, messageStore: messageStoreStub, dataStore: dataStoreStub, stateIndex, coreProtocols: new CoreProtocolRegistry(), eventLog,
+                });
                 const tenant = await (await TestDataGenerator.generatePersona()).did; // unauthorized tenant
                 const reply = await recordsWriteHandler.handle({ tenant, message, dataStream: dataStream });
                 expect(reply.status.code).toBe(401);
@@ -3658,7 +3746,9 @@ export function testRecordsWriteHandler() {
                 const didResolver = TestStubGenerator.createDidResolverStub(author);
                 const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
                 const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStoreStub, dataStoreStub, stateIndex, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler({
+                    didResolver, messageStore: messageStoreStub, dataStore: dataStoreStub, stateIndex, coreProtocols: new CoreProtocolRegistry(), eventLog,
+                });
                 const reply = await recordsWriteHandler.handle({ tenant, message, dataStream: dataStream });
                 expect(reply.status.code).toBe(400);
                 expect(reply.status.detail).toContain(`Only 'descriptorCid' is allowed in attestation payload`);
@@ -3667,7 +3757,9 @@ export function testRecordsWriteHandler() {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
                 const bob = await TestDataGenerator.generateDidKeyPersona();
                 const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [alice, bob] });
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, stateIndex, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler({
+                    didResolver, messageStore, dataStore, stateIndex, coreProtocols: new CoreProtocolRegistry(), eventLog,
+                });
                 const writeReply = await recordsWriteHandler.handle({ tenant: alice.did, message, dataStream: dataStream });
                 expect(writeReply.status.code).toBe(400);
                 expect(writeReply.status.detail).toContain('implementation only supports 1 attester');
@@ -3678,7 +3770,9 @@ export function testRecordsWriteHandler() {
                 // create another write and use its `attestation` value instead, that `attestation` will point to an entirely different `descriptorCid`
                 const anotherWrite = await TestDataGenerator.generateRecordsWrite({ attesters: [alice] });
                 message.attestation = anotherWrite.message.attestation;
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, stateIndex, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler({
+                    didResolver, messageStore, dataStore, stateIndex, coreProtocols: new CoreProtocolRegistry(), eventLog,
+                });
                 const writeReply = await recordsWriteHandler.handle({ tenant: alice.did, message, dataStream: dataStream });
                 expect(writeReply.status.code).toBe(400);
                 expect(writeReply.status.detail).toContain('does not match expected descriptorCid');
@@ -3691,7 +3785,9 @@ export function testRecordsWriteHandler() {
                 const descriptorCid = await Cid.computeCid(message.descriptor);
                 const attestationNotReferencedByAuthorization = await RecordsWrite['createAttestation'](descriptorCid, Jws.createSigners([bob]));
                 message.attestation = attestationNotReferencedByAuthorization;
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, stateIndex, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler({
+                    didResolver, messageStore, dataStore, stateIndex, coreProtocols: new CoreProtocolRegistry(), eventLog,
+                });
                 const writeReply = await recordsWriteHandler.handle({ tenant: alice.did, message, dataStream: dataStream });
                 expect(writeReply.status.code).toBe(400);
                 expect(writeReply.status.detail).toContain('does not match attestationCid');
@@ -3709,7 +3805,15 @@ export function testRecordsWriteHandler() {
                 const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
                 messageStoreStub.query.resolves({ messages: [initialWriteMessage] });
                 const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-                const recordsWriteHandler = new RecordsWriteHandler(didResolverStub, messageStoreStub, dataStoreStub, stateIndex, eventStream);
+                // stub protocol validation so the handler reaches the process methods
+                sinon.stub(ProtocolAuthorization, 'validateReferentialIntegrity').resolves();
+                const recordsWriteHandler = new RecordsWriteHandler({
+                    didResolver: didResolverStub, messageStore: messageStoreStub,
+                    dataStore: dataStoreStub, stateIndex, coreProtocols: new CoreProtocolRegistry(), eventLog,
+                });
+                // stub the squash backstop so the stubbed messageStore (which returns RecordsWrite messages
+                // for all queries) does not interfere with the flow reaching the process methods
+                sinon.stub(recordsWriteHandler, 'enforceSquashBackstop').resolves();
                 // simulate throwing unexpected error
                 sinon.stub(recordsWriteHandler, 'processMessageWithoutDataStream').throws(new Error('an unknown error in recordsWriteHandler.processMessageWithoutDataStream()'));
                 sinon.stub(recordsWriteHandler, 'processMessageWithDataStream').throws(new Error('an unknown error in recordsWriteHandler.processMessageWithDataStream()'));