@enbox/dwn-sdk-js 0.0.6 → 0.0.8

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

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import sinon from 'sinon';
 import { beforeEach, describe, expect, it } from 'bun:test';
 import { DwnErrorCode } from '../../src/core/dwn-error.js';
@@ -20,74 +11,91 @@ describe('RecordsWrite', () => {
         sinon.restore();
     });
     describe('create()', () => {
-        it('should be able to create and authorize a valid RecordsWrite message', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should be able to create and authorize a valid RecordsWrite message', async () => {
             // testing `create()` first
-            const alice = yield TestDataGenerator.generatePersona();
+            const alice = await TestDataGenerator.generatePersona();
             const options = {
                 data: TestDataGenerator.randomBytes(10),
                 dataFormat: 'application/json',
                 dateCreated: '2022-10-14T10:20:30.405060Z',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
                 signer: Jws.createSigner(alice)
             };
-            const recordsWrite = yield RecordsWrite.create(options);
+            const recordsWrite = await RecordsWrite.create(options);
             const message = recordsWrite.message;
             expect(message.authorization).toBeDefined();
             expect(message.descriptor.dataFormat).toBe(options.dataFormat);
             expect(message.descriptor.dateCreated).toBe(options.dateCreated);
             expect(message.recordId).toBe(options.recordId);
             const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
-            yield RecordsWriteHandler['authorizeRecordsWrite'](alice.did, recordsWrite, messageStoreStub);
-        }));
-        it('should include permissionGrantId in the descriptor when provided', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
-            const grantId = yield TestDataGenerator.randomCborSha256Cid();
-            const recordsWrite = yield RecordsWrite.create({
+            // authorizeRecordsWrite is a private instance method; invoke via bracket notation on an instance
+            const handler = new RecordsWriteHandler({
+                didResolver: {},
+                messageStore: messageStoreStub,
+                dataStore: {},
+                stateIndex: {},
+            });
+            await handler.authorizeRecordsWrite(alice.did, recordsWrite, messageStoreStub);
+        });
+        it('should include permissionGrantId in the descriptor when provided', async () => {
+            const alice = await TestDataGenerator.generatePersona();
+            const grantId = await TestDataGenerator.randomCborSha256Cid();
+            const recordsWrite = await RecordsWrite.create({
                 data: TestDataGenerator.randomBytes(10),
                 dataFormat: 'application/json',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
                 signer: Jws.createSigner(alice),
                 permissionGrantId: grantId,
             });
             expect(recordsWrite.message.descriptor.permissionGrantId).toBe(grantId);
-        }));
-        it('should not include permissionGrantId in the descriptor when not provided', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
-            const recordsWrite = yield RecordsWrite.create({
+        });
+        it('should not include permissionGrantId in the descriptor when not provided', async () => {
+            const alice = await TestDataGenerator.generatePersona();
+            const recordsWrite = await RecordsWrite.create({
                 data: TestDataGenerator.randomBytes(10),
                 dataFormat: 'application/json',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
                 signer: Jws.createSigner(alice),
             });
             expect(recordsWrite.message.descriptor.permissionGrantId).toBeUndefined();
-        }));
-        it('should be able to auto-fill `datePublished` when `published` set to `true` but `datePublished` not given', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
+        });
+        it('should be able to auto-fill `datePublished` when `published` set to `true` but `datePublished` not given', async () => {
+            const alice = await TestDataGenerator.generatePersona();
             const options = {
                 data: TestDataGenerator.randomBytes(10),
                 dataFormat: 'application/json',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
                 published: true,
                 signer: Jws.createSigner(alice)
             };
-            const recordsWrite = yield RecordsWrite.create(options);
+            const recordsWrite = await RecordsWrite.create(options);
             const message = recordsWrite.message;
             expect(message.descriptor.datePublished).toBeDefined();
-        }));
-        it('should not allow `data` and `dataCid` to be both defined or undefined', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
+        });
+        it('should not allow `data` and `dataCid` to be both defined or undefined', async () => {
+            const alice = await TestDataGenerator.generatePersona();
             // testing `data` and `dataCid` both defined
             const options1 = {
                 recipient: alice.did,
                 data: TestDataGenerator.randomBytes(10),
-                dataCid: yield TestDataGenerator.randomCborSha256Cid(),
+                dataCid: await TestDataGenerator.randomCborSha256Cid(),
                 dataFormat: 'application/json',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
                 published: true,
                 signer: Jws.createSigner(alice)
             };
             const createPromise1 = RecordsWrite.create(options1);
-            yield expect(createPromise1).rejects.toThrow(DwnErrorCode.RecordsWriteCreateDataAndDataCidMutuallyExclusive);
+            await expect(createPromise1).rejects.toThrow(DwnErrorCode.RecordsWriteCreateDataAndDataCidMutuallyExclusive);
             // testing `data` and `dataCid` both undefined
             const options2 = {
                 recipient: alice.did,
@@ -95,41 +103,47 @@ describe('RecordsWrite', () => {
                 // data                        : TestDataGenerator.randomBytes(10),
                 // dataCid                     : await TestDataGenerator.randomCborSha256Cid(),
                 dataFormat: 'application/json',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
                 published: true,
                 signer: Jws.createSigner(alice)
             };
             const createPromise2 = RecordsWrite.create(options2);
-            yield expect(createPromise2).rejects.toThrow(DwnErrorCode.RecordsWriteCreateDataAndDataCidMutuallyExclusive);
-        }));
-        it('should required `dataCid` and `dataSize` to be both defined or undefined at the same time', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
+            await expect(createPromise2).rejects.toThrow(DwnErrorCode.RecordsWriteCreateDataAndDataCidMutuallyExclusive);
+        });
+        it('should required `dataCid` and `dataSize` to be both defined or undefined at the same time', async () => {
+            const alice = await TestDataGenerator.generatePersona();
             const options1 = {
                 recipient: alice.did,
-                dataCid: yield TestDataGenerator.randomCborSha256Cid(),
+                dataCid: await TestDataGenerator.randomCborSha256Cid(),
                 // dataSize                  : 123, // intentionally missing
                 dataFormat: 'application/json',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
                 published: true,
                 signer: Jws.createSigner(alice)
             };
             const createPromise1 = RecordsWrite.create(options1);
-            yield expect(createPromise1).rejects.toThrow('`dataCid` and `dataSize` must both be defined or undefined at the same time');
+            await expect(createPromise1).rejects.toThrow('`dataCid` and `dataSize` must both be defined or undefined at the same time');
             const options2 = {
                 recipient: alice.did,
                 data: TestDataGenerator.randomBytes(10),
                 // dataCid                   : await TestDataGenerator.randomCborSha256Cid(), // intentionally missing
                 dataSize: 123,
                 dataFormat: 'application/json',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
                 published: true,
                 signer: Jws.createSigner(alice)
             };
             const createPromise2 = RecordsWrite.create(options2);
-            yield expect(createPromise2).rejects.toThrow('`dataCid` and `dataSize` must both be defined or undefined at the same time');
-        }));
-        it('should auto-normalize protocol URL', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
+            await expect(createPromise2).rejects.toThrow('`dataCid` and `dataSize` must both be defined or undefined at the same time');
+        });
+        it('should auto-normalize protocol URL', async () => {
+            const alice = await TestDataGenerator.generatePersona();
             const options = {
                 recipient: alice.did,
                 data: TestDataGenerator.randomBytes(10),
@@ -139,50 +153,41 @@ describe('RecordsWrite', () => {
                 protocolPath: 'example',
                 schema: 'http://foo.bar/schema'
             };
-            const recordsWrite = yield RecordsWrite.create(options);
+            const recordsWrite = await RecordsWrite.create(options);
             const message = recordsWrite.message;
             expect(message.descriptor.protocol).toBe('http://example.com');
-        }));
-        it('should required `protocol` and `protocolPath` to be both defined or undefined at the same time', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
-            const options1 = {
+        });
+        it('should require `protocol` and `protocolPath`', async () => {
+            const alice = await TestDataGenerator.generatePersona();
+            const baseOptions = {
                 recipient: alice.did,
-                protocol: 'http://example.com',
-                // protocolPath                : 'foo/bar', // intentionally missing
-                dataCid: yield TestDataGenerator.randomCborSha256Cid(),
+                dataCid: await TestDataGenerator.randomCborSha256Cid(),
                 dataSize: 123,
                 dataFormat: 'application/json',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
                 signer: Jws.createSigner(alice)
             };
-            const createPromise1 = RecordsWrite.create(options1);
-            yield expect(createPromise1).rejects.toThrow('`protocol` and `protocolPath` must both be defined or undefined at the same time');
-            const options2 = {
-                recipient: alice.did,
-                // protocol                    : 'http://example.com', // intentionally missing
+            // missing protocol
+            const missingProtocol = RecordsWrite.create({
+                ...baseOptions,
                 protocolPath: 'foo/bar',
-                data: TestDataGenerator.randomBytes(10),
-                dataCid: yield TestDataGenerator.randomCborSha256Cid(),
-                dataSize: 123,
-                dataFormat: 'application/json',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
-                signer: Jws.createSigner(alice)
-            };
-            const createPromise2 = RecordsWrite.create(options2);
-            yield expect(createPromise2).rejects.toThrow('`protocol` and `protocolPath` must both be defined or undefined at the same time');
-        }));
-        it('should be able to create a RecordsWrite successfully using a custom signer', () => __awaiter(void 0, void 0, void 0, function* () {
+            });
+            await expect(missingProtocol).rejects.toThrow('`protocol` and `protocolPath` are required');
+            // missing protocolPath
+            const missingProtocolPath = RecordsWrite.create({
+                ...baseOptions,
+                protocol: 'http://example.com',
+            });
+            await expect(missingProtocolPath).rejects.toThrow('`protocol` and `protocolPath` are required');
+        });
+        it('should be able to create a RecordsWrite successfully using a custom signer', async () => {
             // create a custom signer
             const hardCodedSignature = Encoder.stringToBytes('some_hard_coded_signature');
             class CustomSigner {
-                constructor() {
-                    this.keyId = 'did:example:alice#key1';
-                    this.algorithm = 'unused';
-                }
-                sign(_content) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        return hardCodedSignature;
-                    });
+                keyId = 'did:example:alice#key1';
+                algorithm = 'unused';
+                async sign(_content) {
+                    return hardCodedSignature;
                 }
             }
             const signer = new CustomSigner();
@@ -190,70 +195,24 @@ describe('RecordsWrite', () => {
                 schema: 'http://any-schema.com',
                 protocol: 'http://example.com',
                 protocolPath: 'foo/bar',
-                dataCid: yield TestDataGenerator.randomCborSha256Cid(),
+                dataCid: await TestDataGenerator.randomCborSha256Cid(),
                 dataSize: 123,
                 dataFormat: 'application/json',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
                 signer
             };
-            const recordsWrite = yield RecordsWrite.create(options);
+            const recordsWrite = await RecordsWrite.create(options);
             expect(recordsWrite.message.authorization.signature.signatures[0].signature).toBe(Encoder.bytesToBase64Url(hardCodedSignature));
-        }));
-        it('should throw if attempting to use `protocols` key derivation encryption scheme on non-protocol-based record', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
-            const dataEncryptionInitializationVector = TestDataGenerator.randomBytes(12);
-            const dataEncryptionKey = TestDataGenerator.randomBytes(32);
-            const encryptionInput = {
-                initializationVector: dataEncryptionInitializationVector,
-                key: dataEncryptionKey,
-                authenticationTag: TestDataGenerator.randomBytes(16),
-                keyEncryptionInputs: [{
-                        publicKeyId: alice.keyId, // reusing signing key for encryption purely as a convenience
-                        publicKey: alice.encryptionKeyPair.publicJwk,
-                        derivationScheme: KeyDerivationScheme.ProtocolPath
-                    }]
-            };
-            // intentionally generating a record that is not protocol-based
-            const createPromise = RecordsWrite.create({
-                signer: Jws.createSigner(alice),
-                dataFormat: 'application/json',
-                data: TestDataGenerator.randomBytes(10),
-                encryptionInput
-            });
-            yield expect(createPromise).rejects.toThrow(DwnErrorCode.RecordsWriteMissingProtocol);
-        }));
-        it('should throw if attempting to use `schemas` key derivation encryption scheme on a record without `schema`', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
-            const dataEncryptionInitializationVector = TestDataGenerator.randomBytes(12);
-            const dataEncryptionKey = TestDataGenerator.randomBytes(32);
-            const encryptionInput = {
-                initializationVector: dataEncryptionInitializationVector,
-                key: dataEncryptionKey,
-                authenticationTag: TestDataGenerator.randomBytes(16),
-                keyEncryptionInputs: [{
-                        publicKeyId: alice.keyId, // reusing signing key for encryption purely as a convenience
-                        publicKey: alice.encryptionKeyPair.publicJwk,
-                        derivationScheme: KeyDerivationScheme.Schemas
-                    }]
-            };
-            // intentionally generating a record that is without `schema`
-            const createPromise = RecordsWrite.create({
-                signer: Jws.createSigner(alice),
-                dataFormat: 'application/octet-stream',
-                data: TestDataGenerator.randomBytes(10),
-                encryptionInput
-            });
-            yield expect(createPromise).rejects.toThrow(DwnErrorCode.RecordsWriteMissingSchema);
-        }));
-        it('should throw if delegated grant is given but signer is not given', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
-            const bob = yield TestDataGenerator.generatePersona();
+        });
+        it('should throw if delegated grant is given but signer is not given', async () => {
+            const alice = await TestDataGenerator.generatePersona();
+            const bob = await TestDataGenerator.generatePersona();
             const scope = {
                 interface: DwnInterfaceName.Records,
                 method: DwnMethodName.Write,
                 protocol: 'chat'
             };
-            const grantToBob = yield PermissionsProtocol.createGrant({
+            const grantToBob = await PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
@@ -263,27 +222,29 @@ describe('RecordsWrite', () => {
             });
             const createPromise = RecordsWrite.create({
                 delegatedGrant: grantToBob.dataEncodedMessage,
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
                 dataFormat: 'application/octet-stream',
                 data: TestDataGenerator.randomBytes(10),
             });
-            yield expect(createPromise).rejects.toThrow(DwnErrorCode.RecordsWriteCreateMissingSigner);
-        }));
+            await expect(createPromise).rejects.toThrow(DwnErrorCode.RecordsWriteCreateMissingSigner);
+        });
     });
     describe('createFrom()', () => {
-        it('should create a RecordsWrite with `published` set to `true` with just `publishedDate` given', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { author, recordsWrite } = yield TestDataGenerator.generateRecordsWrite({
+        it('should create a RecordsWrite with `published` set to `true` with just `publishedDate` given', async () => {
+            const { author, recordsWrite } = await TestDataGenerator.generateRecordsWrite({
                 published: false
             });
-            const write = yield RecordsWrite.createFrom({
+            const write = await RecordsWrite.createFrom({
                 recordsWriteMessage: recordsWrite.message,
                 datePublished: Time.getCurrentTimestamp(),
                 signer: Jws.createSigner(author)
             });
             expect(write.message.descriptor.published).toBe(true);
-        }));
-        it('replace tags with updated tags, if tags do not exist in createFrom remove them', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it('replace tags with updated tags, if tags do not exist in createFrom remove them', async () => {
             // create a record with tags
-            const { author, message, recordsWrite } = yield TestDataGenerator.generateRecordsWrite({
+            const { author, message, recordsWrite } = await TestDataGenerator.generateRecordsWrite({
                 tags: {
                     tag1: ['value1', 'value2']
                 }
@@ -292,7 +253,7 @@ describe('RecordsWrite', () => {
             expect(message.descriptor.tags.tag1).toBeDefined();
             expect(message.descriptor.tags.tag1).toEqual(expect.arrayContaining(['value1', 'value2']));
             // update the record's tags
-            const write = yield RecordsWrite.createFrom({
+            const write = await RecordsWrite.createFrom({
                 recordsWriteMessage: recordsWrite.message,
                 signer: Jws.createSigner(author),
                 tags: {
@@ -304,30 +265,32 @@ describe('RecordsWrite', () => {
             expect(write.message.descriptor.tags.tag2).toBeDefined();
             expect(write.message.descriptor.tags.tag2).toEqual(expect.arrayContaining(['value1', 'value2', 'value3']));
             // update without tags
-            const write2 = yield RecordsWrite.createFrom({
+            const write2 = await RecordsWrite.createFrom({
                 recordsWriteMessage: write.message,
                 signer: Jws.createSigner(author),
             });
             expect(write2.message.descriptor.tags).toBeUndefined();
-        }));
+        });
     });
     describe('parse()', () => {
-        it('should invoke JSON schema validation when parsing a RecordsWrite', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
-            const recordsWrite = yield RecordsWrite.create({
+        it('should invoke JSON schema validation when parsing a RecordsWrite', async () => {
+            const alice = await TestDataGenerator.generatePersona();
+            const recordsWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(alice),
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
                 dataFormat: 'application/octet-stream',
                 data: TestDataGenerator.randomBytes(10),
             });
             const validateJsonSchemaSpy = sinon.spy(Message, 'validateJsonSchema');
-            yield RecordsWrite.parse(recordsWrite.message);
+            await RecordsWrite.parse(recordsWrite.message);
             expect(validateJsonSchemaSpy.called).toBe(true);
-        }));
+        });
     });
     describe('isSignedByAuthorDelegate()', () => {
-        it('should return false if the given RecordsWrite is not signed at all', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should return false if the given RecordsWrite is not signed at all', async () => {
             const data = new TextEncoder().encode('any data');
-            const recordsWrite = yield RecordsWrite.create({
+            const recordsWrite = await RecordsWrite.create({
                 protocol: 'unused',
                 protocolPath: 'unused',
                 schema: 'unused',
@@ -336,12 +299,12 @@ describe('RecordsWrite', () => {
             });
             const isSignedByAuthorDelegate = recordsWrite.isSignedByAuthorDelegate;
             expect(isSignedByAuthorDelegate).toBe(false);
-        }));
+        });
     });
     describe('isSignedByOwnerDelegate()', () => {
-        it('should return false if the given RecordsWrite is not signed at all', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should return false if the given RecordsWrite is not signed at all', async () => {
             const data = new TextEncoder().encode('any data');
-            const recordsWrite = yield RecordsWrite.create({
+            const recordsWrite = await RecordsWrite.create({
                 protocol: 'unused',
                 protocolPath: 'unused',
                 schema: 'unused',
@@ -350,103 +313,111 @@ describe('RecordsWrite', () => {
             });
             const isSignedByOwnerDelegate = recordsWrite.isSignedByOwnerDelegate;
             expect(isSignedByOwnerDelegate).toBe(false);
-        }));
+        });
     });
     describe('isInitialWrite()', () => {
-        it('should return false if given message is not a RecordsWrite', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { message } = yield TestDataGenerator.generateRecordsQuery();
-            const isInitialWrite = yield RecordsWrite.isInitialWrite(message);
+        it('should return false if given message is not a RecordsWrite', async () => {
+            const { message } = await TestDataGenerator.generateRecordsQuery();
+            const isInitialWrite = await RecordsWrite.isInitialWrite(message);
             expect(isInitialWrite).toBe(false);
-        }));
+        });
     });
     describe('getEntryId()', () => {
-        it('should throw if the given author is undefined', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { message } = yield TestDataGenerator.generateRecordsWrite();
+        it('should throw if the given author is undefined', async () => {
+            const { message } = await TestDataGenerator.generateRecordsWrite();
             const author = undefined;
-            yield expect(RecordsWrite.getEntryId(author, message.descriptor)).rejects.toThrow(DwnErrorCode.RecordsWriteGetEntryIdUndefinedAuthor);
-        }));
+            await expect(RecordsWrite.getEntryId(author, message.descriptor)).rejects.toThrow(DwnErrorCode.RecordsWriteGetEntryIdUndefinedAuthor);
+        });
     });
     describe('signAsOwner()', () => {
-        it('should throw if the RecordsWrite is not signed by an author yet', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should throw if the RecordsWrite is not signed by an author yet', async () => {
             const options = {
                 data: TestDataGenerator.randomBytes(10),
                 dataFormat: 'application/json',
                 dateCreated: '2023-07-27T10:20:30.405060Z',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
             };
-            const recordsWrite = yield RecordsWrite.create(options);
+            const recordsWrite = await RecordsWrite.create(options);
             expect(recordsWrite.author).toBeUndefined();
             expect(recordsWrite.signaturePayload).toBeUndefined();
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            yield expect(recordsWrite.signAsOwner(Jws.createSigner(alice))).rejects.toThrow(DwnErrorCode.RecordsWriteSignAsOwnerUnknownAuthor);
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            await expect(recordsWrite.signAsOwner(Jws.createSigner(alice))).rejects.toThrow(DwnErrorCode.RecordsWriteSignAsOwnerUnknownAuthor);
             expect(recordsWrite.owner).toBeUndefined();
             expect(recordsWrite.ownerSignaturePayload).toBeUndefined();
-        }));
+        });
     });
     describe('signAsOwnerDelegate()', () => {
-        it('should throw if the RecordsWrite is not signed by an author yet', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should throw if the RecordsWrite is not signed by an author yet', async () => {
             const options = {
                 data: TestDataGenerator.randomBytes(10),
                 dataFormat: 'application/json',
                 dateCreated: '2023-07-27T10:20:30.405060Z',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
             };
-            const recordsWrite = yield RecordsWrite.create(options);
+            const recordsWrite = await RecordsWrite.create(options);
             expect(recordsWrite.author).toBeUndefined();
             expect(recordsWrite.signaturePayload).toBeUndefined();
             // create a delegated grant
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
             const scope = {
                 interface: DwnInterfaceName.Records,
                 method: DwnMethodName.Write,
                 protocol: 'chat'
             };
-            const ownerDelegatedGrant = yield PermissionsProtocol.createGrant({
+            const ownerDelegatedGrant = await PermissionsProtocol.createGrant({
                 signer: Jws.createSigner(alice),
                 delegated: true, // this is a delegated grant
                 dateExpires: Time.createOffsetTimestamp({ seconds: 100 }),
                 grantedTo: bob.did,
                 scope
             });
-            yield expect(recordsWrite.signAsOwnerDelegate(Jws.createSigner(bob), ownerDelegatedGrant.dataEncodedMessage))
+            await expect(recordsWrite.signAsOwnerDelegate(Jws.createSigner(bob), ownerDelegatedGrant.dataEncodedMessage))
                 .rejects.toThrow(DwnErrorCode.RecordsWriteSignAsOwnerDelegateUnknownAuthor);
             expect(recordsWrite.owner).toBeUndefined();
             expect(recordsWrite.ownerSignaturePayload).toBeUndefined();
-        }));
+        });
     });
     describe('ownerSignatureSigner()', () => {
-        it('should return `undefined` if owner signature is not present in the message', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should return `undefined` if owner signature is not present in the message', async () => {
             const options = {
                 data: TestDataGenerator.randomBytes(10),
                 dataFormat: 'application/json',
                 dateCreated: '2023-07-27T10:20:30.405060Z',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
             };
-            const recordsWrite = yield RecordsWrite.create(options);
+            const recordsWrite = await RecordsWrite.create(options);
             expect(recordsWrite.ownerSignatureSigner).toBeUndefined();
-        }));
+        });
     });
     describe('message', () => {
-        it('should throw if attempting to access the message of a RecordsWrite that is not given authorization signature input', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should throw if attempting to access the message of a RecordsWrite that is not given authorization signature input', async () => {
             const options = {
                 data: TestDataGenerator.randomBytes(10),
                 dataFormat: 'application/json',
                 dateCreated: '2023-07-27T10:20:30.405060Z',
-                recordId: yield TestDataGenerator.randomCborSha256Cid(),
+                recordId: await TestDataGenerator.randomCborSha256Cid(),
+                protocol: 'http://test-protocol.xyz',
+                protocolPath: 'testRecord',
             };
-            const recordsWrite = yield RecordsWrite.create(options);
+            const recordsWrite = await RecordsWrite.create(options);
             expect(recordsWrite.author).toBeUndefined();
             expect(recordsWrite.signaturePayload).toBeUndefined();
             expect(() => recordsWrite.message).toThrow(DwnErrorCode.RecordsWriteMissingSigner);
-        }));
+        });
     });
     describe('encryptSymmetricEncryptionKey()', () => {
-        it('should replace encryption property by default', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
+        it('should replace encryption property by default', async () => {
+            const alice = await TestDataGenerator.generatePersona();
             const dataEncryptionKey = TestDataGenerator.randomBytes(32);
             const dataEncryptionIV = TestDataGenerator.randomBytes(12);
-            const recordsWrite = yield RecordsWrite.create({
+            const recordsWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(alice),
                 protocol: 'https://example.com/protocol',
                 protocolPath: 'test',
@@ -465,7 +436,7 @@ describe('RecordsWrite', () => {
                         derivationScheme: KeyDerivationScheme.ProtocolPath,
                     }],
             };
-            yield recordsWrite.encryptSymmetricEncryptionKey(encryptionInput1);
+            await recordsWrite.encryptSymmetricEncryptionKey(encryptionInput1);
             expect(recordsWrite['_message'].encryption).toBeDefined();
             expect(recordsWrite['_message'].encryption.recipients).toHaveLength(1);
             expect(recordsWrite['_message'].encryption.recipients[0].header.derivationScheme).toBe('protocolPath');
@@ -477,19 +448,19 @@ describe('RecordsWrite', () => {
                 keyEncryptionInputs: [{
                         publicKeyId: alice.keyId,
                         publicKey: alice.encryptionKeyPair.publicJwk,
-                        derivationScheme: KeyDerivationScheme.Schemas,
+                        derivationScheme: KeyDerivationScheme.ProtocolContext,
                     }],
             };
-            yield recordsWrite.encryptSymmetricEncryptionKey(encryptionInput2);
-            // Should have replaced — only 1 entry with Schemas scheme
+            await recordsWrite.encryptSymmetricEncryptionKey(encryptionInput2);
+            // Should have replaced — only 1 entry with ProtocolContext scheme
             expect(recordsWrite['_message'].encryption.recipients).toHaveLength(1);
-            expect(recordsWrite['_message'].encryption.recipients[0].header.derivationScheme).toBe('schemas');
-        }));
-        it('should append recipients when append option is true', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
+            expect(recordsWrite['_message'].encryption.recipients[0].header.derivationScheme).toBe('protocolContext');
+        });
+        it('should append recipients when append option is true', async () => {
+            const alice = await TestDataGenerator.generatePersona();
             const dataEncryptionKey = TestDataGenerator.randomBytes(32);
             const dataEncryptionIV = TestDataGenerator.randomBytes(12);
-            const recordsWrite = yield RecordsWrite.create({
+            const recordsWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(alice),
                 protocol: 'https://example.com/protocol',
                 protocolPath: 'test',
@@ -508,7 +479,7 @@ describe('RecordsWrite', () => {
                         derivationScheme: KeyDerivationScheme.ProtocolPath,
                     }],
             };
-            yield recordsWrite.encryptSymmetricEncryptionKey(encryptionInput1);
+            await recordsWrite.encryptSymmetricEncryptionKey(encryptionInput1);
             const originalIV = recordsWrite['_message'].encryption.iv;
             const originalProtected = recordsWrite['_message'].encryption.protected;
             // Second encryption with append — ProtocolContext
@@ -522,7 +493,7 @@ describe('RecordsWrite', () => {
                         derivationScheme: KeyDerivationScheme.ProtocolContext,
                     }],
             };
-            yield recordsWrite.encryptSymmetricEncryptionKey(encryptionInput2, { append: true });
+            await recordsWrite.encryptSymmetricEncryptionKey(encryptionInput2, { append: true });
             // Should have both entries
             const encryption = recordsWrite['_message'].encryption;
             expect(encryption.recipients).toHaveLength(2);
@@ -538,16 +509,16 @@ describe('RecordsWrite', () => {
             // When starting from a parsed/signed message (the signAsOwner test
             // below), authorization IS preserved by append mode.
             expect(recordsWrite['_message'].authorization).toBeUndefined();
-        }));
-        it('should allow signAsOwner after append (reactive root-record upgrade)', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it('should allow signAsOwner after append (reactive root-record upgrade)', async () => {
             // Simulates the cross-DWN scenario: Bob authors a record, Alice (owner)
             // appends a ProtocolContext recipient entry, then signs as owner.
-            const alice = yield TestDataGenerator.generatePersona();
-            const bob = yield TestDataGenerator.generatePersona();
+            const alice = await TestDataGenerator.generatePersona();
+            const bob = await TestDataGenerator.generatePersona();
             const dataEncryptionKey = TestDataGenerator.randomBytes(32);
             const dataEncryptionIV = TestDataGenerator.randomBytes(12);
             // Bob creates and signs the record
-            const recordsWrite = yield RecordsWrite.create({
+            const recordsWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(bob),
                 protocol: 'https://example.com/protocol',
                 protocolPath: 'thread',
@@ -566,12 +537,12 @@ describe('RecordsWrite', () => {
                         derivationScheme: KeyDerivationScheme.ProtocolPath,
                     }],
             };
-            yield recordsWrite.encryptSymmetricEncryptionKey(encryptionInput1);
-            yield recordsWrite.sign({ signer: Jws.createSigner(bob) });
+            await recordsWrite.encryptSymmetricEncryptionKey(encryptionInput1);
+            await recordsWrite.sign({ signer: Jws.createSigner(bob) });
             expect(recordsWrite.author).toBe(bob.did);
             expect(recordsWrite['_message'].authorization).toBeDefined();
             // Simulate: Alice parses Bob's message and appends ProtocolContext
-            const parsed = yield RecordsWrite.parse(recordsWrite.message);
+            const parsed = await RecordsWrite.parse(recordsWrite.message);
             expect(parsed.author).toBe(bob.did);
             const encryptionInput2 = {
                 initializationVector: dataEncryptionIV,
@@ -583,12 +554,12 @@ describe('RecordsWrite', () => {
                         derivationScheme: KeyDerivationScheme.ProtocolContext,
                     }],
             };
-            yield parsed.encryptSymmetricEncryptionKey(encryptionInput2, { append: true });
+            await parsed.encryptSymmetricEncryptionKey(encryptionInput2, { append: true });
             // Author and authorization should be preserved after append
             expect(parsed.author).toBe(bob.did);
             expect(parsed['_message'].authorization).toBeDefined();
             // Alice signs as owner — should NOT throw
-            yield parsed.signAsOwner(Jws.createSigner(alice));
+            await parsed.signAsOwner(Jws.createSigner(alice));
             expect(parsed.owner).toBe(alice.did);
             expect(parsed['_message'].authorization.ownerSignature).toBeDefined();
             // Both recipient entries should be present
@@ -598,13 +569,13 @@ describe('RecordsWrite', () => {
             expect(encryption.recipients[1].header.derivationScheme).toBe('protocolContext');
             // validateIntegrity should pass — the stale encryptionCid in the
             // author's signature is allowed when ownerSignature is present
-            yield parsed['validateIntegrity']();
-        }));
-        it('should throw when append is true but encryption does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
-            const alice = yield TestDataGenerator.generatePersona();
+            await parsed['validateIntegrity']();
+        });
+        it('should throw when append is true but encryption does not exist', async () => {
+            const alice = await TestDataGenerator.generatePersona();
             const dataEncryptionKey = TestDataGenerator.randomBytes(32);
             const dataEncryptionIV = TestDataGenerator.randomBytes(12);
-            const recordsWrite = yield RecordsWrite.create({
+            const recordsWrite = await RecordsWrite.create({
                 signer: Jws.createSigner(alice),
                 protocol: 'https://example.com/protocol',
                 protocolPath: 'test',
@@ -621,8 +592,8 @@ describe('RecordsWrite', () => {
                         derivationScheme: KeyDerivationScheme.ProtocolPath,
                     }],
             };
-            yield expect(recordsWrite.encryptSymmetricEncryptionKey(encryptionInput, { append: true })).rejects.toThrow(DwnErrorCode.RecordsWriteMissingEncryption);
-        }));
+            await expect(recordsWrite.encryptSymmetricEncryptionKey(encryptionInput, { append: true })).rejects.toThrow(DwnErrorCode.RecordsWriteMissingEncryption);
+        });
     });
 });
 //# sourceMappingURL=records-write.spec.js.map