Notifications.h

Go to the documentation of this file.

 
#pragma once
#include "ContainerTypes.h"
#include "EntityType.h"
#include "NetworkInfo.h"
#include "NotificationType.h"
#include "catapult/utils/ArraySet.h"
#include "catapult/utils/TimeSpan.h"
#include "catapult/types.h"
#include <vector>
 
namespace catapult { namespace model {
 
    // region base notification
 
    struct Notification {
    public:
        explicit Notification(NotificationType type, size_t size)
                : Type(type)
                , Size(size)
        {}
 
    public:
        NotificationType Type;
 
        size_t Size;
    };
 
    // endregion
 
    // region account
 
    struct AccountAddressNotification : public Notification {
    public:
        static constexpr auto Notification_Type = Core_Register_Account_Address_Notification;
 
    public:
        explicit AccountAddressNotification(const UnresolvedAddress& address)
                : Notification(Notification_Type, sizeof(AccountAddressNotification))
                , Address(address)
        {}
 
    public:
        UnresolvedAddress Address;
    };
 
    struct AccountPublicKeyNotification : public Notification {
    public:
        static constexpr auto Notification_Type = Core_Register_Account_Public_Key_Notification;
 
    public:
        explicit AccountPublicKeyNotification(const Key& publicKey)
                : Notification(Notification_Type, sizeof(AccountPublicKeyNotification))
                , PublicKey(publicKey)
        {}
 
    public:
        const Key& PublicKey;
    };
 
    // endregion
 
    // region balance
 
    template<typename TDerivedNotification>
    struct BasicBalanceNotification : public Notification {
    public:
        BasicBalanceNotification(const Key& sender, UnresolvedMosaicId mosaicId, Amount amount)
                : Notification(TDerivedNotification::Notification_Type, sizeof(TDerivedNotification))
                , Sender(sender)
                , MosaicId(mosaicId)
                , Amount(amount)
        {}
 
    public:
        const Key& Sender;
 
        UnresolvedMosaicId MosaicId;
 
        catapult::Amount Amount;
    };
 
    struct BalanceTransferNotification : public BasicBalanceNotification<BalanceTransferNotification> {
    public:
        static constexpr auto Notification_Type = Core_Balance_Transfer_Notification;
 
    public:
        BalanceTransferNotification(
                const Key& sender,
                const UnresolvedAddress& recipient,
                UnresolvedMosaicId mosaicId,
                catapult::Amount amount)
                : BasicBalanceNotification(sender, mosaicId, amount)
                , Recipient(recipient)
        {}
 
    public:
        UnresolvedAddress Recipient;
    };
 
    struct BalanceDebitNotification : public BasicBalanceNotification<BalanceDebitNotification> {
    public:
        static constexpr auto Notification_Type = Core_Balance_Debit_Notification;
 
    public:
        using BasicBalanceNotification<BalanceDebitNotification>::BasicBalanceNotification;
    };
 
    // endregion
 
    // region entity
 
    struct EntityNotification : public Notification {
    public:
        static constexpr auto Notification_Type = Core_Entity_Notification;
 
    public:
        EntityNotification(model::NetworkIdentifier networkIdentifier, uint8_t entityVersion, uint8_t minVersion, uint8_t maxVersion)
                : Notification(Notification_Type, sizeof(EntityNotification))
                , NetworkIdentifier(networkIdentifier)
                , EntityVersion(entityVersion)
                , MinVersion(minVersion)
                , MaxVersion(maxVersion)
        {}
 
    public:
        model::NetworkIdentifier NetworkIdentifier;
 
        uint8_t EntityVersion;
 
        uint8_t MinVersion;
 
        uint8_t MaxVersion;
    };
 
    // endregion
 
    // region block
 
    struct BlockNotification : public Notification {
    public:
        static constexpr auto Notification_Type = Core_Block_Notification;
 
    public:
        BlockNotification(const Key& signer, const Key& beneficiary, Timestamp timestamp, Difficulty difficulty)
                : Notification(Notification_Type, sizeof(BlockNotification))
                , Signer(signer)
                , Beneficiary(beneficiary)
                , Timestamp(timestamp)
                , Difficulty(difficulty)
                , NumTransactions(0)
        {}
 
    public:
        const Key& Signer;
 
        const Key& Beneficiary;
 
        catapult::Timestamp Timestamp;
 
        catapult::Difficulty Difficulty;
 
        Amount TotalFee;
 
        uint32_t NumTransactions;
    };
 
    // endregion
 
    // region transaction
 
    struct TransactionNotification : public Notification {
    public:
        static constexpr auto Notification_Type = Core_Transaction_Notification;
 
    public:
        TransactionNotification(const Key& signer, const Hash256& transactionHash, EntityType transactionType, Timestamp deadline)
                : Notification(Notification_Type, sizeof(TransactionNotification))
                , Signer(signer)
                , TransactionHash(transactionHash)
                , TransactionType(transactionType)
                , Deadline(deadline)
        {}
 
    public:
        const Key& Signer;
 
        const Hash256& TransactionHash;
 
        EntityType TransactionType;
 
        Timestamp Deadline;
    };
 
    struct TransactionDeadlineNotification : public Notification {
    public:
        static constexpr auto Notification_Type = Core_Transaction_Deadline_Notification;
 
    public:
        TransactionDeadlineNotification(Timestamp deadline, utils::TimeSpan maxLifetime)
                : Notification(Notification_Type, sizeof(TransactionDeadlineNotification))
                , Deadline(deadline)
                , MaxLifetime(maxLifetime)
        {}
 
    public:
        Timestamp Deadline;
 
        utils::TimeSpan MaxLifetime;
    };
 
    struct TransactionFeeNotification : public Notification {
    public:
        static constexpr auto Notification_Type = Core_Transaction_Fee_Notification;
 
    public:
        TransactionFeeNotification(const Key& signer, uint32_t transactionSize, Amount fee, Amount maxFee)
                : Notification(Notification_Type, sizeof(TransactionFeeNotification))
                , Signer(signer)
                , TransactionSize(transactionSize)
                , Fee(fee)
                , MaxFee(maxFee)
        {}
 
    public:
        const Key& Signer;
 
        uint32_t TransactionSize;
 
        Amount Fee;
 
        // Maximum transaction fee.
        Amount MaxFee;
    };
 
    // endregion
 
    // region signature
 
    struct SignatureNotification : public Notification {
    public:
        enum class ReplayProtectionMode { Enabled, Disabled };
 
    public:
        static constexpr auto Notification_Type = Core_Signature_Notification;
 
    public:
        SignatureNotification(
                const Key& signer,
                const Signature& signature,
                const RawBuffer& data,
                ReplayProtectionMode dataReplayProtectionMode = ReplayProtectionMode::Disabled)
                : Notification(Notification_Type, sizeof(SignatureNotification))
                , Signer(signer)
                , Signature(signature)
                , Data(data)
                , DataReplayProtectionMode(dataReplayProtectionMode)
        {}
 
    public:
        const Key& Signer;
 
        const catapult::Signature& Signature;
 
        RawBuffer Data;
 
        ReplayProtectionMode DataReplayProtectionMode;
    };
 
    // endregion
 
    // region address interaction
 
    struct AddressInteractionNotification : public Notification {
    public:
        static constexpr auto Notification_Type = Core_Address_Interaction_Notification;
 
    public:
        AddressInteractionNotification(const Key& source, EntityType transactionType, const UnresolvedAddressSet& participantsByAddress)
                : AddressInteractionNotification(source, transactionType, participantsByAddress, {})
        {}
 
        AddressInteractionNotification(
                const Key& source,
                EntityType transactionType,
                const UnresolvedAddressSet& participantsByAddress,
                const utils::KeySet& participantsByKey)
                : Notification(Notification_Type, sizeof(AddressInteractionNotification))
                , Source(source)
                , TransactionType(transactionType)
                , ParticipantsByAddress(participantsByAddress)
                , ParticipantsByKey(participantsByKey)
        {}
 
    public:
        Key Source;
 
        EntityType TransactionType;
 
        UnresolvedAddressSet ParticipantsByAddress;
 
        utils::KeySet ParticipantsByKey;
    };
 
    // endregion
 
    // region mosaic required
 
    struct MosaicRequiredNotification : public Notification {
    public:
        enum class MosaicType { Resolved, Unresolved };
 
    public:
        static constexpr auto Notification_Type = Core_Mosaic_Required_Notification;
 
    public:
        MosaicRequiredNotification(const Key& signer, MosaicId mosaicId)
                : Notification(Notification_Type, sizeof(MosaicRequiredNotification))
                , Signer(signer)
                , MosaicId(mosaicId)
                , ProvidedMosaicType(MosaicType::Resolved)
        {}
 
        MosaicRequiredNotification(const Key& signer, UnresolvedMosaicId mosaicId)
                : Notification(Notification_Type, sizeof(MosaicRequiredNotification))
                , Signer(signer)
                , UnresolvedMosaicId(mosaicId)
                , ProvidedMosaicType(MosaicType::Unresolved)
        {}
 
    public:
        const Key& Signer;
 
        catapult::MosaicId MosaicId;
 
        catapult::UnresolvedMosaicId UnresolvedMosaicId;
 
        MosaicType ProvidedMosaicType;
    };
 
    // endregion
 
    // region source change
 
    struct SourceChangeNotification : public Notification {
    public:
        enum class SourceChangeType { Absolute, Relative };
 
    public:
        static constexpr auto Notification_Type = Core_Source_Change_Notification;
 
    public:
        SourceChangeNotification(
                SourceChangeType primaryChangeType,
                uint32_t primaryId,
                SourceChangeType secondaryChangeType,
                uint32_t secondaryId)
                : Notification(Notification_Type, sizeof(SourceChangeNotification))
                , PrimaryChangeType(primaryChangeType)
                , PrimaryId(primaryId)
                , SecondaryChangeType(secondaryChangeType)
                , SecondaryId(secondaryId)
        {}
 
    public:
        SourceChangeType PrimaryChangeType;
 
        uint32_t PrimaryId;
 
        SourceChangeType SecondaryChangeType;
 
        uint32_t SecondaryId;
    };
 
    // endregion
}}