@nmshd/consumption 7.0.0-openid4vc.6 → 7.1.0-openid4vc.1

package/dist/modules/attributes/AttributesController.js

@@ -50,21 +50,24 @@ const ConsumptionError_1 = require("../../consumption/ConsumptionError");
 const ConsumptionIds_1 = require("../../consumption/ConsumptionIds");
 const common_1 = require("../common");
 const events_1 = require("./events");
-const AttributeSuccessorParams_1 = require("./local/AttributeSuccessorParams");
+const AttributeForwardingDetails_1 = require("./local/AttributeForwardingDetails");
 const AttributeTagCollection_1 = require("./local/AttributeTagCollection");
-const CreateRepositoryAttributeParams_1 = require("./local/CreateRepositoryAttributeParams");
-const CreateSharedLocalAttributeCopyParams_1 = require("./local/CreateSharedLocalAttributeCopyParams");
-const CreateSharedLocalAttributeParams_1 = require("./local/CreateSharedLocalAttributeParams");
-const LocalAttribute_1 = require("./local/LocalAttribute");
-const LocalAttributeDeletionInfo_1 = require("./local/LocalAttributeDeletionInfo");
-const LocalAttributeShareInfo_1 = require("./local/LocalAttributeShareInfo");
+const LocalAttribute_1 = require("./local/attributeTypes/LocalAttribute");
+const OwnIdentityAttribute_1 = require("./local/attributeTypes/OwnIdentityAttribute");
+const OwnRelationshipAttribute_1 = require("./local/attributeTypes/OwnRelationshipAttribute");
+const PeerIdentityAttribute_1 = require("./local/attributeTypes/PeerIdentityAttribute");
+const PeerRelationshipAttribute_1 = require("./local/attributeTypes/PeerRelationshipAttribute");
+const ThirdPartyRelationshipAttribute_1 = require("./local/attributeTypes/ThirdPartyRelationshipAttribute");
+const deletionInfos_1 = require("./local/deletionInfos");
 const QueryTranslator_1 = require("./local/QueryTranslator");
+const successorParams_1 = require("./local/successorParams");
+const PeerRelationshipAttributeSuccessorParams_1 = require("./local/successorParams/PeerRelationshipAttributeSuccessorParams");
 class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseController {
-    constructor(parent, eventBus, identity, setDefaultRepositoryAttributes) {
+    constructor(parent, eventBus, identity, setDefaultOwnIdentityAttributes) {
         super(ConsumptionControllerName_1.ConsumptionControllerName.AttributesController, parent);
         this.eventBus = eventBus;
         this.identity = identity;
-        this.setDefaultRepositoryAttributes = setDefaultRepositoryAttributes;
+        this.setDefaultOwnIdentityAttributes = setDefaultOwnIdentityAttributes;
         this.ETAG_DB_KEY = "etag";
         this.CACHE_TIMESTAMP_DB_KEY = "cacheTimestamp";
         this.TAG_COLLECTION_DB_KEY = "tagCollection";
@@ -72,6 +75,7 @@ class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseCo
     async init() {
         await super.init();
         this.attributes = await this.parent.accountController.getSynchronizedCollection("Attributes");
+        this.forwardingDetails = await this.parent.accountController.getSynchronizedCollection("AttributeForwardingDetails");
         this.tagCollection = await this.parent.accountController.db.getCollection("TagCollection");
         this.attributeTagClient = new transport_1.TagClient(this.parent.transport.config, this.parent.accountController.authenticator, this.parent.transport.correlator);
         const tagDefinitionCacheExists = await this.tagCollection.exists({ name: this.TAG_COLLECTION_DB_KEY });
@@ -91,18 +95,22 @@ class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseCo
         });
         if (!result)
             return;
-        return LocalAttribute_1.LocalAttribute.from(result);
+        const attribute = LocalAttribute_1.LocalAttribute.from(result);
+        await this.updateNumberOfForwards(attribute);
+        return attribute;
     }
     async getLocalAttributes(query, hideTechnical = false) {
-        const enrichedQuery = this.enrichQuery(query, hideTechnical);
+        const enrichedQuery = this.addHideTechnicalToQuery(query, hideTechnical);
         const attributes = await this.attributes.find(enrichedQuery);
         const parsed = this.parseArray(attributes, LocalAttribute_1.LocalAttribute);
         const sorted = parsed.sort((a, b) => {
             return a.createdAt.compare(b.createdAt);
         });
+        for (const attribute of sorted)
+            await this.updateNumberOfForwards(attribute);
         return sorted;
     }
-    enrichQuery(query, hideTechnical) {
+    addHideTechnicalToQuery(query, hideTechnical) {
         if (!hideTechnical)
             return query;
         const hideTechnicalQuery = {
@@ -129,12 +137,7 @@ class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseCo
     async executeIQLQuery(query) {
         /* Fetch subset of attributes relevant for IQL queries. We filter for
          * identity attributes which are not shared. */
-        const envelopedAttributes = await this.attributes.find({
-            "content.@type": "IdentityAttribute",
-            shareInfo: {
-                $exists: false
-            }
-        });
+        const envelopedAttributes = await this.attributes.find({ "@type": "OwnIdentityAttribute" });
         /* Remove envelope from attributes and execute query. IQL makes no use
          * of the envelope data. */
         const attributes = envelopedAttributes.map((e) => {
@@ -144,6 +147,8 @@ class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseCo
         /* Map matched indices back to their respective attributes and return. */
         const matchedAttributes = indices.map((ii) => envelopedAttributes[ii]);
         const result = this.parseArray(matchedAttributes, LocalAttribute_1.LocalAttribute);
+        for (const attribute of result)
+            await this.updateNumberOfForwards(attribute);
         return result;
     }
     async executeRelationshipAttributeQuery(query) {
@@ -155,6 +160,8 @@ class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseCo
         }
         const attributes = await this.attributes.find(dbQuery);
         const attribute = attributes.length > 0 ? LocalAttribute_1.LocalAttribute.from(attributes[0]) : undefined;
+        if (attribute)
+            await this.updateNumberOfForwards(attribute);
         return attribute;
     }
     async executeThirdPartyRelationshipAttributeQuery(query) {
@@ -182,80 +189,45 @@ class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseCo
                 dbQuery = { $and: [dbQuery, recipientOrThirdPartyIsOwnerQuery] };
                 break;
         }
-        const attributes = await this.attributes.find(dbQuery);
-        return this.parseArray(attributes, LocalAttribute_1.LocalAttribute);
+        const attributeDocs = await this.attributes.find(dbQuery);
+        const attributes = this.parseArray(attributeDocs, LocalAttribute_1.LocalAttribute);
+        for (const attribute of attributes)
+            await this.updateNumberOfForwards(attribute);
+        return attributes;
     }
     async executeIdentityAttributeQuery(query) {
         const parsedQuery = content_1.IdentityAttributeQuery.from(query);
         const dbQuery = QueryTranslator_1.IdentityAttributeQueryTranslator.translate(parsedQuery);
         dbQuery["content.owner"] = this.identity.address.toString();
-        dbQuery["shareInfo"] = { $exists: false };
-        const attributes = await this.attributes.find(dbQuery);
-        return this.parseArray(attributes, LocalAttribute_1.LocalAttribute);
-    }
-    async createRepositoryAttribute(params) {
-        if (params.content.owner.toString() !== this.identity.address.toString()) {
-            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.wrongOwnerOfRepositoryAttribute();
-        }
-        const parsedParams = CreateRepositoryAttributeParams_1.CreateRepositoryAttributeParams.from(params);
-        const tagValidationResult = await this.validateTagsOfAttribute(parsedParams.content);
-        if (tagValidationResult.isError())
-            throw tagValidationResult.error;
-        const trimmedAttribute = {
-            ...parsedParams.content.toJSON(),
-            value: this.trimAttributeValue(parsedParams.content.value.toJSON())
-        };
-        parsedParams.content = content_1.IdentityAttribute.from(trimmedAttribute);
-        if (!this.validateAttributeCharacters(parsedParams.content)) {
-            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.forbiddenCharactersInAttribute("The Attribute contains forbidden characters.");
-        }
-        let localAttribute = LocalAttribute_1.LocalAttribute.from({
-            id: parsedParams.id ?? (await ConsumptionIds_1.ConsumptionIds.attribute.generate()),
+        const attributeDocs = await this.attributes.find(dbQuery);
+        const attributes = this.parseArray(attributeDocs, LocalAttribute_1.LocalAttribute);
+        for (const attribute of attributes)
+            await this.updateNumberOfForwards(attribute);
+        return attributes;
+    }
+    async createOwnIdentityAttribute(params) {
+        const attribute = this.trimAttribute(params.content);
+        if (!attribute.owner.equals(this.identity.address)) {
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.wrongOwnerOfAttribute("When creating an OwnIdentityAttribute, the owner must match the own address.");
+        }
+        await this.validateAttributeCreation(attribute);
+        let ownIdentityAttribute = OwnIdentityAttribute_1.OwnIdentityAttribute.from({
+            id: await ConsumptionIds_1.ConsumptionIds.attribute.generate(),
             createdAt: core_types_1.CoreDate.utc(),
-            content: parsedParams.content,
-            parentId: parsedParams.parentId
+            content: attribute
         });
-        await this.attributes.create(localAttribute);
-        if (this.setDefaultRepositoryAttributes) {
-            localAttribute = await this.setAsDefaultRepositoryAttribute(localAttribute, true);
-        }
-        if (localAttribute.content.value instanceof content_1.AbstractComplexValue) {
-            await this.createLocalAttributesForChildrenOfComplexAttribute(localAttribute);
-        }
-        this.eventBus.publish(new events_1.AttributeCreatedEvent(this.identity.address.toString(), localAttribute));
-        return localAttribute;
-    }
-    async createLocalAttributesForChildrenOfComplexAttribute(localAttribute) {
-        if (!(localAttribute.content instanceof content_1.IdentityAttribute)) {
-            throw new ConsumptionError_1.ConsumptionError("Only IdentityAttributes may have child Attributes.");
-        }
-        const childAttributeValues = Object.values(localAttribute.content.value).filter((p) => p instanceof content_1.AbstractAttributeValue);
-        for (const propertyValue of childAttributeValues) {
-            const childAttribute = content_1.IdentityAttribute.from({
-                ...localAttribute.content.toJSON(),
-                value: propertyValue.toJSON()
-            });
-            await this.createRepositoryAttribute({
-                content: childAttribute,
-                parentId: localAttribute.id
-            });
-        }
-    }
-    async setAsDefaultRepositoryAttribute(newDefaultAttribute, skipOverwrite) {
-        if (!this.setDefaultRepositoryAttributes)
-            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.setDefaultRepositoryAttributesIsDisabled();
-        if (!newDefaultAttribute.isRepositoryAttribute(this.identity.address)) {
-            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.isNotRepositoryAttribute(newDefaultAttribute.id);
-        }
+        await this.attributes.create(ownIdentityAttribute);
+        if (this.setDefaultOwnIdentityAttributes)
+            ownIdentityAttribute = await this.setAsDefaultOwnIdentityAttribute(ownIdentityAttribute, true);
+        ownIdentityAttribute.numberOfForwards = 0;
+        this.eventBus.publish(new events_1.AttributeCreatedEvent(this.identity.address.toString(), ownIdentityAttribute));
+        return ownIdentityAttribute;
+    }
+    async setAsDefaultOwnIdentityAttribute(newDefaultAttribute, skipOverwrite) {
+        if (!this.setDefaultOwnIdentityAttributes)
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.setDefaultOwnIdentityAttributesIsDisabled();
         if (newDefaultAttribute.isDefault)
             return newDefaultAttribute;
-        if (newDefaultAttribute.parentId) {
-            const parentAttribute = await this.getLocalAttribute(newDefaultAttribute.parentId);
-            if (!parentAttribute)
-                throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, newDefaultAttribute.parentId.toString());
-            if (parentAttribute.isDefault)
-                skipOverwrite = false;
-        }
         const valueType = newDefaultAttribute.content.value.constructor.name;
         const query = {
             $and: [
@@ -267,7 +239,7 @@ class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseCo
                 }
             ]
         };
-        const currentDefaultAttributeResult = await this.getLocalAttributes(query);
+        const currentDefaultAttributeResult = (await this.getLocalAttributes(query));
         if (currentDefaultAttributeResult.length > 1) {
             throw new ConsumptionError_1.ConsumptionError(`There are multiple default Attributes for type ${valueType.toString()}, even though only one is expected.`);
         }
@@ -283,531 +255,359 @@ class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseCo
         await this.updateAttributeUnsafe(newDefaultAttribute);
         return newDefaultAttribute;
     }
-    async createSharedLocalAttributeCopy(params) {
-        const parsedParams = CreateSharedLocalAttributeCopyParams_1.CreateSharedLocalAttributeCopyParams.from(params);
-        const sourceAttribute = await this.getLocalAttribute(parsedParams.sourceAttributeId);
-        if (!sourceAttribute) {
-            throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, parsedParams.sourceAttributeId.toString());
-        }
-        const shareInfo = LocalAttributeShareInfo_1.LocalAttributeShareInfo.from({
-            peer: parsedParams.peer,
-            requestReference: parsedParams.requestReference,
-            sourceAttribute: parsedParams.sourceAttributeId,
-            thirdPartyAddress: sourceAttribute.shareInfo?.peer
-        });
-        const sharedLocalAttributeCopy = await LocalAttribute_1.LocalAttribute.fromAttribute(sourceAttribute.content, undefined, shareInfo, parsedParams.attributeId);
-        await this.attributes.create(sharedLocalAttributeCopy);
-        this.eventBus.publish(new events_1.SharedAttributeCopyCreatedEvent(this.identity.address.toString(), sharedLocalAttributeCopy));
-        return sharedLocalAttributeCopy;
-    }
-    async createSharedLocalAttribute(params) {
-        const parsedParams = CreateSharedLocalAttributeParams_1.CreateSharedLocalAttributeParams.from(params);
-        const tagValidationResult = await this.validateTagsOfAttribute(parsedParams.content);
-        if (tagValidationResult.isError())
-            throw tagValidationResult.error;
-        const shareInfo = LocalAttributeShareInfo_1.LocalAttributeShareInfo.from({
+    async updateAttributeUnsafe(attribute) {
+        const doc = await this.attributes.findOne({ [(0, ts_simple_nameof_1.nameof)((c) => c.id)]: attribute.id.toString() });
+        if (!doc)
+            throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, attribute.id.toString());
+        await this.attributes.update(doc, attribute);
+        return attribute;
+    }
+    async createPeerIdentityAttribute(params) {
+        const attribute = this.trimAttribute(params.content);
+        if (attribute.owner.equals(this.identity.address)) {
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.wrongOwnerOfAttribute("When creating a PeerIdentityAttribute, the owner must not match the own address.");
+        }
+        if (!attribute.owner.equals(params.peer)) {
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.wrongOwnerOfAttribute("When creating a PeerIdentityAttribute, the owner must match the address of the peer.");
+        }
+        await this.validateAttributeCreation(attribute);
+        const peerIdentityAttribute = PeerIdentityAttribute_1.PeerIdentityAttribute.from({
+            id: params.id,
+            content: attribute,
             peer: params.peer,
-            requestReference: params.requestReference,
-            thirdPartyAddress: params.thirdPartyAddress
-        });
-        const peerLocalAttribute = LocalAttribute_1.LocalAttribute.from({
-            id: params.id ?? (await ConsumptionIds_1.ConsumptionIds.attribute.generate()),
-            content: params.content,
-            shareInfo: shareInfo,
+            sourceReference: params.sourceReference,
             createdAt: core_types_1.CoreDate.utc()
         });
-        await this.attributes.create(peerLocalAttribute);
-        this.eventBus.publish(new events_1.AttributeCreatedEvent(this.identity.address.toString(), peerLocalAttribute));
-        return peerLocalAttribute;
+        await this.attributes.create(peerIdentityAttribute);
+        this.eventBus.publish(new events_1.AttributeCreatedEvent(this.identity.address.toString(), peerIdentityAttribute));
+        return peerIdentityAttribute;
     }
-    async deleteAttribute(attribute) {
-        if (attribute.content instanceof content_1.IdentityAttribute && attribute.content.value instanceof content_1.AbstractComplexValue) {
-            await this.deleteChildAttributesOfComplexAttribute(attribute);
+    async createOwnRelationshipAttribute(params) {
+        const attribute = params.content;
+        if (!attribute.owner.equals(this.identity.address)) {
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.wrongOwnerOfAttribute("When creating an OwnRelationshipAttribute, the owner must match the own address.");
         }
-        await this.deleteAttributeUnsafe(attribute.id);
-        this.eventBus.publish(new events_1.AttributeDeletedEvent(this.identity.address.toString(), attribute));
-    }
-    async deleteAttributesExchangedWithPeer(peer) {
-        const attributes = await this.getLocalAttributes({ "shareInfo.peer": peer.toString() });
-        for (const attribute of attributes) {
-            await this.deleteAttributeUnsafe(attribute.id);
+        if (params.peer.equals(this.identity.address)) {
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.wrongOwnerOfAttribute("When creating an OwnRelationshipAttribute, the peer must not match the own address.");
         }
+        await this.validateAttributeCreation(attribute);
+        const ownRelationshipAttribute = OwnRelationshipAttribute_1.OwnRelationshipAttribute.from({
+            id: params.id ?? (await ConsumptionIds_1.ConsumptionIds.attribute.generate()),
+            content: attribute,
+            peer: params.peer,
+            sourceReference: params.sourceReference,
+            createdAt: core_types_1.CoreDate.utc()
+        });
+        await this.attributes.create(ownRelationshipAttribute);
+        ownRelationshipAttribute.numberOfForwards = 0;
+        this.eventBus.publish(new events_1.AttributeCreatedEvent(this.identity.address.toString(), ownRelationshipAttribute));
+        return ownRelationshipAttribute;
     }
-    async deleteChildAttributesOfComplexAttribute(complexAttribute) {
-        if (!(complexAttribute.content instanceof content_1.IdentityAttribute)) {
-            throw new ConsumptionError_1.ConsumptionError("Only IdentityAttributes may have child Attributes.");
-        }
-        const childAttributes = await this.getLocalAttributes({ parentId: complexAttribute.id.toString() });
-        for (const childAttribute of childAttributes) {
-            await this.deleteAttribute(childAttribute);
+    async createPeerRelationshipAttribute(params) {
+        const attribute = params.content;
+        if (attribute.owner.equals(this.identity.address)) {
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.wrongOwnerOfAttribute("When creating a PeerRelationshipAttribute, the owner must not match the own address.");
         }
-    }
-    async succeedRepositoryAttribute(predecessorId, successorParams, validate = true) {
-        const parsedSuccessorParams = AttributeSuccessorParams_1.AttributeSuccessorParams.from(successorParams);
-        const trimmedAttribute = {
-            ...parsedSuccessorParams.content.toJSON(),
-            value: this.trimAttributeValue(parsedSuccessorParams.content.value.toJSON())
-        };
-        parsedSuccessorParams.content = content_1.IdentityAttribute.from(trimmedAttribute);
-        if (validate) {
-            const validationResult = await this.validateRepositoryAttributeSuccession(predecessorId, parsedSuccessorParams);
-            if (validationResult.isError())
-                throw validationResult.error;
+        if (!attribute.owner.equals(params.peer)) {
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.wrongOwnerOfAttribute("When creating a PeerRelationshipAttribute, the owner must match the address of the peer.");
         }
-        const { predecessor, successor } = await this._succeedAttributeUnsafe(predecessorId, {
-            id: parsedSuccessorParams.id,
-            content: parsedSuccessorParams.content,
-            succeeds: predecessorId,
-            shareInfo: parsedSuccessorParams.shareInfo,
-            parentId: parsedSuccessorParams.parentId,
-            createdAt: parsedSuccessorParams.createdAt,
-            succeededBy: parsedSuccessorParams.succeededBy
+        await this.validateAttributeCreation(attribute);
+        const peerRelationshipAttribute = PeerRelationshipAttribute_1.PeerRelationshipAttribute.from({
+            id: params.id ?? (await ConsumptionIds_1.ConsumptionIds.attribute.generate()),
+            content: attribute,
+            peer: params.peer,
+            sourceReference: params.sourceReference,
+            createdAt: core_types_1.CoreDate.utc()
         });
-        if (predecessor.isComplexAttribute()) {
-            await this.succeedChildrenOfComplexAttribute(successor.id);
-        }
-        this.eventBus.publish(new events_1.RepositoryAttributeSucceededEvent(this.identity.address.toString(), predecessor, successor));
-        return { predecessor, successor };
+        await this.attributes.create(peerRelationshipAttribute);
+        peerRelationshipAttribute.numberOfForwards = 0;
+        this.eventBus.publish(new events_1.AttributeCreatedEvent(this.identity.address.toString(), peerRelationshipAttribute));
+        return peerRelationshipAttribute;
+    }
+    async createThirdPartyRelationshipAttribute(params) {
+        const attribute = params.content;
+        if (attribute.owner.equals(this.identity.address)) {
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.wrongOwnerOfAttribute("When creating a ThirdPartyRelationshipAttribute, the owner must not match the own address.");
+        }
+        if (!(attribute.owner.equals(params.peer) || attribute.owner.equals(params.initialAttributePeer))) {
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.wrongOwnerOfAttribute("When creating a ThirdPartyRelationshipAttribute, the owner must match the address of the peer or initial Attribute peer.");
+        }
+        if (params.peer.equals(params.initialAttributePeer)) {
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.wrongOwnerOfAttribute("When creating a ThirdPartyRelationshipAttribute, the peer must not match the initialAttributePeer.");
+        }
+        await this.validateAttributeCreation(attribute);
+        const thirdPartyRelationshipAttribute = ThirdPartyRelationshipAttribute_1.ThirdPartyRelationshipAttribute.from({
+            id: params.id,
+            content: attribute,
+            peer: params.peer,
+            sourceReference: params.sourceReference,
+            initialAttributePeer: params.initialAttributePeer,
+            createdAt: core_types_1.CoreDate.utc()
+        });
+        await this.attributes.create(thirdPartyRelationshipAttribute);
+        this.eventBus.publish(new events_1.AttributeCreatedEvent(this.identity.address.toString(), thirdPartyRelationshipAttribute));
+        return thirdPartyRelationshipAttribute;
     }
-    async succeedOwnSharedIdentityAttribute(predecessorId, successorParams, validate = true) {
-        const parsedSuccessorParams = AttributeSuccessorParams_1.AttributeSuccessorParams.from(successorParams);
+    async validateAttributeCreation(attribute) {
+        if (!this.validateAttributeCharacters(attribute))
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.forbiddenCharactersInAttribute("The Attribute contains forbidden characters.");
+        if (attribute instanceof content_1.RelationshipAttribute)
+            return;
+        const tagValidationResult = await this.validateTagsOfAttribute(attribute);
+        if (tagValidationResult.isError())
+            throw tagValidationResult.error;
+    }
+    async addForwardingDetailsToAttribute(attribute, peer, sourceReference) {
+        if (await this.isAttributeForwardedToPeer(attribute, peer, true))
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.alreadyForwarded(attribute.id, peer);
+        const existingForwardingDetails = await this.getForwardingDetailsForPeer(attribute, peer, true);
+        const forwardingDetails = existingForwardingDetails
+            ? (() => {
+                existingForwardingDetails.deletionInfo = undefined;
+                return existingForwardingDetails;
+            })()
+            : AttributeForwardingDetails_1.AttributeForwardingDetails.from({
+                id: await ConsumptionIds_1.ConsumptionIds.attributeForwardingDetails.generate(),
+                attributeId: attribute.id,
+                peer,
+                sourceReference,
+                sharedAt: core_types_1.CoreDate.utc()
+            });
+        await this.upsertForwardingDetailsForPeer(attribute, peer, forwardingDetails);
+        this.eventBus.publish(new events_1.AttributeForwardingDetailsChangedEvent(this.identity.address.toString(), attribute));
+        return attribute;
+    }
+    async succeedOwnIdentityAttribute(predecessor, successorParams, validate = true) {
+        const parsedSuccessorParams = successorParams_1.OwnIdentityAttributeSuccessorParams.from(successorParams);
+        const attribute = this.trimAttribute(parsedSuccessorParams.content);
         if (validate) {
-            const validationResult = await this.validateOwnSharedIdentityAttributeSuccession(predecessorId, parsedSuccessorParams);
+            const validationResult = await this.validateOwnIdentityAttributeSuccession(predecessor, parsedSuccessorParams);
             if (validationResult.isError())
                 throw validationResult.error;
         }
-        const { predecessor, successor } = await this._succeedAttributeUnsafe(predecessorId, {
-            id: parsedSuccessorParams.id,
-            content: parsedSuccessorParams.content,
-            succeeds: predecessorId,
-            shareInfo: parsedSuccessorParams.shareInfo,
-            parentId: parsedSuccessorParams.parentId,
-            createdAt: parsedSuccessorParams.createdAt,
-            succeededBy: parsedSuccessorParams.succeededBy
+        const successor = OwnIdentityAttribute_1.OwnIdentityAttribute.from({
+            id: await ConsumptionIds_1.ConsumptionIds.attribute.generate(),
+            content: attribute,
+            createdAt: core_types_1.CoreDate.utc(),
+            succeeds: predecessor.id,
+            isDefault: predecessor.isDefault
         });
-        this.eventBus.publish(new events_1.OwnSharedAttributeSucceededEvent(this.identity.address.toString(), predecessor, successor));
+        await this.succeedAttributeUnsafe(predecessor, successor);
+        await this.removeDefault(predecessor);
+        successor.numberOfForwards = 0;
+        this.eventBus.publish(new events_1.AttributeSucceededEvent(this.identity.address.toString(), predecessor, successor));
         return { predecessor, successor };
     }
-    async succeedOwnSharedRelationshipAttribute(predecessorId, successorParams, validate = true) {
-        const parsedSuccessorParams = AttributeSuccessorParams_1.AttributeSuccessorParams.from(successorParams);
+    async succeedAttributeUnsafe(predecessor, successor) {
+        await this.attributes.create(successor);
+        predecessor.succeededBy = successor.id;
+        await this.updateAttributeUnsafe(predecessor);
+    }
+    async removeDefault(attribute) {
+        if (!attribute.isDefault)
+            return attribute;
+        attribute.isDefault = undefined;
+        await this.updateAttributeUnsafe(attribute);
+        return attribute;
+    }
+    async succeedPeerIdentityAttribute(predecessor, successorParams, validate = true) {
+        const parsedSuccessorParams = successorParams_1.PeerIdentityAttributeSuccessorParams.from(successorParams);
+        const attribute = this.trimAttribute(parsedSuccessorParams.content);
         if (validate) {
-            const validationResult = await this.validateOwnSharedRelationshipAttributeSuccession(predecessorId, parsedSuccessorParams);
+            const validationResult = await this.validatePeerIdentityAttributeSuccession(predecessor, parsedSuccessorParams);
             if (validationResult.isError())
                 throw validationResult.error;
         }
-        const { predecessor, successor } = await this._succeedAttributeUnsafe(predecessorId, {
+        const successor = PeerIdentityAttribute_1.PeerIdentityAttribute.from({
             id: parsedSuccessorParams.id,
-            content: parsedSuccessorParams.content,
-            succeeds: predecessorId,
-            shareInfo: parsedSuccessorParams.shareInfo,
-            parentId: parsedSuccessorParams.parentId,
-            createdAt: parsedSuccessorParams.createdAt,
-            succeededBy: parsedSuccessorParams.succeededBy
+            content: attribute,
+            createdAt: core_types_1.CoreDate.utc(),
+            succeeds: predecessor.id,
+            peer: predecessor.peer,
+            sourceReference: parsedSuccessorParams.sourceReference
         });
-        this.eventBus.publish(new events_1.OwnSharedAttributeSucceededEvent(this.identity.address.toString(), predecessor, successor));
+        await this.succeedAttributeUnsafe(predecessor, successor);
         return { predecessor, successor };
     }
-    async succeedPeerSharedIdentityAttribute(predecessorId, successorParams, validate = true) {
-        const parsedSuccessorParams = AttributeSuccessorParams_1.AttributeSuccessorParams.from(successorParams);
+    async succeedOwnRelationshipAttribute(predecessor, successorParams, validate = true) {
+        const parsedSuccessorParams = successorParams_1.OwnRelationshipAttributeSuccessorParams.from(successorParams);
         if (validate) {
-            const validationResult = await this.validatePeerSharedIdentityAttributeSuccession(predecessorId, parsedSuccessorParams);
+            const validationResult = await this.validateOwnRelationshipAttributeSuccession(predecessor, parsedSuccessorParams);
             if (validationResult.isError())
                 throw validationResult.error;
         }
-        const { predecessor, successor } = await this._succeedAttributeUnsafe(predecessorId, {
-            id: parsedSuccessorParams.id,
+        const successor = OwnRelationshipAttribute_1.OwnRelationshipAttribute.from({
+            id: await ConsumptionIds_1.ConsumptionIds.attribute.generate(),
             content: parsedSuccessorParams.content,
-            succeeds: predecessorId,
-            shareInfo: parsedSuccessorParams.shareInfo,
-            parentId: parsedSuccessorParams.parentId,
-            createdAt: parsedSuccessorParams.createdAt,
-            succeededBy: parsedSuccessorParams.succeededBy
+            createdAt: core_types_1.CoreDate.utc(),
+            succeeds: predecessor.id,
+            peer: predecessor.peer,
+            sourceReference: parsedSuccessorParams.sourceReference
         });
-        /* No succeeded attribute event fired here. This is done by the notification system. */
+        await this.succeedAttributeUnsafe(predecessor, successor);
+        successor.numberOfForwards = 0;
+        this.eventBus.publish(new events_1.AttributeSucceededEvent(this.identity.address.toString(), predecessor, successor));
         return { predecessor, successor };
     }
-    async succeedPeerSharedRelationshipAttribute(predecessorId, successorParams, validate = true) {
-        const parsedSuccessorParams = AttributeSuccessorParams_1.AttributeSuccessorParams.from(successorParams);
+    async succeedPeerRelationshipAttribute(predecessor, successorParams, validate = true) {
+        const parsedSuccessorParams = PeerRelationshipAttributeSuccessorParams_1.PeerRelationshipAttributeSuccessorParams.from(successorParams);
         if (validate) {
-            const validationResult = await this.validatePeerSharedRelationshipAttributeSuccession(predecessorId, parsedSuccessorParams);
+            const validationResult = await this.validatePeerRelationshipAttributeSuccession(predecessor, parsedSuccessorParams);
             if (validationResult.isError())
                 throw validationResult.error;
         }
-        const { predecessor, successor } = await this._succeedAttributeUnsafe(predecessorId, {
+        const successor = PeerRelationshipAttribute_1.PeerRelationshipAttribute.from({
             id: parsedSuccessorParams.id,
             content: parsedSuccessorParams.content,
-            succeeds: predecessorId,
-            shareInfo: parsedSuccessorParams.shareInfo,
-            parentId: parsedSuccessorParams.parentId,
-            createdAt: parsedSuccessorParams.createdAt,
-            succeededBy: parsedSuccessorParams.succeededBy
+            createdAt: core_types_1.CoreDate.utc(),
+            succeeds: predecessor.id,
+            peer: predecessor.peer,
+            sourceReference: parsedSuccessorParams.sourceReference
         });
-        /* No succeeded attribute event fired here. This is done by the notification system. */
+        await this.succeedAttributeUnsafe(predecessor, successor);
+        successor.numberOfForwards = 0;
         return { predecessor, successor };
     }
-    async succeedThirdPartyRelationshipAttribute(predecessorId, successorParams, validate = true) {
-        const parsedSuccessorParams = AttributeSuccessorParams_1.AttributeSuccessorParams.from(successorParams);
+    async succeedThirdPartyRelationshipAttribute(predecessor, successorParams, validate = true) {
+        const parsedSuccessorParams = successorParams_1.ThirdPartyRelationshipAttributeSuccessorParams.from(successorParams);
         if (validate) {
-            const validationResult = await this.validateThirdPartyRelationshipAttributeSuccession(predecessorId, parsedSuccessorParams);
-            if (validationResult.isError()) {
+            const validationResult = await this.validateThirdPartyRelationshipAttributeSuccession(predecessor, parsedSuccessorParams);
+            if (validationResult.isError())
                 throw validationResult.error;
-            }
         }
-        const { predecessor, successor } = await this._succeedAttributeUnsafe(predecessorId, {
+        const successor = ThirdPartyRelationshipAttribute_1.ThirdPartyRelationshipAttribute.from({
             id: parsedSuccessorParams.id,
             content: parsedSuccessorParams.content,
-            succeeds: predecessorId,
-            shareInfo: parsedSuccessorParams.shareInfo,
-            parentId: parsedSuccessorParams.parentId,
-            createdAt: parsedSuccessorParams.createdAt,
-            succeededBy: parsedSuccessorParams.succeededBy
-        });
-        this.eventBus.publish(new events_1.ThirdPartyRelationshipAttributeSucceededEvent(this.identity.address.toString(), predecessor, successor));
-        return { predecessor, successor };
-    }
-    async succeedChildrenOfComplexAttribute(parentSuccessorId) {
-        const parentSuccessor = await this.getLocalAttribute(parentSuccessorId);
-        if (!parentSuccessor)
-            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.invalidParentSuccessor(parentSuccessorId);
-        const childAttributeValues = Object.values(parentSuccessor.content.value).filter((elem) => elem instanceof content_1.AbstractAttributeValue);
-        for (const childAttributeValue of childAttributeValues) {
-            let currentParent = await this.getLocalAttribute(parentSuccessorId);
-            let child;
-            while (!child && currentParent?.succeeds) {
-                const currentPredecessor = (await this.getLocalAttribute(currentParent.succeeds));
-                currentParent = currentPredecessor;
-                child = await this.getChildAttributesByValueType(currentParent.id, childAttributeValue.constructor);
-            }
-            const childPredecessorId = child?.id;
-            if (childPredecessorId) {
-                await this._succeedAttributeUnsafe(childPredecessorId, {
-                    content: content_1.IdentityAttribute.from({
-                        value: childAttributeValue.toJSON(),
-                        owner: this.identity.address
-                    }),
-                    parentId: parentSuccessorId,
-                    createdAt: parentSuccessor.createdAt
-                });
-            }
-            else {
-                await this.createAttributeUnsafe({
-                    content: content_1.IdentityAttribute.from({
-                        value: childAttributeValue.toJSON(),
-                        owner: this.identity.address
-                    }),
-                    parentId: parentSuccessorId,
-                    createdAt: parentSuccessor.createdAt
-                });
-            }
-        }
-    }
-    async getChildAttributesByValueType(parentId, valueType) {
-        const children = await this.getLocalAttributes({
-            parentId: parentId.toString()
-        });
-        /** We currently assume that all of the child attributes of a complex
-         * attribute have distinct types. */
-        return children.find((elem) => elem.content.value instanceof valueType);
-    }
-    async _succeedAttributeUnsafe(predecessorId, successorParams) {
-        const predecessor = await this.getLocalAttribute(predecessorId);
-        if (!predecessor)
-            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.predecessorDoesNotExist();
-        const successor = await this.createAttributeUnsafe({
-            id: successorParams.id,
-            content: successorParams.content,
-            succeeds: predecessorId,
-            shareInfo: successorParams.shareInfo,
-            parentId: successorParams.parentId,
-            createdAt: successorParams.createdAt,
-            succeededBy: successorParams.succeededBy,
-            isDefault: predecessor.isDefault
+            createdAt: core_types_1.CoreDate.utc(),
+            succeeds: predecessor.id,
+            peer: predecessor.peer,
+            sourceReference: parsedSuccessorParams.sourceReference,
+            initialAttributePeer: predecessor.initialAttributePeer
         });
-        await this.removeDefault(predecessor);
-        predecessor.succeededBy = successor.id;
-        await this.updateAttributeUnsafe(predecessor);
+        await this.succeedAttributeUnsafe(predecessor, successor);
+        this.eventBus.publish(new events_1.AttributeSucceededEvent(this.identity.address.toString(), predecessor, successor));
         return { predecessor, successor };
     }
-    async removeDefault(attribute) {
-        if (!attribute.isDefault)
-            return attribute;
-        attribute.isDefault = undefined;
-        await this.updateAttributeUnsafe(attribute);
-        return attribute;
-    }
-    async validateRepositoryAttributeSuccession(predecessorId, successorParams) {
+    async validateOwnIdentityAttributeSuccession(predecessor, successorParams) {
         let parsedSuccessorParams;
         try {
-            parsedSuccessorParams = AttributeSuccessorParams_1.AttributeSuccessorParams.from(successorParams);
+            parsedSuccessorParams = successorParams_1.OwnIdentityAttributeSuccessorParams.from(successorParams);
         }
         catch (e) {
             return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorIsNotAValidAttribute(e));
         }
-        const commonValidation = await this.validateAttributeSuccessionCommon(predecessorId, parsedSuccessorParams);
-        if (commonValidation.isError())
-            return commonValidation;
-        const predecessor = (await this.getLocalAttribute(predecessorId));
-        const successor = LocalAttribute_1.LocalAttribute.from({
-            id: core_types_1.CoreId.from(parsedSuccessorParams.id ?? "dummy"),
+        const tagValidationResult = await this.validateTagsOfAttribute(parsedSuccessorParams.content);
+        if (tagValidationResult.isError())
+            throw tagValidationResult.error;
+        const successor = OwnIdentityAttribute_1.OwnIdentityAttribute.from({
+            id: await ConsumptionIds_1.ConsumptionIds.attribute.generate(),
             content: parsedSuccessorParams.content,
-            createdAt: parsedSuccessorParams.createdAt ?? core_types_1.CoreDate.utc(),
-            succeeds: parsedSuccessorParams.succeeds,
-            succeededBy: parsedSuccessorParams.succeededBy,
-            shareInfo: parsedSuccessorParams.shareInfo,
-            parentId: parsedSuccessorParams.parentId
+            createdAt: core_types_1.CoreDate.utc(),
+            succeeds: predecessor.id
         });
-        if (!predecessor.isRepositoryAttribute(this.identity.address)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.predecessorIsNotRepositoryAttribute());
-        }
-        if (!successor.isRepositoryAttribute(this.identity.address)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorIsNotRepositoryAttribute());
-        }
-        return common_1.ValidationResult.success();
+        return await this.validateAttributeSuccession(predecessor, successor);
     }
-    async validateOwnSharedIdentityAttributeSuccession(predecessorId, successorParams) {
+    async validatePeerIdentityAttributeSuccession(predecessor, successorParams) {
         let parsedSuccessorParams;
         try {
-            parsedSuccessorParams = AttributeSuccessorParams_1.AttributeSuccessorParams.from(successorParams);
+            parsedSuccessorParams = successorParams_1.PeerIdentityAttributeSuccessorParams.from(successorParams);
         }
         catch (e) {
             return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorIsNotAValidAttribute(e));
         }
-        const commonValidation = await this.validateAttributeSuccessionCommon(predecessorId, parsedSuccessorParams);
-        if (commonValidation.isError())
-            return commonValidation;
-        const predecessor = (await this.getLocalAttribute(predecessorId));
-        const successor = LocalAttribute_1.LocalAttribute.from({
-            id: core_types_1.CoreId.from(parsedSuccessorParams.id ?? "dummy"),
+        const successor = PeerIdentityAttribute_1.PeerIdentityAttribute.from({
+            id: parsedSuccessorParams.id,
             content: parsedSuccessorParams.content,
-            createdAt: parsedSuccessorParams.createdAt ?? core_types_1.CoreDate.utc(),
-            succeeds: parsedSuccessorParams.succeeds,
-            succeededBy: parsedSuccessorParams.succeededBy,
-            shareInfo: parsedSuccessorParams.shareInfo,
-            parentId: parsedSuccessorParams.parentId
+            createdAt: core_types_1.CoreDate.utc(),
+            succeeds: predecessor.id,
+            peer: predecessor.peer,
+            sourceReference: parsedSuccessorParams.sourceReference
         });
-        if (!predecessor.isOwnSharedIdentityAttribute(this.identity.address)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.predecessorIsNotOwnSharedIdentityAttribute());
-        }
-        if (!successor.isOwnSharedIdentityAttribute(this.identity.address)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorIsNotOwnSharedIdentityAttribute());
-        }
-        if (!predecessor.shareInfo.peer.equals(successor.shareInfo.peer)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successionMustNotChangePeer());
-        }
-        if (!successor.shareInfo.sourceAttribute) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorSourceAttributeIsNotSpecified());
+        if (predecessor.deletionInfo?.deletionStatus === deletionInfos_1.ReceivedAttributeDeletionStatus.DeletedByEmitter) {
+            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.cannotSucceedSharedAttributesDeletedByPeer());
         }
-        const successorSource = await this.getLocalAttribute(successor.shareInfo.sourceAttribute);
-        if (!successorSource) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorSourceAttributeDoesNotExist());
-        }
-        if (!successorSource.isRepositoryAttribute(this.identity.address)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorSourceAttributeIsNotRepositoryAttribute());
-        }
-        if (!lodash_1.default.isEqual(successorSource.content.toJSON(), successor.content.toJSON())) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorSourceContentIsNotEqualToCopyContent());
-        }
-        const predecessorSource = predecessor.shareInfo.sourceAttribute ? await this.getLocalAttribute(predecessor.shareInfo.sourceAttribute) : undefined;
-        if (predecessorSource) {
-            if (!predecessorSource.isRepositoryAttribute(this.identity.address)) {
-                return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.predecessorSourceAttributeIsNotRepositoryAttribute());
-            }
-            const successorSourceVersionIds = (await this.getVersionsOfAttribute(successorSource.id)).map((x) => x.id.toString());
-            if (!predecessorSource.succeededBy || !successorSourceVersionIds.some((id) => id === predecessorSource.succeededBy?.toString())) {
-                return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorSourceDoesNotSucceedPredecessorSource());
-            }
-            if (!lodash_1.default.isEqual(predecessorSource.content.toJSON(), predecessor.content.toJSON())) {
-                return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.predecessorSourceContentIsNotEqualToCopyContent());
-            }
-        }
-        return common_1.ValidationResult.success();
+        return await this.validateAttributeSuccession(predecessor, successor);
     }
-    async validateOwnSharedRelationshipAttributeSuccession(predecessorId, successorParams) {
+    async validateOwnRelationshipAttributeSuccession(predecessor, successorParams) {
         let parsedSuccessorParams;
         try {
-            parsedSuccessorParams = AttributeSuccessorParams_1.AttributeSuccessorParams.from(successorParams);
+            parsedSuccessorParams = successorParams_1.OwnRelationshipAttributeSuccessorParams.from(successorParams);
         }
         catch (e) {
             return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorIsNotAValidAttribute(e));
         }
-        const commonValidation = await this.validateAttributeSuccessionCommon(predecessorId, parsedSuccessorParams);
-        if (commonValidation.isError())
-            return commonValidation;
-        const predecessor = (await this.getLocalAttribute(predecessorId));
-        const successor = LocalAttribute_1.LocalAttribute.from({
-            id: core_types_1.CoreId.from(parsedSuccessorParams.id ?? "dummy"),
+        const successor = OwnRelationshipAttribute_1.OwnRelationshipAttribute.from({
+            id: await ConsumptionIds_1.ConsumptionIds.attribute.generate(),
             content: parsedSuccessorParams.content,
-            createdAt: parsedSuccessorParams.createdAt ?? core_types_1.CoreDate.utc(),
-            succeeds: parsedSuccessorParams.succeeds,
-            succeededBy: parsedSuccessorParams.succeededBy,
-            shareInfo: parsedSuccessorParams.shareInfo,
-            parentId: parsedSuccessorParams.parentId
+            createdAt: core_types_1.CoreDate.utc(),
+            succeeds: predecessor.id,
+            peer: predecessor.peer,
+            sourceReference: parsedSuccessorParams.sourceReference
         });
-        if (!predecessor.isOwnSharedRelationshipAttribute(this.identity.address)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.predecessorIsNotOwnSharedRelationshipAttribute());
-        }
-        if (!successor.isOwnSharedRelationshipAttribute(this.identity.address)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorIsNotOwnSharedRelationshipAttribute());
-        }
-        if (successor.content.key !== predecessor.content.key) {
+        if (predecessor.content.key !== successor.content.key) {
             return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successionMustNotChangeKey());
         }
-        if (!predecessor.shareInfo.peer.equals(successor.shareInfo.peer)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successionMustNotChangePeer());
-        }
-        return common_1.ValidationResult.success();
-    }
-    async validatePeerSharedIdentityAttributeSuccession(predecessorId, successorParams) {
-        let parsedSuccessorParams;
-        try {
-            parsedSuccessorParams = AttributeSuccessorParams_1.AttributeSuccessorParams.from(successorParams);
-        }
-        catch (e) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorIsNotAValidAttribute(e));
-        }
-        const commonValidation = await this.validateAttributeSuccessionCommon(predecessorId, parsedSuccessorParams);
-        if (commonValidation.isError())
-            return commonValidation;
-        const predecessor = (await this.getLocalAttribute(predecessorId));
-        const successor = LocalAttribute_1.LocalAttribute.from({
-            id: core_types_1.CoreId.from(parsedSuccessorParams.id ?? "dummy"),
-            content: parsedSuccessorParams.content,
-            createdAt: parsedSuccessorParams.createdAt ?? core_types_1.CoreDate.utc(),
-            succeeds: parsedSuccessorParams.succeeds,
-            succeededBy: parsedSuccessorParams.succeededBy,
-            shareInfo: parsedSuccessorParams.shareInfo,
-            parentId: parsedSuccessorParams.parentId
-        });
-        if (!predecessor.isPeerSharedIdentityAttribute()) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.predecessorIsNotPeerSharedIdentityAttribute());
+        if (predecessor.deletionInfo?.deletionStatus === deletionInfos_1.EmittedAttributeDeletionStatus.DeletedByRecipient) {
+            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.cannotSucceedSharedAttributesDeletedByPeer());
         }
-        if (!successor.isPeerSharedIdentityAttribute()) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorIsNotPeerSharedIdentityAttribute());
-        }
-        if (!predecessor.shareInfo.peer.equals(successor.shareInfo.peer)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successionMustNotChangePeer());
-        }
-        return common_1.ValidationResult.success();
+        return await this.validateAttributeSuccession(predecessor, successor);
     }
-    async validatePeerSharedRelationshipAttributeSuccession(predecessorId, successorParams) {
+    async validatePeerRelationshipAttributeSuccession(predecessor, successorParams) {
         let parsedSuccessorParams;
         try {
-            parsedSuccessorParams = AttributeSuccessorParams_1.AttributeSuccessorParams.from(successorParams);
+            parsedSuccessorParams = PeerRelationshipAttributeSuccessorParams_1.PeerRelationshipAttributeSuccessorParams.from(successorParams);
         }
         catch (e) {
             return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorIsNotAValidAttribute(e));
         }
-        const commonValidation = await this.validateAttributeSuccessionCommon(predecessorId, parsedSuccessorParams);
-        if (commonValidation.isError())
-            return commonValidation;
-        const predecessor = (await this.getLocalAttribute(predecessorId));
-        const successor = LocalAttribute_1.LocalAttribute.from({
-            id: core_types_1.CoreId.from(parsedSuccessorParams.id ?? "dummy"),
+        const successor = PeerRelationshipAttribute_1.PeerRelationshipAttribute.from({
+            id: parsedSuccessorParams.id,
             content: parsedSuccessorParams.content,
-            createdAt: parsedSuccessorParams.createdAt ?? core_types_1.CoreDate.utc(),
-            succeeds: parsedSuccessorParams.succeeds,
-            succeededBy: parsedSuccessorParams.succeededBy,
-            shareInfo: parsedSuccessorParams.shareInfo,
-            parentId: parsedSuccessorParams.parentId
+            createdAt: core_types_1.CoreDate.utc(),
+            succeeds: predecessor.id,
+            peer: predecessor.peer,
+            sourceReference: parsedSuccessorParams.sourceReference
         });
-        if (!predecessor.isPeerSharedRelationshipAttribute()) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.predecessorIsNotPeerSharedRelationshipAttribute());
-        }
-        if (!successor.isPeerSharedRelationshipAttribute()) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorIsNotPeerSharedRelationshipAttribute());
-        }
-        if (successor.content.key !== predecessor.content.key) {
+        if (predecessor.content.key !== successor.content.key) {
             return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successionMustNotChangeKey());
         }
-        if (!predecessor.shareInfo.peer.equals(successor.shareInfo.peer)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successionMustNotChangePeer());
+        if (predecessor.deletionInfo?.deletionStatus === deletionInfos_1.ReceivedAttributeDeletionStatus.DeletedByEmitter) {
+            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.cannotSucceedSharedAttributesDeletedByPeer());
         }
-        return common_1.ValidationResult.success();
+        return await this.validateAttributeSuccession(predecessor, successor);
     }
-    async validateThirdPartyRelationshipAttributeSuccession(predecessorId, successorParams) {
+    async validateThirdPartyRelationshipAttributeSuccession(predecessor, successorParams) {
         let parsedSuccessorParams;
         try {
-            parsedSuccessorParams = AttributeSuccessorParams_1.AttributeSuccessorParams.from(successorParams);
+            parsedSuccessorParams = successorParams_1.ThirdPartyRelationshipAttributeSuccessorParams.from(successorParams);
         }
         catch (e) {
             return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorIsNotAValidAttribute(e));
         }
-        const commonValidation = await this.validateAttributeSuccessionCommon(predecessorId, parsedSuccessorParams);
-        if (commonValidation.isError())
-            return commonValidation;
-        const predecessor = (await this.getLocalAttribute(predecessorId));
-        const successor = LocalAttribute_1.LocalAttribute.from({
-            id: core_types_1.CoreId.from(parsedSuccessorParams.id ?? "dummy"),
+        const successor = ThirdPartyRelationshipAttribute_1.ThirdPartyRelationshipAttribute.from({
+            id: parsedSuccessorParams.id,
             content: parsedSuccessorParams.content,
-            createdAt: parsedSuccessorParams.createdAt ?? core_types_1.CoreDate.utc(),
-            succeeds: parsedSuccessorParams.succeeds,
-            succeededBy: parsedSuccessorParams.succeededBy,
-            shareInfo: parsedSuccessorParams.shareInfo,
-            parentId: parsedSuccessorParams.parentId
+            createdAt: core_types_1.CoreDate.utc(),
+            succeeds: predecessor.id,
+            peer: predecessor.peer,
+            sourceReference: parsedSuccessorParams.sourceReference,
+            initialAttributePeer: predecessor.initialAttributePeer
         });
-        if (!predecessor.isThirdPartyRelationshipAttribute()) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.predecessorIsNotThirdPartyRelationshipAttribute());
-        }
-        if (!successor.isThirdPartyRelationshipAttribute()) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorIsNotThirdPartyRelationshipAttribute());
-        }
-        if (successor.content.key !== predecessor.content.key) {
+        if (predecessor.content.key !== successor.content.key) {
             return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successionMustNotChangeKey());
         }
-        if (!predecessor.shareInfo.peer.equals(successor.shareInfo.peer)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successionMustNotChangePeer());
-        }
-        if (!predecessor.shareInfo.thirdPartyAddress.equals(successor.shareInfo.thirdPartyAddress)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successionMustNotChangeThirdParty());
+        if (predecessor.deletionInfo?.deletionStatus === deletionInfos_1.ReceivedAttributeDeletionStatus.DeletedByEmitter) {
+            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.cannotSucceedSharedAttributesDeletedByPeer());
         }
-        return common_1.ValidationResult.success();
+        return await this.validateAttributeSuccession(predecessor, successor);
     }
-    async validateAttributeSuccessionCommon(predecessorId, successorParams) {
-        let parsedSuccessorParams;
-        try {
-            parsedSuccessorParams = AttributeSuccessorParams_1.AttributeSuccessorParams.from(successorParams);
-        }
-        catch (e) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorIsNotAValidAttribute(e));
-        }
-        const tagValidationResult = await this.validateTagsOfAttribute(parsedSuccessorParams.content);
-        if (tagValidationResult.isError())
-            throw tagValidationResult.error;
-        const successor = LocalAttribute_1.LocalAttribute.from({
-            id: core_types_1.CoreId.from(parsedSuccessorParams.id ?? "dummy"),
-            content: parsedSuccessorParams.content,
-            createdAt: parsedSuccessorParams.createdAt ?? core_types_1.CoreDate.utc(),
-            succeeds: parsedSuccessorParams.succeeds,
-            succeededBy: parsedSuccessorParams.succeededBy,
-            shareInfo: parsedSuccessorParams.shareInfo,
-            parentId: parsedSuccessorParams.parentId
-        });
-        if (parsedSuccessorParams.id) {
-            const successor = await this.getLocalAttribute(core_types_1.CoreId.from(parsedSuccessorParams.id));
-            if (successor)
-                return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorMustNotYetExist());
-        }
-        if (successor.succeededBy) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorMustNotHaveASuccessor());
-        }
-        if (successor.parentId) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.cannotSucceedChildOfComplexAttribute(predecessorId.toString()));
-        }
-        const predecessor = await this.getLocalAttribute(predecessorId);
-        if (!predecessor) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.predecessorDoesNotExist());
-        }
+    async validateAttributeSuccession(predecessor, successor) {
+        const existingAttributeWithSameId = await this.getLocalAttribute(successor.id);
+        if (existingAttributeWithSameId)
+            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorMustNotYetExist());
         if (predecessor.succeededBy) {
             return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.cannotSucceedAttributesWithASuccessor(predecessor.succeededBy.toString()));
         }
-        if (predecessor.parentId) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.cannotSucceedChildOfComplexAttribute(predecessorId.toString()));
-        }
-        if (predecessor.hasDeletionInfo() &&
-            !(predecessor.deletionInfo.deletionStatus === LocalAttributeDeletionInfo_1.LocalAttributeDeletionStatus.DeletionRequestRejected ||
-                predecessor.deletionInfo.deletionStatus === LocalAttributeDeletionInfo_1.LocalAttributeDeletionStatus.DeletionRequestSent)) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.cannotSucceedAttributesWithDeletionInfo());
-        }
         if (lodash_1.default.isEqual(successor.content.toJSON(), predecessor.content.toJSON())) {
             return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successionMustChangeContent());
         }
@@ -820,120 +620,66 @@ class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseCo
         if (predecessor.content.value.constructor !== successor.content.value.constructor) {
             return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successionMustNotChangeValueType());
         }
-        if (successor.succeeds && !predecessorId.equals(successor.succeeds.toString())) {
-            return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.setPredecessorIdDoesNotMatchActualPredecessorId());
-        }
         if (!this.validateAttributeCharacters(successor.content)) {
             return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.forbiddenCharactersInAttribute("The successor contains forbidden characters."));
         }
         return common_1.ValidationResult.success();
     }
-    async createAttributeUnsafe(attributeData) {
-        const localAttribute = LocalAttribute_1.LocalAttribute.from({
-            id: attributeData.id ?? (await ConsumptionIds_1.ConsumptionIds.attribute.generate()),
-            content: attributeData.content,
-            createdAt: attributeData.createdAt ?? core_types_1.CoreDate.utc(),
-            shareInfo: attributeData.shareInfo,
-            parentId: attributeData.parentId,
-            succeededBy: attributeData.succeededBy,
-            succeeds: attributeData.succeeds,
-            deletionInfo: attributeData.deletionInfo,
-            isDefault: attributeData.isDefault
-        });
-        await this.attributes.create(localAttribute);
-        return localAttribute;
-    }
-    async updateAttributeUnsafe(attributeParams) {
-        const doc = await this.attributes.findOne({
-            [(0, ts_simple_nameof_1.nameof)((c) => c.id)]: attributeParams.id.toString()
-        });
-        if (!doc) {
-            throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, attributeParams.id.toString());
-        }
-        const params = {
-            id: attributeParams.id,
-            content: attributeParams.content,
-            createdAt: attributeParams.createdAt,
-            parentId: attributeParams.parentId,
-            shareInfo: attributeParams.shareInfo,
-            succeededBy: attributeParams.succeededBy,
-            succeeds: attributeParams.succeeds,
-            deletionInfo: attributeParams.deletionInfo,
-            isDefault: attributeParams.isDefault
-        };
-        const newAttribute = LocalAttribute_1.LocalAttribute.from(params);
-        await this.attributes.update(doc, newAttribute);
-        return newAttribute;
+    async deleteAttribute(attributeId) {
+        const attribute = await this.getLocalAttribute(attributeId);
+        if (!attribute)
+            throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, attributeId.toString());
+        await this.deleteAttributeUnsafe(attributeId);
+        this.eventBus.publish(new events_1.AttributeDeletedEvent(this.identity.address.toString(), attribute));
     }
     async deleteAttributeUnsafe(id) {
         await this.attributes.delete({ id: id });
     }
-    async executeFullAttributeDeletionProcess(attribute) {
-        const validationResult = await this.validateFullAttributeDeletionProcess(attribute);
-        if (validationResult.isError())
-            throw validationResult.error;
-        const childAttributes = await this.getLocalAttributes({ parentId: attribute.id.toString() });
-        const parentAndChildAttributes = [attribute, ...childAttributes];
-        for (const attr of parentAndChildAttributes) {
-            if (attr.succeededBy) {
-                const successor = await this.getLocalAttribute(attr.succeededBy);
-                if (!successor) {
-                    throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorDoesNotExist();
-                }
-                await this.detachSuccessor(successor);
-            }
+    async deleteAttributesExchangedWithPeer(peer) {
+        const receivedAttributes = await this.getLocalAttributes({ peer: peer.toString() });
+        for (const attribute of receivedAttributes) {
+            await this.deleteAttributeUnsafe(attribute.id);
         }
-        const copiesOfParentAndChildAttributes = await this.getLocalAttributes({
-            ["shareInfo.sourceAttribute"]: { $in: parentAndChildAttributes.map((attribute) => attribute.id.toString()) }
-        });
-        const predecessorCopiesOfParentAndChildAttributes = [];
-        for (const attr of parentAndChildAttributes) {
-            const predecessorCopies = await this.getSharedPredecessorsOfAttribute(attr);
-            predecessorCopiesOfParentAndChildAttributes.push(...predecessorCopies);
-        }
-        const attributeCopiesToDetach = [...copiesOfParentAndChildAttributes, ...predecessorCopiesOfParentAndChildAttributes];
-        await this.detachAttributeCopies(attributeCopiesToDetach);
-        await this.deletePredecessorsOfAttribute(attribute.id);
-        if (this.setDefaultRepositoryAttributes) {
-            await this.transferDefault(attribute);
+        const forwardedAttributes = (await this.getAttributesForwardedToPeer(peer, {
+            "@type": { $in: ["OwnIdentityAttribute", "OwnRelationshipAttribute", "PeerRelationshipAttribute"] }
+        }));
+        for (const attribute of forwardedAttributes) {
+            await this.removeForwardingDetailsFromAttribute(attribute, peer);
         }
-        await this.deleteAttribute(attribute);
     }
-    async validateFullAttributeDeletionProcess(attribute) {
-        const childAttributes = await this.getLocalAttributes({ parentId: attribute.id.toString() });
-        const parentAndChildAttributes = [attribute, ...childAttributes];
-        for (const attr of parentAndChildAttributes) {
-            const validateSuccessorResult = await this.validateSuccessor(attr);
-            if (validateSuccessorResult.isError()) {
-                return validateSuccessorResult;
-            }
+    async removeForwardingDetailsFromAttribute(attribute, peer) {
+        const existingForwardingDetailsDocs = await this.forwardingDetails.find({ attributeId: attribute.id.toString(), peer: peer.toString() });
+        const existingForwardingDetails = existingForwardingDetailsDocs.map((obj) => AttributeForwardingDetails_1.AttributeForwardingDetails.from(obj));
+        for (const entry of existingForwardingDetails) {
+            await this.forwardingDetails.delete(entry);
         }
-        const copiesOfParentAndChildAttributes = await this.getLocalAttributes({
-            ["shareInfo.sourceAttribute"]: { $in: parentAndChildAttributes.map((attribute) => attribute.id.toString()) }
-        });
-        const predecessorCopiesOfParentAndChildAttributes = [];
-        for (const attr of parentAndChildAttributes) {
-            const predecessorCopies = await this.getSharedPredecessorsOfAttribute(attr);
-            predecessorCopiesOfParentAndChildAttributes.push(...predecessorCopies);
-        }
-        const attributeCopiesToDetach = [...copiesOfParentAndChildAttributes, ...predecessorCopiesOfParentAndChildAttributes];
-        const validateSharedAttributesResult = this.validateSharedAttributes(attributeCopiesToDetach);
-        return validateSharedAttributesResult;
+        await this.updateNumberOfForwards(attribute);
+        this.eventBus.publish(new events_1.AttributeForwardingDetailsChangedEvent(this.identity.address.toString(), attribute));
+        return attribute;
     }
-    async validateSuccessor(predecessor) {
-        if (predecessor.succeededBy) {
-            const successor = await this.getLocalAttribute(predecessor.succeededBy);
-            if (!successor) {
-                return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorDoesNotExist());
-            }
+    async executeFullAttributeDeletionProcess(attribute) {
+        const validationResult = await this.validateFullAttributeDeletionProcess(attribute.id);
+        if (validationResult.isError())
+            throw validationResult.error;
+        if (attribute.succeededBy) {
+            const successor = await this.getLocalAttribute(attribute.succeededBy);
+            if (!successor)
+                throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorDoesNotExist();
+            await this.detachSuccessor(successor);
         }
-        return common_1.ValidationResult.success();
+        await this.deletePredecessorsOfAttribute(attribute);
+        if (attribute instanceof OwnIdentityAttribute_1.OwnIdentityAttribute && this.setDefaultOwnIdentityAttributes)
+            await this.transferDefault(attribute);
+        await this.deleteAttribute(attribute.id);
     }
-    validateSharedAttributes(sharedAttributes) {
-        for (const sharedAttribute of sharedAttributes) {
-            if (!sharedAttribute.isShared()) {
-                return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.isNotSharedAttribute(sharedAttribute.id));
-            }
+    async validateFullAttributeDeletionProcess(attributeId) {
+        const attribute = await this.getLocalAttribute(attributeId);
+        if (!attribute)
+            throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, attributeId.toString());
+        if (attribute.succeededBy) {
+            const successor = await this.getLocalAttribute(attribute.succeededBy);
+            if (!successor)
+                return common_1.ValidationResult.error(ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.successorDoesNotExist());
         }
         return common_1.ValidationResult.success();
     }
@@ -941,89 +687,67 @@ class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseCo
         successor.succeeds = undefined;
         await this.updateAttributeUnsafe(successor);
     }
-    async detachAttributeCopies(sharedAttributes) {
-        for (const sharedAttribute of sharedAttributes) {
-            if (!sharedAttribute.isShared()) {
-                throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.isNotSharedAttribute(sharedAttribute.id);
-            }
-            sharedAttribute.shareInfo.sourceAttribute = undefined;
-            await this.updateAttributeUnsafe(sharedAttribute);
-        }
-    }
-    async deletePredecessorsOfAttribute(attributeId) {
-        const predecessors = await this.getPredecessorsOfAttribute(attributeId);
+    async deletePredecessorsOfAttribute(attribute) {
+        const predecessors = await this.getPredecessorsOfAttribute(attribute);
         for (const predecessor of predecessors) {
-            await this.deleteAttribute(predecessor);
+            await this.deleteAttribute(predecessor.id);
         }
     }
     async transferDefault(attribute) {
-        if (!this.setDefaultRepositoryAttributes)
-            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.setDefaultRepositoryAttributesIsDisabled();
+        if (!this.setDefaultOwnIdentityAttributes)
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.setDefaultOwnIdentityAttributesIsDisabled();
         if (!attribute.isDefault)
             return;
         const valueType = attribute.content.value.constructor.name;
         const query = {
             $and: [
-                {
-                    [`${(0, ts_simple_nameof_1.nameof)((c) => c.content)}.value.@type`]: valueType
-                },
-                {
-                    [(0, ts_simple_nameof_1.nameof)((c) => c.succeededBy)]: undefined
-                },
-                {
-                    [(0, ts_simple_nameof_1.nameof)((c) => c.id)]: { $ne: attribute.id.toString() }
-                }
+                { [`@type`]: "OwnIdentityAttribute" },
+                { [`${(0, ts_simple_nameof_1.nameof)((c) => c.content)}.value.@type`]: valueType },
+                { [(0, ts_simple_nameof_1.nameof)((c) => c.succeededBy)]: undefined },
+                { [(0, ts_simple_nameof_1.nameof)((c) => c.id)]: { $ne: attribute.id.toString() } }
             ]
         };
-        const defaultCandidates = await this.getLocalAttributes(query);
+        const defaultCandidates = (await this.getLocalAttributes(query));
         if (defaultCandidates.length === 0)
             return;
         defaultCandidates[defaultCandidates.length - 1].isDefault = true;
         await this.updateAttributeUnsafe(defaultCandidates[defaultCandidates.length - 1]);
     }
-    async getVersionsOfAttribute(id) {
-        const attribute = await this.getLocalAttribute(id);
-        if (!attribute) {
-            throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, id.toString());
-        }
-        const predecessors = await this.getPredecessorsOfAttribute(id);
-        const successors = await this.getSuccessorsOfAttribute(id);
+    async getVersionsOfAttribute(attribute) {
+        const predecessors = await this.getPredecessorsOfAttribute(attribute);
+        const successors = await this.getSuccessorsOfAttribute(attribute);
         const allAttributeVersions = [...successors.reverse(), attribute, ...predecessors];
         return allAttributeVersions;
     }
-    async getPredecessorsOfAttribute(id) {
-        let attribute = await this.getLocalAttribute(id);
-        if (!attribute) {
-            throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, id.toString());
-        }
+    async getPredecessorsOfAttribute(attribute) {
         const predecessors = [];
         while (attribute.succeeds) {
-            const predecessor = await this.getLocalAttribute(attribute.succeeds);
-            if (!predecessor) {
+            const predecessor = (await this.getLocalAttribute(attribute.succeeds));
+            if (!predecessor)
                 throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, attribute.succeeds.toString());
-            }
             attribute = predecessor;
             predecessors.push(attribute);
         }
         return predecessors;
     }
-    async getSuccessorsOfAttribute(id) {
-        let attribute = await this.getLocalAttribute(id);
-        if (!attribute) {
-            throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, id.toString());
-        }
+    async getSuccessorsOfAttribute(attribute) {
         const successors = [];
         while (attribute.succeededBy) {
-            const successor = await this.getLocalAttribute(attribute.succeededBy);
-            if (!successor) {
+            const successor = (await this.getLocalAttribute(attribute.succeededBy));
+            if (!successor)
                 throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, attribute.succeededBy.toString());
-            }
             attribute = successor;
             successors.push(successor);
         }
         return successors;
     }
-    async isSubsequentInSuccession(predecessor, successor) {
+    async isSubsequentInSuccession(predecessorId, successorId) {
+        let predecessor = await this.getLocalAttribute(predecessorId);
+        if (!predecessor)
+            throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, predecessorId.toString());
+        const successor = await this.getLocalAttribute(successorId);
+        if (!successor)
+            throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, successorId.toString());
         while (predecessor.succeededBy) {
             const directSuccessor = await this.getLocalAttribute(predecessor.succeededBy);
             if (!directSuccessor)
@@ -1034,102 +758,131 @@ class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseCo
         }
         return false;
     }
-    async getSharedVersionsOfAttribute(id, peers, onlyLatestVersions = true, query = {}) {
-        const sourceAttribute = await this.getLocalAttribute(id);
-        if (!sourceAttribute)
-            throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, id.toString());
-        query["shareInfo.sourceAttribute"] = sourceAttribute.id.toString();
-        if (peers)
-            query["shareInfo.peer"] = { $in: peers.map((address) => address.toString()) };
-        if (onlyLatestVersions)
-            query["succeededBy"] = { $exists: false };
-        const ownSharedAttributes = await this.getLocalAttributes(query);
-        const ownSharedAttributePredecessors = await this.getSharedPredecessorsOfAttribute(sourceAttribute, query);
-        const ownSharedAttributeSuccessors = await this.getSharedSuccessorsOfAttribute(sourceAttribute, query);
-        const ownSharedAttributeVersions = [...ownSharedAttributeSuccessors.reverse(), ...ownSharedAttributes, ...ownSharedAttributePredecessors];
-        return ownSharedAttributeVersions;
-    }
-    async getSharedPredecessorsOfAttribute(sourceAttribute, query = {}) {
-        const ownSharedAttributePredecessors = [];
-        while (sourceAttribute.succeeds) {
-            const predecessor = await this.getLocalAttribute(sourceAttribute.succeeds);
+    async getVersionsOfAttributeSharedWithPeer(attribute, peerAddress, onlyLatestVersion = true, excludeToBeDeleted = false) {
+        const sharedAttribute = (await this.isAttributeForwardedToPeer(attribute, peerAddress, excludeToBeDeleted)) ? [attribute] : [];
+        const sharedPredecessors = await this.getPredecessorsOfAttributeSharedWithPeer(attribute, peerAddress, excludeToBeDeleted);
+        const sharedSuccessors = await this.getSuccessorsOfAttributeSharedWithPeer(attribute, peerAddress, excludeToBeDeleted);
+        const sharedAttributeVersions = [...sharedSuccessors.reverse(), ...sharedAttribute, ...sharedPredecessors];
+        if (onlyLatestVersion)
+            return sharedAttributeVersions.length > 0 ? [sharedAttributeVersions[0]] : [];
+        return sharedAttributeVersions;
+    }
+    async getPredecessorsOfAttributeSharedWithPeer(referenceAttribute, peerAddress, excludeToBeDeleted = false) {
+        const matchingPredecessors = [];
+        while (referenceAttribute.succeeds) {
+            const predecessor = (await this.getLocalAttribute(referenceAttribute.succeeds));
             if (!predecessor)
-                throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, sourceAttribute.succeeds.toString());
-            sourceAttribute = predecessor;
-            query["shareInfo.sourceAttribute"] = sourceAttribute.id.toString();
-            const sharedCopies = await this.getLocalAttributes(query);
-            ownSharedAttributePredecessors.push(...sharedCopies);
-        }
-        return ownSharedAttributePredecessors;
-    }
-    async getSharedSuccessorsOfAttribute(sourceAttribute, query = {}) {
-        const ownSharedAttributeSuccessors = [];
-        while (sourceAttribute.succeededBy) {
-            const successor = await this.getLocalAttribute(sourceAttribute.succeededBy);
+                throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, referenceAttribute.succeeds.toString());
+            referenceAttribute = predecessor;
+            if (await this.isAttributeForwardedToPeer(referenceAttribute, peerAddress, excludeToBeDeleted))
+                matchingPredecessors.push(referenceAttribute);
+        }
+        return matchingPredecessors;
+    }
+    async getSuccessorsOfAttributeSharedWithPeer(referenceAttribute, peerAddress, excludeToBeDeleted = false) {
+        const matchingSuccessors = [];
+        while (referenceAttribute.succeededBy) {
+            const successor = (await this.getLocalAttribute(referenceAttribute.succeededBy));
             if (!successor)
-                throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, sourceAttribute.succeededBy.toString());
-            sourceAttribute = successor;
-            query["shareInfo.sourceAttribute"] = sourceAttribute.id.toString();
-            const sharedCopies = await this.getLocalAttributes(query);
-            ownSharedAttributeSuccessors.push(...sharedCopies);
+                throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, referenceAttribute.succeededBy.toString());
+            referenceAttribute = successor;
+            if (await this.isAttributeForwardedToPeer(referenceAttribute, peerAddress, excludeToBeDeleted))
+                matchingSuccessors.push(referenceAttribute);
+        }
+        return matchingSuccessors;
+    }
+    async getPeersWithExclusivelyForwardedPredecessors(attributeId) {
+        let attribute = (await this.getLocalAttribute(attributeId));
+        if (!attribute)
+            throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, attributeId.toString());
+        if (!(attribute instanceof OwnIdentityAttribute_1.OwnIdentityAttribute || attribute instanceof OwnRelationshipAttribute_1.OwnRelationshipAttribute || attribute instanceof PeerRelationshipAttribute_1.PeerRelationshipAttribute)) {
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.wrongTypeOfAttribute(`The Attribute ${attributeId} is not an OwnIdentityAttribute, an OwnRelationshipAttribute or a PeerRelationshipAttribute.`);
+        }
+        const peersWithLaterSharedVersion = await this.getForwardingPeers(attribute, true);
+        const peersWithExclusivelyForwardedPredecessors = [];
+        while (attribute.succeeds) {
+            const predecessor = (await this.getLocalAttribute(attribute.succeeds));
+            if (!predecessor)
+                throw transport_1.TransportCoreErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, attribute.succeeds.toString());
+            attribute = predecessor;
+            const forwardingPeers = await this.getForwardingPeers(attribute, true);
+            const newPeers = forwardingPeers.filter((peer) => !peersWithLaterSharedVersion.some((peerWithLaterSharedVersion) => peerWithLaterSharedVersion.equals(peer)));
+            if (newPeers.length === 0)
+                continue;
+            for (const peer of newPeers) {
+                peersWithExclusivelyForwardedPredecessors.push([peer, attribute.id]);
+            }
+            peersWithLaterSharedVersion.push(...newPeers);
         }
-        return ownSharedAttributeSuccessors;
+        return peersWithExclusivelyForwardedPredecessors;
+    }
+    async getOwnIdentityAttributeWithSameValue(value) {
+        const trimmedValue = this.trimAttributeValue(value);
+        const queryForOwnIdentityAttributeDuplicates = (0, common_1.flattenObject)({
+            "@type": "OwnIdentityAttribute",
+            content: { value: trimmedValue }
+        });
+        queryForOwnIdentityAttributeDuplicates["succeededBy"] = { $exists: false };
+        return (await this.getAttributeWithSameValue(trimmedValue, queryForOwnIdentityAttributeDuplicates));
     }
-    async getRepositoryAttributeWithSameValue(value) {
+    async getPeerIdentityAttributeWithSameValue(value, owner) {
         const trimmedValue = this.trimAttributeValue(value);
-        const queryForRepositoryAttributeDuplicates = (0, common_1.flattenObject)({
+        const query = (0, common_1.flattenObject)({
+            "@type": "PeerIdentityAttribute",
             content: {
-                "@type": "IdentityAttribute",
-                owner: this.identity.address.toString(),
-                value: trimmedValue
+                value: trimmedValue,
+                owner: owner
             }
         });
-        queryForRepositoryAttributeDuplicates["succeededBy"] = { $exists: false };
-        queryForRepositoryAttributeDuplicates["shareInfo"] = { $exists: false };
-        return await this.getAttributeWithSameValue(trimmedValue, queryForRepositoryAttributeDuplicates);
+        query["deletionInfo.deletionStatus"] = { $ne: deletionInfos_1.ReceivedAttributeDeletionStatus.DeletedByEmitter };
+        return (await this.getAttributeWithSameValue(trimmedValue, query));
     }
-    async getPeerSharedIdentityAttributeWithSameValue(value, peer) {
-        const trimmedValue = this.trimAttributeValue(value);
-        const queryForPeerSharedAttributeDuplicates = (0, common_1.flattenObject)({
+    async getThirdPartyRelationshipAttributeWithSameValue(value, peer, owner, key) {
+        const query = (0, common_1.flattenObject)({
+            "@type": "ThirdPartyRelationshipAttribute",
             content: {
-                "@type": "IdentityAttribute",
-                owner: peer,
-                value: trimmedValue
-            },
-            shareInfo: {
-                peer
+                value: value,
+                owner: owner,
+                key: key
             }
         });
-        queryForPeerSharedAttributeDuplicates["succeededBy"] = { $exists: false };
-        queryForPeerSharedAttributeDuplicates["shareInfo.sourceAttribute"] = { $exists: false };
-        return await this.getAttributeWithSameValue(trimmedValue, queryForPeerSharedAttributeDuplicates);
+        query["peer"] = peer;
+        query["deletionInfo.deletionStatus"] = { $ne: deletionInfos_1.ReceivedAttributeDeletionStatus.DeletedByEmitter };
+        return (await this.getAttributeWithSameValue(value, query));
     }
     async getAttributeWithSameValue(value, query) {
         const matchingAttributes = await this.getLocalAttributes(query);
         const attributeDuplicate = matchingAttributes.find((duplicate) => lodash_1.default.isEqual(duplicate.content.value.toJSON(), value));
         return attributeDuplicate;
     }
+    trimAttribute(attribute) {
+        const trimmedAttribute = {
+            ...attribute.toJSON(),
+            value: this.trimAttributeValue(attribute.value.toJSON())
+        };
+        return content_1.IdentityAttribute.from(trimmedAttribute);
+    }
     trimAttributeValue(value) {
         const trimmedEntries = Object.entries(value).map((entry) => (typeof entry[1] === "string" ? [entry[0], entry[1].trim()] : entry));
         return Object.fromEntries(trimmedEntries);
     }
     async getRelationshipAttributesOfValueTypeToPeerWithGivenKeyAndOwner(key, owner, valueType, peer) {
-        return await this.getLocalAttributes({
-            "content.@type": "RelationshipAttribute",
+        const query = {
+            "@type": { $in: ["OwnRelationshipAttribute", "PeerRelationshipAttribute"] },
             "content.owner": owner.toString(),
             "content.key": key,
             "content.value.@type": valueType,
-            "shareInfo.peer": peer.toString(),
-            "shareInfo.thirdPartyAddress": { $exists: false },
+            peer: peer.toString(),
             "deletionInfo.deletionStatus": {
                 $nin: [
-                    LocalAttributeDeletionInfo_1.LocalAttributeDeletionStatus.ToBeDeleted,
-                    LocalAttributeDeletionInfo_1.LocalAttributeDeletionStatus.ToBeDeletedByPeer,
-                    LocalAttributeDeletionInfo_1.LocalAttributeDeletionStatus.DeletedByPeer,
-                    LocalAttributeDeletionInfo_1.LocalAttributeDeletionStatus.DeletedByOwner
+                    deletionInfos_1.EmittedAttributeDeletionStatus.ToBeDeletedByRecipient,
+                    deletionInfos_1.EmittedAttributeDeletionStatus.DeletedByRecipient,
+                    deletionInfos_1.ReceivedAttributeDeletionStatus.ToBeDeleted,
+                    deletionInfos_1.ReceivedAttributeDeletionStatus.DeletedByEmitter
                 ]
             }
-        });
+        };
+        return (await this.getLocalAttributes(query));
     }
     async getAttributeTagCollection() {
         if (this.readTagCollectionPromise) {
@@ -1273,37 +1026,102 @@ class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseCo
             throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.wrongRelationshipStatusToSetDeletionInfo();
         }
         const deletionDate = relationship.auditLog[relationship.auditLog.length - 1].createdAt;
-        await this.setDeletionInfoOfOwnSharedAttributes(relationship.peer.address.toString(), deletionDate);
-        await this.setDeletionInfoOfPeerSharedAttributes(relationship.peer.address.toString(), deletionDate);
+        await this.setDeletionInfoOfAttributesSharedWithPeer(relationship.peer.address, deletionDate);
     }
-    async setDeletionInfoOfOwnSharedAttributes(peer, deletionDate) {
-        const ownSharedAttributeDeletionInfo = LocalAttributeDeletionInfo_1.LocalAttributeDeletionInfo.from({
-            deletionStatus: LocalAttributeDeletionInfo_1.LocalAttributeDeletionStatus.DeletedByPeer,
+    async setDeletionInfoOfAttributesSharedWithPeer(peer, deletionDate) {
+        await this.setForwardedDeletionInfoOfAttributes(peer, deletionDate);
+        await this.setPeerDeletionInfoOfOwnRelationshipAttributes(peer, deletionDate);
+        await this.setPeerDeletionInfoOfReceivedAttributes(peer, deletionDate);
+    }
+    async setForwardedDeletionInfoOfAttributes(peer, deletionDate) {
+        const deletionInfo = deletionInfos_1.EmittedAttributeDeletionInfo.from({
+            deletionStatus: deletionInfos_1.EmittedAttributeDeletionStatus.DeletedByRecipient,
             deletionDate
         });
-        const ownSharedAttributes = await this.getLocalAttributes({
-            "shareInfo.peer": peer,
-            "content.owner": this.identity.address.toString(),
-            "deletionInfo.deletionStatus": { $ne: LocalAttributeDeletionInfo_1.LocalAttributeDeletionStatus.DeletedByPeer }
+        const forwardingDetailsForPeer = await this.forwardingDetails.find({
+            peer: peer.toString(),
+            "deletionInfo.deletionStatus": { $ne: deletionInfos_1.EmittedAttributeDeletionStatus.DeletedByRecipient }
         });
-        await this.setDeletionInfoOfAttributes(ownSharedAttributes, ownSharedAttributeDeletionInfo);
+        if (forwardingDetailsForPeer.length === 0)
+            return;
+        const attributesForwardedToPeer = (await this.getLocalAttributes({
+            "@type": { $in: ["OwnIdentityAttribute", "OwnRelationshipAttribute", "PeerRelationshipAttribute"] },
+            id: { $in: forwardingDetailsForPeer.map((detail) => detail.attributeId.toString()) }
+        }));
+        for (const attribute of attributesForwardedToPeer) {
+            await this.setForwardedDeletionInfoOfAttribute(attribute, deletionInfo, peer);
+        }
     }
-    async setDeletionInfoOfPeerSharedAttributes(peer, deletionDate) {
-        const peerSharedAttributeDeletionInfo = LocalAttributeDeletionInfo_1.LocalAttributeDeletionInfo.from({
-            deletionStatus: LocalAttributeDeletionInfo_1.LocalAttributeDeletionStatus.DeletedByOwner,
+    async setPeerDeletionInfoOfOwnRelationshipAttributes(peer, deletionDate) {
+        const deletionInfo = deletionInfos_1.EmittedAttributeDeletionInfo.from({
+            deletionStatus: deletionInfos_1.EmittedAttributeDeletionStatus.DeletedByRecipient,
             deletionDate
         });
-        const peerSharedAttributes = await this.getLocalAttributes({
-            "shareInfo.peer": peer,
-            "content.owner": peer,
-            "deletionInfo.deletionStatus": { $ne: LocalAttributeDeletionInfo_1.LocalAttributeDeletionStatus.DeletedByOwner }
+        const attributesSharedWithPeer = (await this.getLocalAttributes({
+            "@type": "OwnRelationshipAttribute",
+            peer: peer.toString(),
+            "deletionInfo.deletionStatus": { $ne: deletionInfos_1.EmittedAttributeDeletionStatus.DeletedByRecipient }
+        }));
+        for (const attribute of attributesSharedWithPeer) {
+            await this.setPeerDeletionInfoOfOwnRelationshipAttribute(attribute, deletionInfo);
+        }
+    }
+    async setPeerDeletionInfoOfReceivedAttributes(peer, deletionDate) {
+        const deletionInfo = deletionInfos_1.ReceivedAttributeDeletionInfo.from({
+            deletionStatus: deletionInfos_1.ReceivedAttributeDeletionStatus.DeletedByEmitter,
+            deletionDate
         });
-        await this.setDeletionInfoOfAttributes(peerSharedAttributes, peerSharedAttributeDeletionInfo);
+        const attributesReceivedFromPeer = (await this.getLocalAttributes({
+            "@type": { $in: ["PeerIdentityAttribute", "PeerRelationshipAttribute", "ThirdPartyRelationshipAttribute"] },
+            peer: peer.toString(),
+            "deletionInfo.deletionStatus": { $ne: deletionInfos_1.ReceivedAttributeDeletionStatus.DeletedByEmitter }
+        }));
+        for (const attribute of attributesReceivedFromPeer) {
+            await this.setPeerDeletionInfoOfReceivedAttribute(attribute, deletionInfo);
+        }
+    }
+    async setForwardedDeletionInfoOfAttribute(attribute, deletionInfo, peer, overrideDeletedOrToBeDeleted = false) {
+        const isDeletedOrToBeDeletedByForwardingPeer = await this.isAttributeDeletedOrToBeDeletedByForwardingPeer(attribute, peer);
+        if (isDeletedOrToBeDeletedByForwardingPeer && !overrideDeletedOrToBeDeleted)
+            return;
+        await this.setDeletionInfoForForwardingPeer(attribute, deletionInfo, peer, overrideDeletedOrToBeDeleted);
+    }
+    async isAttributeDeletedOrToBeDeletedByForwardingPeer(attribute, peer) {
+        const docs = await this.forwardingDetails.find({ attributeId: attribute.id.toString(), peer: peer.toString() });
+        const forwardingDetailsWithPeer = docs.map((doc) => AttributeForwardingDetails_1.AttributeForwardingDetails.from(doc));
+        const deletionStatuses = [deletionInfos_1.EmittedAttributeDeletionStatus.DeletedByRecipient, deletionInfos_1.EmittedAttributeDeletionStatus.ToBeDeletedByRecipient];
+        const hasSharingDetailsWithDeletionStatus = forwardingDetailsWithPeer.some((details) => details.deletionInfo && deletionStatuses.includes(details.deletionInfo.deletionStatus));
+        const hasSharingDetailsWithoutDeletionStatus = forwardingDetailsWithPeer.some((details) => !details.deletionInfo || !deletionStatuses.includes(details.deletionInfo.deletionStatus));
+        return hasSharingDetailsWithDeletionStatus && !hasSharingDetailsWithoutDeletionStatus;
+    }
+    async setPeerDeletionInfoOfOwnRelationshipAttribute(attribute, deletionInfo, overrideDeletedOrToBeDeleted = false) {
+        if (attribute.isDeletedOrToBeDeletedByRecipient() && !overrideDeletedOrToBeDeleted)
+            return;
+        attribute.setPeerDeletionInfo(deletionInfo, overrideDeletedOrToBeDeleted);
+        await this.updateAttributeUnsafe(attribute);
     }
-    async setDeletionInfoOfAttributes(attributes, deletionInfo) {
-        for (const attribute of attributes) {
-            attribute.setDeletionInfo(deletionInfo, this.identity.address);
-            await this.updateAttributeUnsafe(attribute);
+    async setPeerDeletionInfoOfReceivedAttribute(attribute, deletionInfo, overrideDeletedOrToBeDeleted = false) {
+        if (attribute.isDeletedByEmitterOrToBeDeleted() && !overrideDeletedOrToBeDeleted)
+            return;
+        attribute.setPeerDeletionInfo(deletionInfo, overrideDeletedOrToBeDeleted);
+        await this.updateAttributeUnsafe(attribute);
+    }
+    async setForwardedDeletionInfoOfAttributeAndPredecessors(attribute, deletionInfo, peer, overrideDeletedOrToBeDeleted = false) {
+        const predecessors = await this.getPredecessorsOfAttribute(attribute);
+        for (const attr of [attribute, ...predecessors]) {
+            await this.setForwardedDeletionInfoOfAttribute(attr, deletionInfo, peer, overrideDeletedOrToBeDeleted);
+        }
+    }
+    async setPeerDeletionInfoOfOwnRelationshipAttributeAndPredecessors(attribute, deletionInfo, overrideDeletedOrToBeDeleted = false) {
+        const predecessors = await this.getPredecessorsOfAttribute(attribute);
+        for (const attr of [attribute, ...predecessors]) {
+            await this.setPeerDeletionInfoOfOwnRelationshipAttribute(attr, deletionInfo, overrideDeletedOrToBeDeleted);
+        }
+    }
+    async setPeerDeletionInfoOfReceivedAttributeAndPredecessors(attribute, deletionInfo, overrideDeletedOrToBeDeleted = false) {
+        const predecessors = await this.getPredecessorsOfAttribute(attribute);
+        for (const attr of [attribute, ...predecessors]) {
+            await this.setPeerDeletionInfoOfReceivedAttribute(attr, deletionInfo, overrideDeletedOrToBeDeleted);
         }
     }
     async markAttributeAsViewed(id) {
@@ -1319,6 +1137,118 @@ class AttributesController extends ConsumptionBaseController_1.ConsumptionBaseCo
         this.eventBus.publish(new events_1.AttributeWasViewedAtChangedEvent(this.identity.address.toString(), localAttribute));
         return localAttribute;
     }
+    async isAttributeForwardedToPeer(attribute, peer, excludeToBeDeleted = false) {
+        const forwardingDetails = await this.forwardingDetails.find({
+            attributeId: attribute.id.toString(),
+            peer: peer.toString(),
+            "deletionInfo.deletionStatus": { $ne: deletionInfos_1.EmittedAttributeDeletionStatus.DeletedByRecipient }
+        });
+        if (forwardingDetails.length === 0)
+            return false;
+        if (!excludeToBeDeleted)
+            return true;
+        return forwardingDetails.some((details) => details.deletionInfo?.deletionStatus !== deletionInfos_1.EmittedAttributeDeletionStatus.ToBeDeletedByRecipient);
+    }
+    async getForwardingDetailsForPeer(attribute, peer, excludeDeletedByRecipient = false) {
+        const query = { attributeId: attribute.id.toString(), peer: peer.toString() };
+        if (excludeDeletedByRecipient)
+            query["deletionInfo.deletionStatus"] = { $ne: deletionInfos_1.EmittedAttributeDeletionStatus.DeletedByRecipient };
+        const existingForwardingDetails = await this.forwardingDetails.find(query);
+        if (existingForwardingDetails.length === 0)
+            return undefined;
+        return AttributeForwardingDetails_1.AttributeForwardingDetails.from(existingForwardingDetails[0]);
+    }
+    async upsertForwardingDetailsForPeer(attribute, peer, forwardingDetails) {
+        const existingForwardingDetails = await this.forwardingDetails.find({
+            attributeId: attribute.id.toString(),
+            peer: peer.toString(),
+            "deletionInfo.deletionStatus": { $ne: deletionInfos_1.EmittedAttributeDeletionStatus.DeletedByRecipient }
+        });
+        if (existingForwardingDetails.length === 0) {
+            await this.forwardingDetails.create(forwardingDetails);
+            await this.updateNumberOfForwards(attribute);
+            return;
+        }
+        await this.forwardingDetails.update(existingForwardingDetails[0], forwardingDetails);
+    }
+    async updateNumberOfForwards(attribute) {
+        if (!(attribute instanceof OwnIdentityAttribute_1.OwnIdentityAttribute || attribute instanceof OwnRelationshipAttribute_1.OwnRelationshipAttribute || attribute instanceof PeerRelationshipAttribute_1.PeerRelationshipAttribute))
+            return;
+        const count = await this.forwardingDetails.count({ [(0, ts_simple_nameof_1.nameof)((c) => c.attributeId)]: attribute.id.toString() });
+        attribute.numberOfForwards = count;
+    }
+    async getForwardingPeers(attribute, includeToBeDeleted = false) {
+        const excludedDeletionStatuses = includeToBeDeleted
+            ? [deletionInfos_1.EmittedAttributeDeletionStatus.DeletedByRecipient]
+            : [deletionInfos_1.EmittedAttributeDeletionStatus.DeletedByRecipient, deletionInfos_1.EmittedAttributeDeletionStatus.ToBeDeletedByRecipient];
+        const forwardingDetailsDocs = await this.forwardingDetails.find({
+            attributeId: attribute.id.toString(),
+            "deletionInfo.deletionStatus": { $nin: excludedDeletionStatuses }
+        });
+        const forwardingDetails = forwardingDetailsDocs.map((doc) => AttributeForwardingDetails_1.AttributeForwardingDetails.from(doc));
+        if (forwardingDetails.length === 0)
+            return [];
+        const peers = forwardingDetails.map((details) => details.peer.toString());
+        const uniquePeers = [...new Set(peers)].map((address) => core_types_1.CoreAddress.from(address));
+        return uniquePeers;
+    }
+    async setDeletionInfoForForwardingPeer(localAttribute, deletionInfo, peer, overrideDeleted = false) {
+        const query = { attributeId: localAttribute.id.toString(), peer: peer.toString() };
+        if (!overrideDeleted)
+            query["deletionInfo.deletionStatus"] = { $ne: deletionInfos_1.EmittedAttributeDeletionStatus.DeletedByRecipient };
+        const doc = await this.forwardingDetails.findOne(query);
+        if (!doc)
+            throw ConsumptionCoreErrors_1.ConsumptionCoreErrors.attributes.cannotSetAttributeDeletionInfo(localAttribute.id, peer);
+        const forwardingDetails = AttributeForwardingDetails_1.AttributeForwardingDetails.from(doc);
+        forwardingDetails.deletionInfo = deletionInfo;
+        await this.forwardingDetails.update(doc, forwardingDetails);
+    }
+    async getForwardingDetailsForAttribute(attribute, query = {}) {
+        const docs = await this.forwardingDetails.find({ ...query, attributeId: attribute.id.toString() });
+        return docs.map((doc) => AttributeForwardingDetails_1.AttributeForwardingDetails.from(doc));
+    }
+    async getAttributesExchangedWithPeer(peer, query, hideTechnical = false, onlyLatestVersions = true) {
+        const attributesForwardedToPeer = await this.getAttributesForwardedToPeer(peer, query, hideTechnical, onlyLatestVersions);
+        const attributesWithPeer = await this.getAttributesWithPeer(peer, query, hideTechnical, onlyLatestVersions);
+        return [...attributesForwardedToPeer, ...attributesWithPeer];
+    }
+    async getAttributesForwardedToPeer(peer, query, hideTechnical = false, onlyLatestVersions = true) {
+        const forwardingDetailsDocs = await this.forwardingDetails.find({ peer: peer.toString() });
+        const forwardingDetails = forwardingDetailsDocs.map((doc) => AttributeForwardingDetails_1.AttributeForwardingDetails.from(doc));
+        const attributeIds = [...new Set(forwardingDetails.map((details) => details.attributeId.toString()))];
+        const queryForForwardedAttributes = { ...query, id: { $in: attributeIds.map((id) => id.toString()) } };
+        const docs = await this.attributes.find(this.addHideTechnicalToQuery(queryForForwardedAttributes, hideTechnical));
+        const attributes = docs.map((doc) => LocalAttribute_1.LocalAttribute.from(doc));
+        for (const attribute of attributes)
+            await this.updateNumberOfForwards(attribute);
+        if (!onlyLatestVersions)
+            return attributes;
+        const latestVersions = [];
+        for (const attribute of attributes) {
+            const sharedSuccessors = await this.getSuccessorsOfAttributeSharedWithPeer(attribute, peer);
+            if (sharedSuccessors.length === 0) {
+                latestVersions.push(attribute);
+            }
+        }
+        return latestVersions;
+    }
+    async getAttributesWithPeer(peer, query, hideTechnical = false, onlyLatestVersions = true) {
+        const queryForAttributesWithPeer = { ...query, peer: peer.toString() };
+        const docs = await this.attributes.find(this.addHideTechnicalToQuery(queryForAttributesWithPeer, hideTechnical));
+        const attributesWithPeer = docs.map((doc) => LocalAttribute_1.LocalAttribute.from(doc));
+        for (const attribute of attributesWithPeer)
+            await this.updateNumberOfForwards(attribute);
+        if (!onlyLatestVersions)
+            return attributesWithPeer;
+        const latestVersions = [];
+        for (const attribute of attributesWithPeer) {
+            const sharedSuccessors = await this.getSuccessorsOfAttribute(attribute);
+            if (sharedSuccessors.length === 0) {
+                latestVersions.push(attribute);
+            }
+        }
+        return latestVersions;
+    }
 }
 exports.AttributesController = AttributesController;
 //# sourceMappingURL=AttributesController.js.map