@nmshd/transport 2.8.2 → 5.0.0-alpha.10

package/dist/modules/relationships/RelationshipsController.js

@@ -23,18 +23,16 @@ const RelationshipTemplate_1 = require("../relationshipTemplates/local/Relations
 const RelationshipClient_1 = require("./backbone/RelationshipClient");
 const CachedRelationship_1 = require("./local/CachedRelationship");
 const Relationship_1 = require("./local/Relationship");
+const RelationshipAuditLog_1 = require("./local/RelationshipAuditLog");
 const SendRelationshipParameters_1 = require("./local/SendRelationshipParameters");
-const RelationshipChange_1 = require("./transmission/changes/RelationshipChange");
-const RelationshipChangeResponse_1 = require("./transmission/changes/RelationshipChangeResponse");
-const RelationshipChangeStatus_1 = require("./transmission/changes/RelationshipChangeStatus");
-const RelationshipChangeType_1 = require("./transmission/changes/RelationshipChangeType");
+const RelationshipAuditLog_2 = require("./transmission/RelationshipAuditLog");
 const RelationshipStatus_1 = require("./transmission/RelationshipStatus");
-const RelationshipCreationChangeRequestCipher_1 = require("./transmission/requests/RelationshipCreationChangeRequestCipher");
-const RelationshipCreationChangeRequestContentWrapper_1 = require("./transmission/requests/RelationshipCreationChangeRequestContentWrapper");
-const RelationshipCreationChangeRequestSigned_1 = require("./transmission/requests/RelationshipCreationChangeRequestSigned");
-const RelationshipCreationChangeResponseCipher_1 = require("./transmission/responses/RelationshipCreationChangeResponseCipher");
-const RelationshipCreationChangeResponseContentWrapper_1 = require("./transmission/responses/RelationshipCreationChangeResponseContentWrapper");
-const RelationshipCreationChangeResponseSigned_1 = require("./transmission/responses/RelationshipCreationChangeResponseSigned");
+const RelationshipCreationContentCipher_1 = require("./transmission/requests/RelationshipCreationContentCipher");
+const RelationshipCreationContentSigned_1 = require("./transmission/requests/RelationshipCreationContentSigned");
+const RelationshipCreationContentWrapper_1 = require("./transmission/requests/RelationshipCreationContentWrapper");
+const RelationshipCreationResponseContentCipher_1 = require("./transmission/responses/RelationshipCreationResponseContentCipher");
+const RelationshipCreationResponseContentSigned_1 = require("./transmission/responses/RelationshipCreationResponseContentSigned");
+const RelationshipCreationResponseContentWrapper_1 = require("./transmission/responses/RelationshipCreationResponseContentWrapper");
 class RelationshipsController extends core_1.TransportController {
     constructor(parent, secrets) {
         super(core_1.ControllerName.Relationships, parent);
@@ -48,7 +46,8 @@ class RelationshipsController extends core_1.TransportController {
     }
     async getRelationships(query) {
         const relationshipDocs = await this.relationships.find(query);
-        return this.parseArray(relationshipDocs, Relationship_1.Relationship);
+        const relationships = this.parseArray(relationshipDocs, Relationship_1.Relationship);
+        return relationships;
     }
     async updateCache(ids) {
         if (ids.length < 1) {
@@ -57,7 +56,7 @@ class RelationshipsController extends core_1.TransportController {
         const resultItems = (await this.client.getRelationships({ ids })).value;
         const promises = [];
         for await (const resultItem of resultItems) {
-            promises.push(this.updateCacheOfExistingRelationshipInDb(resultItem.id, resultItem));
+            promises.push(this.updateExistingRelationshipInDb(resultItem.id, resultItem));
         }
         return await Promise.all(promises);
     }
@@ -67,20 +66,26 @@ class RelationshipsController extends core_1.TransportController {
         const backboneRelationships = await (await this.client.getRelationships({ ids: ids.map((id) => id.id) })).value.collect();
         const decryptionPromises = backboneRelationships.map(async (r) => {
             const relationshipDoc = await this.relationships.read(r.id);
+            if (!relationshipDoc) {
+                this._log.error(`Relationship '${r.id}' not found in local database and the cache fetching was therefore skipped. This should not happen and might be a bug in the application logic.`);
+                return;
+            }
             const relationship = Relationship_1.Relationship.from(relationshipDoc);
             return {
                 id: core_1.CoreId.from(r.id),
                 cache: await this.decryptRelationship(r, relationship.relationshipSecretId)
             };
         });
-        return await Promise.all(decryptionPromises);
+        const caches = await Promise.all(decryptionPromises);
+        return caches.filter((c) => c !== undefined);
     }
-    async updateCacheOfExistingRelationshipInDb(id, response) {
+    async updateExistingRelationshipInDb(id, response) {
         const relationshipDoc = await this.relationships.read(id);
         if (!relationshipDoc)
             throw CoreErrors_1.CoreErrors.general.recordNotFound(Relationship_1.Relationship, id);
         const relationship = Relationship_1.Relationship.from(relationshipDoc);
         await this.updateCacheOfRelationship(relationship, response);
+        relationship.status = response.status;
         await this.relationships.update(relationshipDoc, relationship);
         return relationship;
     }
@@ -88,19 +93,15 @@ class RelationshipsController extends core_1.TransportController {
         const query = { peerAddress: address.toString() };
         if (status)
             query[`${(0, ts_simple_nameof_1.nameof)((r) => r.status)}`] = status;
-        let relationshipDoc = await this.relationships.findOne(query);
-        if (!relationshipDoc) {
-            // If we don't find the relationship by peerAddress, we have to check again by peer.address
-            // as the Relationship could have been created before the peerAddress was introduced
-            const query = { [`${(0, ts_simple_nameof_1.nameof)((r) => r.peer)}.${(0, ts_simple_nameof_1.nameof)((r) => r.address)}`]: address.toString() };
-            if (status)
-                query[`${(0, ts_simple_nameof_1.nameof)((r) => r.status)}`] = status;
-            relationshipDoc = await this.relationships.findOne(query);
-        }
-        if (!relationshipDoc) {
-            return;
-        }
-        return Relationship_1.Relationship.from(relationshipDoc);
+        const relationships = await this.relationships.find(query);
+        if (relationships.length === 0)
+            return undefined;
+        if (relationships.length === 1)
+            return Relationship_1.Relationship.from(relationships[0]);
+        const newestRelationship = relationships.reduce((prev, current) => {
+            return prev.createdAt > current.createdAt ? prev : current;
+        });
+        return Relationship_1.Relationship.from(newestRelationship);
     }
     async getActiveRelationshipToIdentity(address) {
         return await this.getRelationshipToIdentity(address, RelationshipStatus_1.RelationshipStatus.Active);
@@ -110,7 +111,8 @@ class RelationshipsController extends core_1.TransportController {
         if (!relationshipDoc) {
             return;
         }
-        return Relationship_1.Relationship.from(relationshipDoc);
+        const relationship = Relationship_1.Relationship.from(relationshipDoc);
+        return relationship;
     }
     async sign(relationship, content) {
         return await this.secrets.sign(relationship.relationshipSecretId, content);
@@ -128,9 +130,9 @@ class RelationshipsController extends core_1.TransportController {
             throw this.newCacheEmptyError(RelationshipTemplate_1.RelationshipTemplate, template.id.toString());
         }
         const secretId = await TransportIds_1.TransportIds.relationshipSecret.generate();
-        const { requestCipher, requestContent } = await this.prepareRequest(secretId, template, parameters.content);
+        const creationContentCipher = await this.prepareCreationContent(secretId, template, parameters.creationContent);
         const result = await this.client.createRelationship({
-            content: requestCipher.toBase64(),
+            creationContent: creationContentCipher.toBase64(),
             relationshipTemplateId: template.id.toString()
         });
         if (result.isError) {
@@ -140,7 +142,7 @@ class RelationshipsController extends core_1.TransportController {
             throw result.error;
         }
         const backboneResponse = result.value;
-        const newRelationship = Relationship_1.Relationship.fromRequestSent(core_1.CoreId.from(backboneResponse.id), template, template.cache.identity, RelationshipChange_1.RelationshipChange.fromBackbone(backboneResponse.changes[0], requestContent.content), secretId);
+        const newRelationship = Relationship_1.Relationship.fromBackboneAndCreationContent(backboneResponse, template, template.cache.identity, parameters.creationContent, secretId);
         await this.relationships.create(newRelationship);
         this.eventBus.publish(new events_1.RelationshipChangedEvent(this.parent.identity.address.toString(), newRelationship));
         return newRelationship;
@@ -156,14 +158,113 @@ class RelationshipsController extends core_1.TransportController {
         await this.relationships.update(relationshipDoc, relationship);
         return relationship;
     }
-    async acceptChange(change, content) {
-        return await this.completeChange(RelationshipChangeStatus_1.RelationshipChangeStatus.Accepted, change, content);
+    async accept(relationshipId) {
+        const relationship = await this.getRelationshipWithCache(relationshipId);
+        this.assertRelationshipStatus(relationship, RelationshipStatus_1.RelationshipStatus.Pending);
+        const lastAuditLogEntry = relationship.cache.auditLog[relationship.cache.auditLog.length - 1];
+        if (!lastAuditLogEntry.createdBy.equals(relationship.peer.address)) {
+            throw CoreErrors_1.CoreErrors.relationships.operationOnlyAllowedForPeer(`Only your peer can accept the relationship ${relationshipId.toString()}`);
+        }
+        return await this.completeOperationWithBackboneCall(RelationshipAuditLog_2.RelationshipAuditLogEntryReason.AcceptanceOfCreation, relationshipId);
+    }
+    async reject(relationshipId) {
+        const relationship = await this.getRelationshipWithCache(relationshipId);
+        this.assertRelationshipStatus(relationship, RelationshipStatus_1.RelationshipStatus.Pending);
+        const lastAuditLogEntry = relationship.cache.auditLog[relationship.cache.auditLog.length - 1];
+        if (!lastAuditLogEntry.createdBy.equals(relationship.peer.address)) {
+            throw CoreErrors_1.CoreErrors.relationships.operationOnlyAllowedForPeer(`Only your peer can reject the relationship ${relationshipId.toString()}. Revoke the relationship instead.`);
+        }
+        return await this.completeOperationWithBackboneCall(RelationshipAuditLog_2.RelationshipAuditLogEntryReason.RejectionOfCreation, relationshipId);
+    }
+    async revoke(relationshipId) {
+        const relationship = await this.getRelationshipWithCache(relationshipId);
+        this.assertRelationshipStatus(relationship, RelationshipStatus_1.RelationshipStatus.Pending);
+        const lastAuditLogEntry = relationship.cache.auditLog[relationship.cache.auditLog.length - 1];
+        if (lastAuditLogEntry.createdBy.equals(relationship.peer.address)) {
+            throw CoreErrors_1.CoreErrors.relationships.operationOnlyAllowedForPeer(`Only your peer can revoke the relationship ${relationshipId.toString()}. Reject the relationship instead.`);
+        }
+        return await this.completeOperationWithBackboneCall(RelationshipAuditLog_2.RelationshipAuditLogEntryReason.RevocationOfCreation, relationshipId);
+    }
+    async terminate(relationshipId) {
+        const relationship = await this.getRelationshipWithCache(relationshipId);
+        this.assertRelationshipStatus(relationship, RelationshipStatus_1.RelationshipStatus.Active);
+        return await this.completeOperationWithBackboneCall(RelationshipAuditLog_2.RelationshipAuditLogEntryReason.Termination, relationshipId);
+    }
+    async requestReactivation(relationshipId) {
+        const relationship = await this.getRelationshipWithCache(relationshipId);
+        this.assertRelationshipStatus(relationship, RelationshipStatus_1.RelationshipStatus.Terminated);
+        const lastAuditLogEntry = relationship.cache.auditLog[relationship.cache.auditLog.length - 1];
+        if (lastAuditLogEntry.reason === RelationshipAuditLog_2.RelationshipAuditLogEntryReason.ReactivationRequested) {
+            if (lastAuditLogEntry.createdBy.equals(relationship.peer.address)) {
+                throw CoreErrors_1.CoreErrors.relationships.reactivationAlreadyRequested(`Your peer has already requested the reactivation of the relationship ${relationshipId.toString()}. You can accept the reactivation instead.`);
+            }
+            throw CoreErrors_1.CoreErrors.relationships.reactivationAlreadyRequested(`You have already requested the reactivation of the relationship ${relationshipId.toString()}.`);
+        }
+        return await this.completeOperationWithBackboneCall(RelationshipAuditLog_2.RelationshipAuditLogEntryReason.ReactivationRequested, relationshipId);
     }
-    async rejectChange(change, content) {
-        return await this.completeChange(RelationshipChangeStatus_1.RelationshipChangeStatus.Rejected, change, content);
+    async rejectReactivation(relationshipId) {
+        const relationship = await this.getRelationshipWithCache(relationshipId);
+        this.assertRelationshipStatus(relationship, RelationshipStatus_1.RelationshipStatus.Terminated);
+        const lastAuditLogEntry = relationship.cache.auditLog[relationship.cache.auditLog.length - 1];
+        if (lastAuditLogEntry.reason !== RelationshipAuditLog_2.RelationshipAuditLogEntryReason.ReactivationRequested) {
+            throw CoreErrors_1.CoreErrors.relationships.reactivationNotRequested(relationshipId.toString());
+        }
+        if (!lastAuditLogEntry.createdBy.equals(relationship.peer.address)) {
+            throw CoreErrors_1.CoreErrors.relationships.operationOnlyAllowedForPeer(`Only your peer can reject the reactivation of the relationship ${relationshipId.toString()}. Revoke the relationship reactivation instead.`);
+        }
+        return await this.completeOperationWithBackboneCall(RelationshipAuditLog_2.RelationshipAuditLogEntryReason.RejectionOfReactivation, relationshipId);
     }
-    async revokeChange(change, content) {
-        return await this.completeChange(RelationshipChangeStatus_1.RelationshipChangeStatus.Revoked, change, content);
+    async revokeReactivation(relationshipId) {
+        const relationship = await this.getRelationshipWithCache(relationshipId);
+        this.assertRelationshipStatus(relationship, RelationshipStatus_1.RelationshipStatus.Terminated);
+        const lastAuditLogEntry = relationship.cache.auditLog[relationship.cache.auditLog.length - 1];
+        if (lastAuditLogEntry.reason !== RelationshipAuditLog_2.RelationshipAuditLogEntryReason.ReactivationRequested) {
+            throw CoreErrors_1.CoreErrors.relationships.reactivationNotRequested(relationshipId.toString());
+        }
+        if (lastAuditLogEntry.createdBy.equals(relationship.peer.address)) {
+            throw CoreErrors_1.CoreErrors.relationships.operationOnlyAllowedForPeer(`Only your peer can revoke the reactivation of the relationship ${relationshipId.toString()}. Reject the relationship reactivation instead.`);
+        }
+        return await this.completeOperationWithBackboneCall(RelationshipAuditLog_2.RelationshipAuditLogEntryReason.RevocationOfReactivation, relationshipId);
+    }
+    async acceptReactivation(relationshipId) {
+        const relationship = await this.getRelationshipWithCache(relationshipId);
+        this.assertRelationshipStatus(relationship, RelationshipStatus_1.RelationshipStatus.Terminated);
+        const lastAuditLogEntry = relationship.cache.auditLog[relationship.cache.auditLog.length - 1];
+        if (lastAuditLogEntry.reason !== RelationshipAuditLog_2.RelationshipAuditLogEntryReason.ReactivationRequested) {
+            throw CoreErrors_1.CoreErrors.relationships.reactivationNotRequested(relationshipId.toString());
+        }
+        if (!lastAuditLogEntry.createdBy.equals(relationship.peer.address)) {
+            throw CoreErrors_1.CoreErrors.relationships.operationOnlyAllowedForPeer(`Only your peer can accept the reactivation of the relationship ${relationshipId.toString()}.`);
+        }
+        return await this.completeOperationWithBackboneCall(RelationshipAuditLog_2.RelationshipAuditLogEntryReason.AcceptanceOfReactivation, relationshipId);
+    }
+    async decompose(relationshipId) {
+        const relationship = await this.getRelationshipWithCache(relationshipId);
+        this.assertRelationshipStatus(relationship, RelationshipStatus_1.RelationshipStatus.Terminated, RelationshipStatus_1.RelationshipStatus.DeletionProposed);
+        const result = await this.client.decomposeRelationship(relationshipId.toString());
+        if (result.isError)
+            throw result.error;
+        const isSecretDeletionSuccessful = await this.secrets.deleteSecretForRelationship(relationship.relationshipSecretId);
+        if (!isSecretDeletionSuccessful) {
+            this._log.error("Decomposition failed to delete secrets");
+        }
+        await this.relationships.delete({ id: relationshipId });
+        this.eventBus.publish(new events_1.RelationshipDecomposedBySelfEvent(this.parent.identity.address.toString(), { relationshipId }));
+    }
+    async getRelationshipWithCache(id) {
+        const relationship = await this.getRelationship(id);
+        if (!relationship)
+            throw CoreErrors_1.CoreErrors.general.recordNotFound(Relationship_1.Relationship, id.toString());
+        if (!relationship.cache)
+            await this.updateCacheOfRelationship(relationship);
+        if (!relationship.cache)
+            throw this.newCacheEmptyError(Relationship_1.Relationship, id.toString());
+        return relationship;
+    }
+    assertRelationshipStatus(relationship, ...status) {
+        if (status.includes(relationship.status))
+            return;
+        throw CoreErrors_1.CoreErrors.relationships.wrongRelationshipStatus(relationship.id.toString(), relationship.status);
     }
     async updateCacheOfRelationship(relationship, response) {
         if (!response) {
@@ -173,322 +274,188 @@ class RelationshipsController extends core_1.TransportController {
         relationship.setCache(cachedRelationship);
     }
     async decryptRelationship(response, relationshipSecretId) {
+        if (!response.creationContent)
+            throw new core_1.TransportError("Creation content is missing");
         const templateId = core_1.CoreId.from(response.relationshipTemplateId);
         this._log.trace(`Parsing relationship template ${templateId} for ${response.id}...`);
         const template = await this.parent.relationshipTemplates.getRelationshipTemplate(templateId);
         if (!template) {
             throw CoreErrors_1.CoreErrors.general.recordNotFound(RelationshipTemplate_1.RelationshipTemplate, templateId.toString());
         }
-        this._log.trace(`Parsing relationship changes of ${response.id}...`);
-        const changesPromises = [];
-        for (const change of response.changes) {
-            switch (change.type) {
-                case RelationshipChangeType_1.RelationshipChangeType.Creation:
-                    changesPromises.push(this.parseCreationChange(change, relationshipSecretId, templateId));
-                    break;
-                default:
-                    break;
-            }
-        }
-        const changes = await Promise.all(changesPromises);
+        this._log.trace(`Parsing relationship creation content of ${response.id}...`);
+        const creationContent = await this.decryptCreationContent(response.creationContent, core_1.CoreAddress.from(response.from), relationshipSecretId);
         const cachedRelationship = CachedRelationship_1.CachedRelationship.from({
-            changes: changes,
-            template: template
+            creationContent: creationContent.content,
+            template,
+            auditLog: RelationshipAuditLog_1.RelationshipAuditLog.fromBackboneAuditLog(response.auditLog)
         });
         return cachedRelationship;
     }
-    async prepareRequest(relationshipSecretId, template, content) {
+    async prepareCreationContent(relationshipSecretId, template, content) {
         if (!template.cache) {
             throw this.newCacheEmptyError(RelationshipTemplate_1.RelationshipTemplate, template.id.toString());
         }
-        const requestPublic = await this.secrets.createRequestorSecrets(template.cache, relationshipSecretId);
-        const requestContent = RelationshipCreationChangeRequestContentWrapper_1.RelationshipCreationChangeRequestContentWrapper.from({
-            content: content,
+        const publicCreationContentCrypto = await this.secrets.createRequestorSecrets(template.cache, relationshipSecretId);
+        const creationContent = RelationshipCreationContentWrapper_1.RelationshipCreationContentWrapper.from({
+            content,
             identity: this.parent.identity.identity,
             templateId: template.id
         });
-        const serializedRequest = requestContent.serialize();
-        const buffer = CoreUtil_1.CoreUtil.toBuffer(serializedRequest);
+        const serializedCreationContent = creationContent.serialize();
+        const buffer = CoreUtil_1.CoreUtil.toBuffer(serializedCreationContent);
         const [deviceSignature, relationshipSignature] = await Promise.all([this.parent.activeDevice.sign(buffer), this.secrets.sign(relationshipSecretId, buffer)]);
-        const signedRequest = RelationshipCreationChangeRequestSigned_1.RelationshipCreationChangeRequestSigned.from({
-            serializedRequest: serializedRequest,
-            deviceSignature: deviceSignature,
-            relationshipSignature: relationshipSignature
+        const signedCreationContent = RelationshipCreationContentSigned_1.RelationshipCreationContentSigned.from({
+            serializedCreationContent,
+            deviceSignature,
+            relationshipSignature
         });
-        const cipher = await this.secrets.encryptRequest(relationshipSecretId, signedRequest);
-        const requestCipher = RelationshipCreationChangeRequestCipher_1.RelationshipCreationChangeRequestCipher.from({
-            cipher: cipher,
-            publicRequestCrypto: requestPublic
+        const cipher = await this.secrets.encryptCreationContent(relationshipSecretId, signedCreationContent);
+        const creationContentCipher = RelationshipCreationContentCipher_1.RelationshipCreationContentCipher.from({
+            cipher,
+            publicCreationContentCrypto
         });
-        return { requestCipher, requestContent };
-    }
-    async applyChangeById(changeId) {
-        const relationshipChange = (await this.client.getRelationshipChange(changeId.toString())).value;
-        return await this.applyChange(relationshipChange);
-    }
-    async applyChange(change) {
-        switch (change.type) {
-            case RelationshipChangeType_1.RelationshipChangeType.Creation:
-                return await this.applyCreationChange(change);
-            case RelationshipChangeType_1.RelationshipChangeType.Termination:
-            case RelationshipChangeType_1.RelationshipChangeType.TerminationCancellation:
-            default:
-                throw CoreErrors_1.CoreErrors.general.notSupported();
-        }
+        return creationContentCipher;
     }
-    async applyCreationChange(change) {
-        const relationshipDoc = await this.relationships.read(change.relationshipId);
-        if (relationshipDoc) {
-            // Incoming change from sync might still have an empty response
-            // This could happen if we've processed the change before (duplicate)
-            if (change.response) {
-                return await this.updatePendingRelationshipWithPeerResponse(relationshipDoc, change);
-            }
-            // If we have a relationship already but no response, do nothing
-            return undefined;
-        }
-        const newRelationship = await this.createNewRelationshipByIncomingCreationChange(change);
-        if (change.response) {
-            // The request was revoked before we fetched the creation,
-            // thus the creation and revoke change is one
-            const relationshipDoc = await this.relationships.read(change.relationshipId);
-            return await this.updatePendingRelationshipWithPeerResponse(relationshipDoc, change);
-        }
-        return newRelationship;
+    async updateRelationshipWithPeerResponse(relationshipDoc) {
+        const relationship = Relationship_1.Relationship.from(relationshipDoc);
+        const backboneRelationship = (await this.client.getRelationship(relationship.id.toString())).value;
+        if (!(await this.secrets.hasCryptoRelationshipSecrets(relationship.relationshipSecretId)) && backboneRelationship.creationResponseContent) {
+            const creationResponseContent = backboneRelationship.creationResponseContent;
+            const cipher = RelationshipCreationResponseContentCipher_1.RelationshipCreationResponseContentCipher.fromBase64(creationResponseContent);
+            await this.secrets.convertSecrets(relationship.relationshipSecretId, cipher.publicCreationResponseContentCrypto);
+        }
+        relationship.cache.auditLog = RelationshipAuditLog_1.RelationshipAuditLog.fromBackboneAuditLog(backboneRelationship.auditLog);
+        relationship.status = backboneRelationship.status;
+        await this.relationships.update(relationshipDoc, relationship);
+        return relationship;
     }
-    async parseCreationChange(change, relationshipSecretId, templateId) {
-        if (change.type !== RelationshipChangeType_1.RelationshipChangeType.Creation)
-            this.throwWrongChangeType(change.type);
-        const promises = [];
-        promises.push(this.decryptCreationChangeRequest(change.request, relationshipSecretId, templateId));
-        const hasRelationshipSecret = await this.secrets.hasCryptoRelationshipSecrets(relationshipSecretId);
-        if (change.response && hasRelationshipSecret) {
-            promises.push(this.decryptCreationChangeResponse(change, relationshipSecretId));
-        }
-        const [requestContent, responseContent] = await Promise.all(promises);
-        const creationChange = RelationshipChange_1.RelationshipChange.fromBackbone(change, requestContent.content, responseContent?.content);
-        return creationChange;
-    }
-    async decryptCreationChangeRequest(change, secretId, templateId) {
-        if (!change.content)
-            throw this.newEmptyOrInvalidContentError();
-        const isOwnChange = this.parent.identity.isMe(core_1.CoreAddress.from(change.createdBy));
-        const requestCipher = RelationshipCreationChangeRequestCipher_1.RelationshipCreationChangeRequestCipher.fromBase64(change.content);
-        const signedRequestBuffer = await this.secrets.decryptRequest(secretId, requestCipher.cipher);
-        const signedRequest = RelationshipCreationChangeRequestSigned_1.RelationshipCreationChangeRequestSigned.deserialize(signedRequestBuffer.toUtf8());
+    async decryptCreationContent(backboneCreationContent, creationContentCreator, secretId) {
+        const isOwnContent = this.parent.identity.isMe(creationContentCreator);
+        const creationContentCipher = RelationshipCreationContentCipher_1.RelationshipCreationContentCipher.fromBase64(backboneCreationContent);
+        const signedCreationContentBuffer = await this.secrets.decryptCreationContent(secretId, creationContentCipher.cipher);
+        const signedCreationContent = RelationshipCreationContentSigned_1.RelationshipCreationContentSigned.deserialize(signedCreationContentBuffer.toUtf8());
         let relationshipSignatureValid;
-        if (isOwnChange) {
-            relationshipSignatureValid = await this.secrets.verifyOwn(secretId, crypto_1.CoreBuffer.fromUtf8(signedRequest.serializedRequest), signedRequest.relationshipSignature);
+        if (isOwnContent) {
+            relationshipSignatureValid = await this.secrets.verifyOwn(secretId, crypto_1.CoreBuffer.fromUtf8(signedCreationContent.serializedCreationContent), signedCreationContent.relationshipSignature);
         }
         else {
-            relationshipSignatureValid = await this.secrets.verifyPeer(secretId, crypto_1.CoreBuffer.fromUtf8(signedRequest.serializedRequest), signedRequest.relationshipSignature);
+            relationshipSignatureValid = await this.secrets.verifyPeer(secretId, crypto_1.CoreBuffer.fromUtf8(signedCreationContent.serializedCreationContent), signedCreationContent.relationshipSignature);
         }
         if (!relationshipSignatureValid) {
-            throw CoreErrors_1.CoreErrors.general.signatureNotValid("relationshipRequest");
-        }
-        const requestContent = RelationshipCreationChangeRequestContentWrapper_1.RelationshipCreationChangeRequestContentWrapper.deserialize(signedRequest.serializedRequest);
-        if (!requestContent.templateId.equals(templateId)) {
-            throw new core_1.TransportError("The relationship request contains a wrong template id.");
-        }
-        return requestContent;
-    }
-    async decryptCreationChangeResponse(change, relationshipSecretId) {
-        if (!change.response)
-            throw this.newChangeResponseMissingError(change.id);
-        if (change.type !== RelationshipChangeType_1.RelationshipChangeType.Creation)
-            this.throwWrongChangeType(change.type);
-        if (!change.response.content) {
-            throw this.newEmptyOrInvalidContentError(change);
-        }
-        const isOwnChange = this.parent.identity.isMe(core_1.CoreAddress.from(change.response.createdBy));
-        const cipher = RelationshipCreationChangeResponseCipher_1.RelationshipCreationChangeResponseCipher.fromBase64(change.response.content);
-        let signedResponseBuffer;
-        if (change.status !== RelationshipChangeStatus_1.RelationshipChangeStatus.Revoked) {
-            if (isOwnChange) {
-                signedResponseBuffer = await this.secrets.decryptOwn(relationshipSecretId, cipher.cipher);
-            }
-            else {
-                signedResponseBuffer = await this.secrets.decryptPeer(relationshipSecretId, cipher.cipher, true);
-            }
-        }
-        else {
-            signedResponseBuffer = await this.secrets.decryptRequest(relationshipSecretId, cipher.cipher);
-        }
-        const signedResponse = RelationshipCreationChangeResponseSigned_1.RelationshipCreationChangeResponseSigned.deserialize(signedResponseBuffer.toUtf8());
-        let relationshipSignatureValid;
-        if (isOwnChange) {
-            relationshipSignatureValid = await this.secrets.verifyOwn(relationshipSecretId, crypto_1.CoreBuffer.fromUtf8(signedResponse.serializedResponse), signedResponse.relationshipSignature);
-        }
-        else {
-            relationshipSignatureValid = await this.secrets.verifyPeer(relationshipSecretId, crypto_1.CoreBuffer.fromUtf8(signedResponse.serializedResponse), signedResponse.relationshipSignature);
-        }
-        if (!relationshipSignatureValid) {
-            throw CoreErrors_1.CoreErrors.general.signatureNotValid("relationshipResponse");
-        }
-        const responseContent = RelationshipCreationChangeResponseContentWrapper_1.RelationshipCreationChangeResponseContentWrapper.deserialize(signedResponse.serializedResponse);
-        if (!responseContent.relationshipId.equals(change.relationshipId)) {
-            throw new core_1.TransportError("The relationship response contains a wrong relationship id.");
-        }
-        return responseContent;
-    }
-    async updatePendingRelationshipWithPeerResponse(relationshipDoc, change) {
-        const relationship = Relationship_1.Relationship.from(relationshipDoc);
-        if (relationship.status !== RelationshipStatus_1.RelationshipStatus.Pending) {
-            this.log.debug("Trying to update non-pending relationship with creation change", change);
-            return;
-        }
-        if (!relationship.cache) {
-            await this.updateCacheOfRelationship(relationship, undefined);
+            throw CoreErrors_1.CoreErrors.general.signatureNotValid("relationshipCreationContent");
         }
-        if (!change.response)
-            throw this.newChangeResponseMissingError(change.id);
-        if (!change.response.content) {
-            throw this.newEmptyOrInvalidContentError(change);
-        }
-        const cipher = RelationshipCreationChangeResponseCipher_1.RelationshipCreationChangeResponseCipher.fromBase64(change.response.content);
-        if (change.status !== RelationshipChangeStatus_1.RelationshipChangeStatus.Revoked) {
-            if (!cipher.publicResponseCrypto) {
-                throw new core_1.TransportError("The response crypto is missing.");
-            }
-            await this.secrets.convertSecrets(relationship.relationshipSecretId, cipher.publicResponseCrypto);
-        }
-        const responseContent = await this.decryptCreationChangeResponse(change, relationship.relationshipSecretId);
-        const response = RelationshipChangeResponse_1.RelationshipChangeResponse.fromBackbone(change.response, responseContent.content);
-        if (!relationship.cache) {
-            throw this.newCacheEmptyError(Relationship_1.Relationship, relationship.id.toString());
-        }
-        relationship.cache.changes[0].status = change.status;
-        switch (change.status) {
-            case RelationshipChangeStatus_1.RelationshipChangeStatus.Accepted:
-                relationship.toActive(response);
-                break;
-            case RelationshipChangeStatus_1.RelationshipChangeStatus.Rejected:
-                relationship.toRejected(response);
-                break;
-            case RelationshipChangeStatus_1.RelationshipChangeStatus.Revoked:
-                relationship.toRevoked(response);
-                break;
-            default:
-                throw CoreErrors_1.CoreErrors.general.notSupported();
-        }
-        await this.relationships.update(relationshipDoc, relationship);
-        return relationship;
+        const creationContent = RelationshipCreationContentWrapper_1.RelationshipCreationContentWrapper.deserialize(signedCreationContent.serializedCreationContent);
+        return creationContent;
     }
-    async createNewRelationshipByIncomingCreationChange(change) {
-        const backboneRelationship = (await this.client.getRelationship(change.relationshipId)).value;
+    async createNewRelationshipByIncomingCreation(relationshipId) {
+        const backboneRelationship = (await this.client.getRelationship(relationshipId)).value;
+        if (!backboneRelationship.creationContent)
+            throw new core_1.TransportError("Creation content is missing");
         const templateId = core_1.CoreId.from(backboneRelationship.relationshipTemplateId);
         const template = await this.parent.relationshipTemplates.getRelationshipTemplate(templateId);
         if (!template)
             throw CoreErrors_1.CoreErrors.general.recordNotFound(RelationshipTemplate_1.RelationshipTemplate, templateId.toString());
         if (!template.cache)
             throw this.newCacheEmptyError(RelationshipTemplate_1.RelationshipTemplate, template.id.toString());
-        if (!change.request.content)
-            throw this.newEmptyOrInvalidContentError(change);
         const secretId = await TransportIds_1.TransportIds.relationshipSecret.generate();
-        const requestCipher = RelationshipCreationChangeRequestCipher_1.RelationshipCreationChangeRequestCipher.fromBase64(change.request.content);
-        await this.secrets.createTemplatorSecrets(secretId, template.cache, requestCipher.publicRequestCrypto);
-        const requestContent = await this.decryptCreationChangeRequest(backboneRelationship.changes[0].request, secretId, templateId);
-        const relationshipChange = RelationshipChange_1.RelationshipChange.fromBackbone(change, requestContent.content);
-        const relationship = Relationship_1.Relationship.fromCreationChangeReceived(backboneRelationship, template, requestContent.identity, relationshipChange, secretId);
+        const creationContentCipher = RelationshipCreationContentCipher_1.RelationshipCreationContentCipher.fromBase64(backboneRelationship.creationContent);
+        await this.secrets.createTemplatorSecrets(secretId, template.cache, creationContentCipher.publicCreationContentCrypto);
+        const creationContent = await this.decryptCreationContent(backboneRelationship.creationContent, core_1.CoreAddress.from(backboneRelationship.from), secretId);
+        const relationship = Relationship_1.Relationship.fromBackboneAndCreationContent(backboneRelationship, template, creationContent.identity, creationContent.content, secretId);
         await this.relationships.create(relationship);
         return relationship;
     }
-    async completeChange(targetStatus, change, content) {
-        const relationshipDoc = await this.relationships.read(change.relationshipId.toString());
+    async applyRelationshipChangedEvent(relationshipId) {
+        let relationshipDoc = await this.relationships.read(relationshipId);
         if (!relationshipDoc) {
-            throw CoreErrors_1.CoreErrors.general.recordNotFound(Relationship_1.Relationship, change.relationshipId.toString());
+            const newRelationship = await this.createNewRelationshipByIncomingCreation(relationshipId);
+            if (newRelationship.status === RelationshipStatus_1.RelationshipStatus.Pending) {
+                return newRelationship;
+            }
+            // this path is for a revocation that is processed before its corresponding creation
+            relationshipDoc = await this.relationships.read(relationshipId);
+        }
+        return await this.updateRelationshipWithPeerResponse(relationshipDoc);
+    }
+    async prepareCreationResponseContent(relationship) {
+        const publicCreationResponseContentCrypto = await this.secrets.getPublicCreationResponseContentCrypto(relationship.relationshipSecretId);
+        const creationResponseContent = RelationshipCreationResponseContentWrapper_1.RelationshipCreationResponseContentWrapper.from({ relationshipId: relationship.id });
+        const serializedCreationResponseContent = creationResponseContent.serialize();
+        const buffer = CoreUtil_1.CoreUtil.toBuffer(serializedCreationResponseContent);
+        const [deviceSignature, relationshipSignature] = await Promise.all([this.parent.activeDevice.sign(buffer), this.secrets.sign(relationship.relationshipSecretId, buffer)]);
+        const signedCreationResponseContent = RelationshipCreationResponseContentSigned_1.RelationshipCreationResponseContentSigned.from({
+            serializedCreationResponseContent,
+            deviceSignature,
+            relationshipSignature
+        });
+        const cipher = await this.secrets.encrypt(relationship.relationshipSecretId, signedCreationResponseContent);
+        const creationResponseContentCipher = RelationshipCreationResponseContentCipher_1.RelationshipCreationResponseContentCipher.from({
+            cipher,
+            publicCreationResponseContentCrypto
+        });
+        return creationResponseContentCipher.toBase64();
+    }
+    async completeOperationWithBackboneCall(operation, id) {
+        const relationshipDoc = await this.relationships.read(id.toString());
+        if (!relationshipDoc) {
+            throw CoreErrors_1.CoreErrors.general.recordNotFound(Relationship_1.Relationship, id.toString());
         }
         const relationship = Relationship_1.Relationship.from(relationshipDoc);
         if (!relationship.cache) {
             await this.updateCacheOfRelationship(relationship);
         }
         if (!relationship.cache) {
-            throw this.newCacheEmptyError(Relationship_1.Relationship, relationship.id.toString());
-        }
-        const queriedChange = relationship.cache.changes.find((r) => r.id.toString() === change.id.toString());
-        if (!queriedChange) {
-            throw CoreErrors_1.CoreErrors.general.recordNotFound(RelationshipChange_1.RelationshipChange, change.id.toString());
-        }
-        if (queriedChange.status !== RelationshipChangeStatus_1.RelationshipChangeStatus.Pending) {
-            throw CoreErrors_1.CoreErrors.relationships.wrongChangeStatus(queriedChange.status);
-        }
-        let encryptedContent;
-        if (content) {
-            encryptedContent =
-                targetStatus === RelationshipChangeStatus_1.RelationshipChangeStatus.Revoked
-                    ? await this.encryptRevokeContent(relationship, content)
-                    : await this.encryptAcceptRejectContent(relationship, content);
+            throw this.newCacheEmptyError(Relationship_1.Relationship, id.toString());
         }
         let backboneResponse;
-        switch (targetStatus) {
-            case RelationshipChangeStatus_1.RelationshipChangeStatus.Accepted:
-                backboneResponse = (await this.client.acceptRelationshipChange(relationship.id.toString(), change.id.toString(), encryptedContent)).value;
+        switch (operation) {
+            case RelationshipAuditLog_2.RelationshipAuditLogEntryReason.AcceptanceOfCreation:
+                const encryptedContent = await this.prepareCreationResponseContent(relationship);
+                backboneResponse = (await this.client.acceptRelationship(id.toString(), { creationResponseContent: encryptedContent })).value;
+                break;
+            case RelationshipAuditLog_2.RelationshipAuditLogEntryReason.RejectionOfCreation:
+                backboneResponse = (await this.client.rejectRelationship(id.toString())).value;
+                break;
+            case RelationshipAuditLog_2.RelationshipAuditLogEntryReason.RevocationOfCreation:
+                backboneResponse = (await this.client.revokeRelationship(id.toString())).value;
+                break;
+            case RelationshipAuditLog_2.RelationshipAuditLogEntryReason.Termination:
+                backboneResponse = (await this.client.terminateRelationship(id.toString())).value;
                 break;
-            case RelationshipChangeStatus_1.RelationshipChangeStatus.Rejected:
-                backboneResponse = (await this.client.rejectRelationshipChange(relationship.id.toString(), change.id.toString(), encryptedContent)).value;
+            case RelationshipAuditLog_2.RelationshipAuditLogEntryReason.ReactivationRequested:
+                backboneResponse = (await this.client.reactivateRelationship(id.toString())).value;
                 break;
-            case RelationshipChangeStatus_1.RelationshipChangeStatus.Revoked:
-                backboneResponse = (await this.client.revokeRelationshipChange(relationship.id.toString(), change.id.toString(), encryptedContent)).value;
+            case RelationshipAuditLog_2.RelationshipAuditLogEntryReason.AcceptanceOfReactivation:
+                backboneResponse = (await this.client.acceptRelationshipReactivation(id.toString())).value;
+                break;
+            case RelationshipAuditLog_2.RelationshipAuditLogEntryReason.RejectionOfReactivation:
+                backboneResponse = (await this.client.rejectRelationshipReactivation(id.toString())).value;
+                break;
+            case RelationshipAuditLog_2.RelationshipAuditLogEntryReason.RevocationOfReactivation:
+                backboneResponse = (await this.client.revokeRelationshipReactivation(id.toString())).value;
                 break;
             default:
-                throw new core_1.TransportError("target change status not supported");
+                throw new core_1.TransportError("operation not supported");
         }
-        const backboneChange = backboneResponse.changes[backboneResponse.changes.length - 1];
-        queriedChange.response = RelationshipChangeResponse_1.RelationshipChangeResponse.fromBackbone(backboneResponse.changes[backboneResponse.changes.length - 1].response, content);
-        queriedChange.status = backboneChange.status;
         relationship.status = backboneResponse.status;
+        relationship.cache.auditLog = RelationshipAuditLog_1.RelationshipAuditLog.fromBackboneAuditLog(backboneResponse.auditLog);
         await this.relationships.update(relationshipDoc, relationship);
-        this.eventBus.publish(new events_1.RelationshipChangedEvent(this.parent.identity.address.toString(), relationship));
+        this.publishEventAfterCompletedOperation(operation, relationship);
         return relationship;
     }
-    async encryptRevokeContent(relationship, content) {
-        const responseContent = RelationshipCreationChangeResponseContentWrapper_1.RelationshipCreationChangeResponseContentWrapper.from({
-            relationshipId: relationship.id,
-            content: content
-        });
-        const serializedResponse = responseContent.serialize();
-        const buffer = CoreUtil_1.CoreUtil.toBuffer(serializedResponse);
-        const [deviceSignature, relationshipSignature] = await Promise.all([this.parent.activeDevice.sign(buffer), this.secrets.sign(relationship.relationshipSecretId, buffer)]);
-        const signedResponse = RelationshipCreationChangeResponseSigned_1.RelationshipCreationChangeResponseSigned.from({
-            serializedResponse: serializedResponse,
-            deviceSignature: deviceSignature,
-            relationshipSignature: relationshipSignature
-        });
-        const cipher = await this.secrets.encryptRequest(relationship.relationshipSecretId, signedResponse);
-        const responseCipher = RelationshipCreationChangeResponseCipher_1.RelationshipCreationChangeResponseCipher.from({
-            cipher: cipher
-        });
-        return responseCipher.toBase64();
-    }
-    async encryptAcceptRejectContent(relationship, content) {
-        const publicResponseCrypto = await this.secrets.getPublicResponse(relationship.relationshipSecretId);
-        const responseContent = RelationshipCreationChangeResponseContentWrapper_1.RelationshipCreationChangeResponseContentWrapper.from({
-            relationshipId: relationship.id,
-            content: content
-        });
-        const serializedResponse = responseContent.serialize();
-        const buffer = CoreUtil_1.CoreUtil.toBuffer(serializedResponse);
-        const [deviceSignature, relationshipSignature] = await Promise.all([this.parent.activeDevice.sign(buffer), this.secrets.sign(relationship.relationshipSecretId, buffer)]);
-        const signedResponse = RelationshipCreationChangeResponseSigned_1.RelationshipCreationChangeResponseSigned.from({
-            serializedResponse: serializedResponse,
-            deviceSignature: deviceSignature,
-            relationshipSignature: relationshipSignature
-        });
-        const cipher = await this.secrets.encrypt(relationship.relationshipSecretId, signedResponse);
-        const responseCipher = RelationshipCreationChangeResponseCipher_1.RelationshipCreationChangeResponseCipher.from({
-            cipher: cipher,
-            publicResponseCrypto: publicResponseCrypto
-        });
-        return responseCipher.toBase64();
-    }
-    throwWrongChangeType(type) {
-        throw new core_1.TransportError(`The relationship change has the wrong type (${type}) to run this operation`);
-    }
-    newChangeResponseMissingError(changeId) {
-        return new core_1.TransportError(`The response of the relationship change (${changeId}) is missing`);
-    }
-    newEmptyOrInvalidContentError(change) {
-        return new core_1.TransportError(`The content property of the relationship change ${change?.id} is missing or invalid`);
+    publishEventAfterCompletedOperation(operation, relationship) {
+        this.eventBus.publish(new events_1.RelationshipChangedEvent(this.parent.identity.address.toString(), relationship));
+        switch (operation) {
+            case RelationshipAuditLog_2.RelationshipAuditLogEntryReason.ReactivationRequested:
+                this.eventBus.publish(new events_1.RelationshipReactivationRequestedEvent(this.parent.identity.address.toString(), relationship));
+                break;
+            case RelationshipAuditLog_2.RelationshipAuditLogEntryReason.RevocationOfReactivation:
+            case RelationshipAuditLog_2.RelationshipAuditLogEntryReason.AcceptanceOfReactivation:
+            case RelationshipAuditLog_2.RelationshipAuditLogEntryReason.RejectionOfReactivation:
+                this.eventBus.publish(new events_1.RelationshipReactivationCompletedEvent(this.parent.identity.address.toString(), relationship));
+                break;
+            default:
+        }
     }
 }
 exports.RelationshipsController = RelationshipsController;
@@ -497,7 +464,7 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Object]),
     __metadata("design:returntype", Promise)
-], RelationshipsController.prototype, "updateCacheOfExistingRelationshipInDb", null);
+], RelationshipsController.prototype, "updateExistingRelationshipInDb", null);
 __decorate([
     (0, ts_utils_1.log)(),
     __metadata("design:type", Function),
@@ -509,42 +476,23 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
-], RelationshipsController.prototype, "applyChange", null);
-__decorate([
-    (0, ts_utils_1.log)(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, core_1.CoreId, core_1.CoreId]),
-    __metadata("design:returntype", Promise)
-], RelationshipsController.prototype, "parseCreationChange", null);
+], RelationshipsController.prototype, "updateRelationshipWithPeerResponse", null);
 __decorate([
     (0, ts_utils_1.log)(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, core_1.CoreId,
-        core_1.CoreId]),
+    __metadata("design:paramtypes", [String, core_1.CoreAddress, core_1.CoreId]),
     __metadata("design:returntype", Promise)
-], RelationshipsController.prototype, "decryptCreationChangeRequest", null);
+], RelationshipsController.prototype, "decryptCreationContent", null);
 __decorate([
     (0, ts_utils_1.log)(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, core_1.CoreId]),
-    __metadata("design:returntype", Promise)
-], RelationshipsController.prototype, "decryptCreationChangeResponse", null);
-__decorate([
-    (0, ts_utils_1.log)(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], RelationshipsController.prototype, "updatePendingRelationshipWithPeerResponse", null);
-__decorate([
-    (0, ts_utils_1.log)(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
+    __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
-], RelationshipsController.prototype, "createNewRelationshipByIncomingCreationChange", null);
+], RelationshipsController.prototype, "createNewRelationshipByIncomingCreation", null);
 __decorate([
     (0, ts_utils_1.log)(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, RelationshipChange_1.RelationshipChange, Object]),
+    __metadata("design:paramtypes", [String, core_1.CoreId]),
     __metadata("design:returntype", Promise)
-], RelationshipsController.prototype, "completeChange", null);
+], RelationshipsController.prototype, "completeOperationWithBackboneCall", null);
 //# sourceMappingURL=RelationshipsController.js.map