verification-tracker.hpp

Go to the documentation of this file.

/*
 * This file is part of libkazv.
 * SPDX-FileCopyrightText: 2026 tusooa <tusooa@kazv.moe>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */
 
#pragma once
#include <libkazv-config.hpp>
#include "verification-process.hpp"
#include "verification-utils.hpp"
 
namespace Kazv
{
    struct VerificationTrackerModel
    {
        struct ProcessTheyRequested
        {
            friend bool operator==(const ProcessTheyRequested &a, const ProcessTheyRequested &b) = default;
        };
 
        struct ProcessWaiting
        {
            friend bool operator==(const ProcessWaiting &a, const ProcessWaiting &b) = default;
        };
 
        struct ProcessCodeDisplayed
        {
            immer::array<int> emojiIndices;
 
            immer::array<int> decimalCode;
 
            friend bool operator==(const ProcessCodeDisplayed &a, const ProcessCodeDisplayed &b) = default;
        };
 
        struct ProcessVerifiedThem
        {
            friend bool operator==(const ProcessVerifiedThem &a, const ProcessVerifiedThem &b) = default;
        };
 
        struct ProcessDone
        {
            friend bool operator==(const ProcessDone &a, const ProcessDone &b) = default;
        };
 
        struct ProcessCancelled
        {
            std::string reasonCode;
            std::string reasonString;
            friend bool operator==(const ProcessCancelled &a, const ProcessCancelled &b) = default;
        };
 
        using ProcessState = std::variant<
            ProcessTheyRequested,
            ProcessWaiting,
            ProcessCodeDisplayed,
            ProcessVerifiedThem,
            ProcessDone,
            ProcessCancelled
            >;
 
        struct Process
        {
            std::string theirUserId;
            std::string theirDeviceId;
            Timestamp requestedTs;
            ProcessState state;
            friend bool operator==(const Process &a, const Process &b) = default;
        };
 
        immer::flex_vector<Process> processes;
    };
 
    struct VerificationTracker
    {
        struct PendingEventDesc
        {
            Event event;
            std::string toUserId;
            std::string toDeviceId;
        };
 
        using PendingEvents = immer::flex_vector<PendingEventDesc>;
 
        VerificationUtils::DeviceIdentity identity;
        std::unordered_map<
            std::string /* userId */,
            std::unordered_map<
                std::string /* deviceId */,
                VerificationProcess
                >
            > processes;
        VerificationTrackerModel model;
 
        VerificationTracker(VerificationUtils::DeviceIdentity identity);
 
        // Change functions:
        [[nodiscard]] PendingEvents requestOutgoingToDevice(VerificationUtils::DeviceIdentity theirIdentity, Timestamp now);
 
        [[nodiscard]] PendingEvents processIncoming(Timestamp now, EventList toDevice);
 
        [[nodiscard]] static bool isVerificationEvent(const Event &e);
 
        void setTheirIdentity(VerificationUtils::DeviceIdentity theirId);
 
        void collect(Timestamp now);
 
        [[nodiscard]] PendingEvents userReady(std::string userId, std::string deviceId);
 
        [[nodiscard]] PendingEvents userCancel(std::string userId, std::string deviceId);
 
        [[nodiscard]] PendingEvents userConfirmMatch(std::string userId, std::string deviceId);
 
        [[nodiscard]] PendingEvents userDenyMatch(std::string userId, std::string deviceId);
 
    private:
        void updateModel();
 
        [[nodiscard]] static bool isExpired(const VerificationProcess &process, Timestamp now);
 
        [[nodiscard]] PendingEvents processOne(const Event &e, Timestamp now);
    };
}