No OneTemporary
Actions

Size

102 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/client/CMakeLists.txt b/src/client/CMakeLists.txt
	index 5db284e..f3f664e 100644
	--- a/src/client/CMakeLists.txt
	+++ b/src/client/CMakeLists.txt
	@@ -1,52 +1,53 @@
	set(kazvclient_SRCS
	sdk-model.cpp
	client-model.cpp
	client.cpp
	clientutil.cpp
	status-utils.cpp
	actions/auth.cpp
	actions/sync.cpp
	actions/paginate.cpp
	actions/membership.cpp
	actions/states.cpp
	actions/account-data.cpp
	actions/send.cpp
	actions/ephemeral.cpp
	actions/content.cpp
	actions/encryption.cpp
	actions/profile.cpp
	+ actions/storage.cpp
	device-list-tracker.cpp
	encrypted-file.cpp

	room/room-model.cpp
	room/room.cpp

	push-rules-desc.cpp
	notification-handler.cpp
	power-levels-desc.cpp

	get-content-job-v1.cpp
	alias.cpp
	encode.cpp
	)

	add_library(kazvclient ${kazvclient_SRCS})
	add_library(libkazv::kazvclient ALIAS kazvclient)
	set_target_properties(kazvclient PROPERTIES VERSION ${libkazv_VERSION_STRING} SOVERSION ${libkazv_SOVERSION})

	# https://github.com/google/googletest/issues/1841
	if (MINGW)
	target_compile_options(kazvclient PRIVATE "-Wa,-mbig-obj")
	endif()

	target_link_libraries(kazvclient PUBLIC kazvbase kazvapi kazvcrypto kazvstore Boost::regex)

	target_include_directories(kazvclient PRIVATE .)

	target_include_directories(kazvclient
	INTERFACE
	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
	$<INSTALL_INTERFACE:include/kazv/client>
	)

	install(TARGETS kazvclient EXPORT libkazvTargets LIBRARY)
	diff --git a/src/client/actions/storage.cpp b/src/client/actions/storage.cpp
	new file mode 100644
	index 0000000..2640477
	--- /dev/null
	+++ b/src/client/actions/storage.cpp
	@@ -0,0 +1,44 @@
	+/*
	+ * This file is part of libkazv.
	+ * SPDX-FileCopyrightText: 2025 tusooa <tusooa@kazv.moe>
	+ * SPDX-License-Identifier: AGPL-3.0-or-later
	+ */
	+
	+#include <libkazv-config.hpp>
	+#include "storage.hpp"
	+#include "room/room-model.hpp"
	+#include "debug.hpp"
	+
	+namespace Kazv
	+{
	+ ClientResult updateClient(ClientModel m, LoadEventsFromStorageAction a)
	+ {
	+ for (auto [roomId, timelineEvents]: a.timelineEvents) {
	+ if (!timelineEvents.empty()) {
	+ m.roomList = RoomListModel::update(
	+ std::move(m.roomList),
	+ // If this call is changed, also change the comments in the AddToTimelineAction reducer in room/room-model.cpp
	+ UpdateRoomAction{roomId, AddToTimelineAction{
	+ timelineEvents,
	+ std::nullopt,
	+ std::nullopt,
	+ std::nullopt,
	+ }}
	+ );
	+ }
	+ }
	+
	+ for (auto [roomId, relatedEvents] : a.relatedEvents) {
	+ if (!relatedEvents.empty()) {
	+ m.roomList = RoomListModel::update(
	+ std::move(m.roomList),
	+ UpdateRoomAction{roomId, AddMessagesAction{
	+ relatedEvents,
	+ }}
	+ );
	+ }
	+ }
	+
	+ return { m, lager::noop };
	+ }
	+}
	diff --git a/src/client/actions/storage.hpp b/src/client/actions/storage.hpp
	new file mode 100644
	index 0000000..a2caf6e
	--- /dev/null
	+++ b/src/client/actions/storage.hpp
	@@ -0,0 +1,14 @@
	+/*
	+ * This file is part of libkazv.
	+ * SPDX-FileCopyrightText: 2025 tusooa <tusooa@kazv.moe>
	+ * SPDX-License-Identifier: AGPL-3.0-or-later
	+ */
	+
	+#pragma once
	+#include <libkazv-config.hpp>
	+#include "client-model.hpp"
	+
	+namespace Kazv
	+{
	+ [[nodiscard]] ClientResult updateClient(ClientModel m, LoadEventsFromStorageAction a);
	+}
	diff --git a/src/client/client-model.cpp b/src/client/client-model.cpp
	index a9c63e4..2d75184 100644
	--- a/src/client/client-model.cpp
	+++ b/src/client/client-model.cpp
	@@ -1,425 +1,426 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2020-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>

	#include <immer/algorithm.hpp>
	#include <lager/util.hpp>
	#include <lager/context.hpp>
	#include <functional>

	#include <zug/transducer/filter.hpp>

	#include <immer/flex_vector_transient.hpp>

	#include "debug.hpp"

	#include "immer-utils.hpp"
	#include "json-utils.hpp"

	#include "client-model.hpp"

	#include "actions/states.hpp"
	#include "actions/auth.hpp"
	#include "actions/membership.hpp"
	#include "actions/paginate.hpp"
	#include "actions/send.hpp"
	#include "actions/states.hpp"
	#include "actions/account-data.hpp"
	#include "actions/sync.hpp"
	#include "actions/ephemeral.hpp"
	#include "actions/content.hpp"
	#include "actions/encryption.hpp"
	#include "actions/profile.hpp"
	+#include "actions/storage.hpp"

	namespace Kazv
	{
	auto ClientModel::update(ClientModel m, Action a) -> Result
	{
	auto oldClient = m;
	auto oldDeviceLists = m.deviceLists;

	auto [newClient, effect] = lager::match(std::move(a))(
	[&](RoomListAction a) -> Result {
	m.roomList = RoomListModel::update(std::move(m.roomList), a);
	return {std::move(m), lager::noop};
	},
	[&](ResubmitJobAction a) -> Result {
	m.addJob(std::move(a.job));
	return { std::move(m), lager::noop };
	},
	[&](auto a) -> decltype(updateClient(m, a)) {
	return updateClient(m, a);
	},
	#define RESPONSE_FOR(_jobId) \
	if (r.jobId() == #_jobId) { \
	return processResponse(m, _jobId##Response{std::move(r)}); \
	}

	[&](ProcessResponseAction a) -> Result {
	auto r = std::move(a.response);

	// auth
	RESPONSE_FOR(Login);
	RESPONSE_FOR(GetWellknown);
	RESPONSE_FOR(GetVersions);
	RESPONSE_FOR(Logout);
	// paginate
	RESPONSE_FOR(GetRoomEvents);
	// sync
	RESPONSE_FOR(Sync);
	RESPONSE_FOR(DefineFilter);
	// membership
	RESPONSE_FOR(CreateRoom);
	RESPONSE_FOR(InviteUser);
	RESPONSE_FOR(JoinRoomById);
	RESPONSE_FOR(JoinRoom);
	RESPONSE_FOR(LeaveRoom);
	RESPONSE_FOR(ForgetRoom);
	RESPONSE_FOR(Kick);
	RESPONSE_FOR(Ban);
	RESPONSE_FOR(Unban);
	// send
	RESPONSE_FOR(SendMessage);
	RESPONSE_FOR(SendToDevice);
	RESPONSE_FOR(RedactEvent);
	// states
	RESPONSE_FOR(GetRoomState);
	RESPONSE_FOR(SetRoomStateWithKey);
	RESPONSE_FOR(GetRoomStateWithKey);
	// account data
	RESPONSE_FOR(SetAccountData);
	RESPONSE_FOR(SetAccountDataPerRoom);
	// ephemeral
	RESPONSE_FOR(SetTyping);
	RESPONSE_FOR(PostReceipt);
	RESPONSE_FOR(SetReadMarker);
	// content
	RESPONSE_FOR(UploadContent);
	RESPONSE_FOR(GetContent);
	RESPONSE_FOR(GetContentThumbnail);
	// encryption
	RESPONSE_FOR(UploadKeys);
	RESPONSE_FOR(QueryKeys);
	RESPONSE_FOR(ClaimKeys);
	// profile
	RESPONSE_FOR(GetUserProfile);
	RESPONSE_FOR(SetAvatarUrl);
	RESPONSE_FOR(SetDisplayName);

	m.addTrigger(UnrecognizedResponse{std::move(r)});
	return { std::move(m), lager::noop };
	}

	#undef RESPONSE_FOR
	);

	newClient.maybeRotateSessions(oldClient);

	return { std::move(newClient), std::move(effect) };
	}

	std::pair<Event, std::optional<std::string>> ClientModel::megOlmEncrypt(
	Event e, std::string roomId, Timestamp timeMs, RandomData random)
	{
	if (!crypto) {
	kzo.client.dbg() << "We do not have e2ee, so do not encrypt events" << std::endl;
	return { e, std::nullopt };
	}

	if (e.encrypted()) {
	kzo.client.dbg() << "The event is already encrypted. Ignoring it." << std::endl;
	return { e, std::nullopt };
	}

	auto j = e.originalJson().get();
	auto r = roomList[roomId];

	if (! r.encrypted) {
	kzo.client.dbg() << "The room " << roomId
	<< " is not encrypted, so do not encrypt events" << std::endl;
	return { e, std::nullopt };
	}

	auto desc = r.sessionRotateDesc();

	auto keyOpt = std::optional<std::string>{};
	if (r.shouldRotateSessionKey) {
	kzo.client.dbg() << "We should rotate this session." << std::endl;
	keyOpt = withCrypto([&](auto &c) { return c.rotateMegOlmSessionWithRandom(random, timeMs, roomId); });
	} else {
	keyOpt = withCrypto([&](auto &c) { return c.rotateMegOlmSessionWithRandomIfNeeded(random, timeMs, roomId, desc); });
	}

	// we no longer need to rotate session
	// until next time a device change happens
	roomList.rooms = std::move(roomList.rooms)
	.update(roomId, [](auto r) { r.shouldRotateSessionKey = false; return r; });

	auto relation = hasAtThat(j["content"], "m.relates_to", &json::is_object) ? j["content"]["m.relates_to"] : json(nullptr);
	// so that Crypto::encryptMegOlm() can find room id
	j["room_id"] = roomId;
	auto content = withCrypto([&](auto &c) { return c.encryptMegOlm(j); });
	j["type"] = "m.room.encrypted";
	j["content"] = std::move(content);
	j["content"]["device_id"] = deviceId;
	// add relationship to plaintext
	if (relation.is_object()) {
	j["content"]["m.relates_to"] = relation;
	}

	return { Event(JsonWrap(j)), keyOpt };
	}

	immer::map<std::string, immer::map<std::string, Event>> ClientModel::olmEncryptSplit(
	Event e,
	immer::map<std::string, immer::flex_vector<std::string>> userIdToDeviceIdMap, RandomData random)
	{
	using ResT = immer::map<std::string, immer::map<std::string, Event>>;
	if (!crypto) {
	kzo.client.dbg() << "We do not have e2ee, so do not encrypt events" << std::endl;
	return ResT{};
	}

	if (e.encrypted()) {
	kzo.client.dbg() << "The event is already encrypted. Ignoring it." << std::endl;
	return ResT{};
	}

	auto origJson = e.originalJson().get();

	auto encJson = json::object();
	encJson["content"] = json{
	{"algorithm", CryptoConstants::olmAlgo},
	{"ciphertext", json::object()},
	{"sender_key", constCrypto().curve25519IdentityKey()},
	};

	encJson["type"] = "m.room.encrypted";

	ResT messages;

	for (auto [userId, devices] : userIdToDeviceIdMap) {
	messages = std::move(messages).set(userId, immer::map<std::string, Event>());
	for (auto dev : devices) {
	auto devInfoOpt = deviceLists.get(userId, dev);
	if (! devInfoOpt) {
	continue;
	}
	auto devInfo = devInfoOpt.value();
	auto jsonForThisDevice = origJson;
	jsonForThisDevice["sender"] = this->userId;
	jsonForThisDevice["recipient"] = userId;
	jsonForThisDevice["recipient_keys"] = json{
	{CryptoConstants::ed25519, devInfo.ed25519Key}
	};
	jsonForThisDevice["keys"] = json{
	{CryptoConstants::ed25519, constCrypto().ed25519IdentityKey()}
	};
	auto thisEventJson = encJson;
	thisEventJson["content"]["ciphertext"]
	.merge_patch(withCrypto([&](auto &c) { return c.encryptOlmWithRandom(random, jsonForThisDevice, devInfo.curve25519Key); }));
	random.erase(0, Crypto::encryptOlmMaxRandomSize());
	messages = setIn(std::move(messages), Event(thisEventJson), userId, dev);
	}
	}

	return messages;
	}

	immer::flex_vector<std::string /* deviceId */> ClientModel::devicesToSendKeys(std::string userId) const
	{
	auto trustLevelNeeded = this->trustLevelNeededToSendKeys;

	// XXX: preliminary approach
	auto shouldSendP = [=](auto deviceInfo, auto /* deviceMap */) {
	return deviceInfo.trustLevel >= trustLevelNeeded;
	};


	auto devices = deviceLists.devicesFor(userId);

	return intoImmer(
	immer::flex_vector<std::string>{},
	zug::filter([=](auto n) {
	auto [id, dev] = n;
	return shouldSendP(dev, devices);
	})
	\| zug::map([=](auto n) {
	return n.first;
	}),
	devices);
	}

	std::size_t ClientModel::numOneTimeKeysNeeded() const
	{
	const auto &crypto = constCrypto();

	// Keep half of max supported number of keys
	int numUploadedKeys = crypto.uploadedOneTimeKeysCount(CryptoConstants::signedCurve25519);
	int numKeysNeeded = crypto.maxNumberOfOneTimeKeys() / 2
	- numUploadedKeys;

	// Subtract the number of existing one-time keys, in case
	// the previous upload was not successful.
	int numKeysToGenerate = numKeysNeeded - crypto.numUnpublishedOneTimeKeys();
	if (numKeysToGenerate < 0) {
	numKeysToGenerate = 0;
	}

	return numKeysToGenerate;
	}

	std::size_t EncryptMegOlmEventAction::maxRandomSize()
	{
	return Crypto::rotateMegOlmSessionRandomSize();
	}

	std::size_t EncryptMegOlmEventAction::minRandomSize()
	{
	return 0;
	}

	std::size_t PrepareForSharingRoomKeyAction::randomSize(PrepareForSharingRoomKeyAction::UserIdToDeviceIdMap devices)
	{
	auto singleRandomSize = Crypto::encryptOlmMaxRandomSize();
	auto deviceNum = accumulate(devices, std::size_t{},
	[](auto counter, auto pair) { return counter + pair.second.size(); });
	return deviceNum * singleRandomSize;
	}

	std::size_t GenerateAndUploadOneTimeKeysAction::randomSize(std::size_t numToGen)
	{
	return Crypto::genOneTimeKeysRandomSize(numToGen);
	}

	std::size_t ClaimKeysAction::randomSize(immer::map<std::string, immer::flex_vector<std::string>> devicesToSend)
	{
	auto singleRandomSize = Crypto::createOutboundSessionRandomSize();
	auto deviceNum = accumulate(devicesToSend, std::size_t{},
	[](auto counter, auto pair) { return counter + pair.second.size(); });
	return deviceNum * singleRandomSize;
	}

	void ClientModel::maybeRotateSessions(ClientModel oldClient)
	{
	auto roomIds = intoImmer(
	immer::flex_vector<std::string>{},
	zug::filter([](const auto &pair) {
	return pair.second.encrypted && !pair.second.shouldRotateSessionKey;
	})
	\| zug::map([](const auto &pair) { return pair.first; }),
	roomList.rooms
	);

	auto markRotate = [this](const auto &roomId) {
	roomList.rooms =
	std::move(roomList.rooms)
	.update(roomId, [](auto room) {
	room.shouldRotateSessionKey = true;
	return room;
	});
	};

	// Rotate megolm keys for rooms whose users' device list has changed
	auto changedUsers = deviceLists.diff(oldClient.deviceLists);
	if (! changedUsers.empty()) {
	for (auto roomId : roomIds) {
	auto it = std::find_if(changedUsers.begin(), changedUsers.end(),
	[=](auto userId) { return roomList.rooms[roomId].hasUser(userId); });
	if (it != changedUsers.end()) {
	kzo.client.dbg() << "rotate keys for room " << roomId << std::endl;
	markRotate(roomId);
	}
	}
	}

	roomIds = intoImmer(
	immer::flex_vector<std::string>{},
	zug::filter([](const auto &pair) {
	return pair.second.encrypted && !pair.second.shouldRotateSessionKey;
	})
	\| zug::map([](const auto &pair) { return pair.first; }),
	roomList.rooms
	);

	for (auto roomId : roomIds) {
	auto userIds = roomList.rooms[roomId].joinedMemberIds();
	auto devicesNotChanged = [oldClient, this](const auto &userId) {
	return oldClient.devicesToSendKeys(userId) == devicesToSendKeys(userId);
	};
	// if any user has the device changes
	if (!immer::all_of(userIds, devicesNotChanged)) {
	kzo.client.dbg() << "rotate keys for room " << roomId << std::endl;
	markRotate(roomId);
	}
	}
	}

	auto ClientModel::directRoomMap() const -> immer::map<std::string, std::string>
	{
	auto directs = accountData["m.direct"].content().get();
	auto directItems = directs.items();

	return std::accumulate(directItems.begin(), directItems.end(), immer::map<std::string, std::string>(),
	[](auto acc, const auto &cur) {
	auto [userId, roomIds] = cur;

	if (!roomIds.is_array()) {
	return acc;
	}

	for (auto roomId : roomIds) {
	if (roomId.is_string()) {
	acc = std::move(acc).set(roomId.template get<std::string>(), userId);
	}
	}
	return acc;
	}
	);
	}

	auto ClientModel::roomIdsUnderTag(std::string tagId) const -> immer::map<std::string, double>
	{
	return std::accumulate(
	roomList.rooms.begin(), roomList.rooms.end(),
	immer::map<std::string, double>{},
	[tagId](auto acc, auto cur) {
	auto [roomId, room] = cur;
	auto tags = room.tags();
	if (tags.count(tagId)) {
	acc = std::move(acc).set(roomId, tags[tagId]);
	}
	return acc;
	}
	);
	}

	auto ClientModel::roomIdsByTagId() const -> immer::map<std::string, immer::map<std::string, double>>
	{
	return std::accumulate(
	roomList.rooms.begin(), roomList.rooms.end(),
	immer::map<std::string, immer::map<std::string, double>>{},
	[](auto acc, auto cur) {
	auto [roomId, room] = cur;
	auto tags = room.tags();
	if (tags.empty()) {
	acc = setIn(std::move(acc), ROOM_TAG_DEFAULT_ORDER, "", roomId);
	} else {
	for (const auto &[tagId, order] : tags) {
	acc = setIn(std::move(acc), order, tagId, roomId);
	}
	}
	return acc;
	}
	);
	}

	const Crypto &ClientModel::constCrypto() const
	{
	return crypto.value().get();
	}
	}
	diff --git a/src/client/client-model.hpp b/src/client/client-model.hpp
	index 91f4ae1..a793aea 100644
	--- a/src/client/client-model.hpp
	+++ b/src/client/client-model.hpp
	@@ -1,636 +1,650 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2020-2024 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/


	#pragma once
	#include <libkazv-config.hpp>

	#include <tuple>
	#include <variant>
	#include <string>
	#include <optional>

	#include <lager/context.hpp>
	#include <boost/hana.hpp>
	#include <serialization/std-optional.hpp>


	#include <csapi/sync.hpp>

	#include <file-desc.hpp>
	#include <crypto.hpp>

	#include <serialization/immer-flex-vector.hpp>
	#include <serialization/immer-box.hpp>
	#include <serialization/immer-map.hpp>
	#include <serialization/immer-array.hpp>

	#include "clientfwd.hpp"
	#include "device-list-tracker.hpp"
	#include "room/room-model.hpp"

	namespace Kazv
	{
	inline const std::string DEFTXNID{"0"};

	enum RoomVisibility
	{
	Private,
	Public,
	};

	enum CreateRoomPreset
	{
	PrivateChat,
	PublicChat,
	TrustedPrivateChat,
	};

	enum ThumbnailResizingMethod
	{
	Crop,
	Scale,
	};

	struct ClientModel
	{
	std::string serverUrl;
	std::string userId;
	std::string token;
	std::string deviceId;
	bool loggedIn{false};

	bool syncing{false};
	bool shouldSync{true};
	int firstRetryMs{1000};
	int retryTimeFactor{2};
	int maxRetryMs{30 * 1000};
	int syncTimeoutMs{20000};
	std::string initialSyncFilterId;
	std::string incrementalSyncFilterId;
	std::optional<std::string> syncToken;

	RoomListModel roomList;
	immer::map<std::string /* sender */, Event> presence;
	immer::map<std::string /* type */, Event> accountData;

	std::string nextTxnId{DEFTXNID};
	immer::flex_vector<BaseJob> nextJobs;
	immer::flex_vector<KazvEvent> nextTriggers;

	EventList toDevice;
	std::optional<immer::box<Crypto>> crypto;
	bool identityKeysUploaded{false};

	DeviceListTracker deviceLists;
	DeviceTrustLevel trustLevelNeededToSendKeys{DeviceTrustLevel::Unseen};

	immer::array<std::string /* version */> versions;

	immer::flex_vector<std::string /* deviceId */> devicesToSendKeys(std::string userId) const;

	/// rotate sessions for a room if there is a user in the room with
	/// devicesToSendKeys changes
	void maybeRotateSessions(ClientModel oldClient);

	std::pair<Event, std::optional<std::string> /* sessionKey */>
	megOlmEncrypt(Event e, std::string roomId, Timestamp timeMs, RandomData random);

	/// precondition: the one-time keys for those devices must already be claimed
	/// @return A map from user id to device id to encrypted event for that device
	immer::map<std::string, immer::map<std::string, Event>> olmEncryptSplit(Event e, immer::map<std::string, immer::flex_vector<std::string>> userIdToDeviceIdMap, RandomData random);

	/// @return number of one-time keys we need to generate
	std::size_t numOneTimeKeysNeeded() const;

	/// @return the mapping from room id to user id of direct rooms
	auto directRoomMap() const -> immer::map<std::string, std::string>;

	auto roomIdsUnderTag(std::string tagId) const -> immer::map<std::string, double>;

	auto roomIdsByTagId() const -> immer::map<std::string, immer::map<std::string, double>>;

	/// Get the const reference of crypto of this client.
	///
	/// `crypto.has_value()` must be true.
	const Crypto &constCrypto() const;

	/// Do func with crypto, returning its return value.
	///
	/// `crypto.has_value()` must be true.
	template<class Func>
	auto withCrypto(Func &&func) -> std::decay_t<std::invoke_result_t<Func &&, Crypto &>>
	{
	using ResT = std::decay_t<std::invoke_result_t<Func &&, Crypto &>>;
	if constexpr (std::is_same_v<ResT, void>) {
	crypto = std::move(crypto).value()
	.update([f=std::forward<Func>(func)](Crypto c) mutable {
	std::forward<Func>(f)(c);
	return c;
	});
	} else {
	std::optional<ResT> res;
	crypto = std::move(crypto).value()
	.update([f=std::forward<Func>(func), &res](Crypto c) mutable {
	res = std::forward<Func>(f)(c);
	return c;
	});
	return std::move(res).value();
	}
	}

	// helpers
	template<class Job>
	struct MakeJobT
	{
	template<class ...Args>
	constexpr auto make(Args &&...args) const {
	if constexpr (Job::needsAuth()) {
	return Job(
	serverUrl,
	token,
	std::forward<Args>(args)...);
	} else {
	return Job(
	serverUrl,
	std::forward<Args>(args)...);
	}
	}

	std::string serverUrl;
	std::string token;
	};

	template<class Job>
	constexpr auto job() const {
	return MakeJobT<Job>{serverUrl, token};
	}

	inline void addJob(BaseJob j) {
	nextJobs = std::move(nextJobs).push_back(std::move(j));
	}

	inline auto popAllJobs() {
	auto jobs = std::move(nextJobs);
	nextJobs = DEFVAL;
	return jobs;
	};

	inline void addTrigger(KazvEvent t) {
	addTriggers({t});
	}

	inline void addTriggers(immer::flex_vector<KazvEvent> c) {
	nextTriggers = std::move(nextTriggers) + c;
	}

	inline auto popAllTriggers() {
	auto triggers = std::move(nextTriggers);
	nextTriggers = DEFVAL;
	return triggers;
	}

	using Action = ClientAction;
	using Effect = ClientEffect;
	using Result = ClientResult;

	static Result update(ClientModel m, Action a);
	};

	// actions:
	struct LoginAction {
	std::string serverUrl;
	std::string username;
	std::string password;
	std::optional<std::string> deviceName;
	};

	struct TokenLoginAction
	{
	std::string serverUrl;
	std::string username;
	std::string token;
	std::string deviceId;
	};

	struct LogoutAction {};
	struct HardLogoutAction {};

	struct GetWellknownAction
	{
	std::string userId;
	};

	struct GetVersionsAction
	{
	std::string serverUrl;
	};

	struct SyncAction {};

	struct SetShouldSyncAction
	{
	bool shouldSync;
	};

	struct PaginateTimelineAction
	{
	std::string roomId;
	/// Must be where the Gap is
	std::string fromEventId;
	std::optional<int> limit;
	};

	struct SendMessageAction
	{
	std::string roomId;
	Event event;
	std::optional<std::string> txnId{std::nullopt};
	};

	struct SendStateEventAction
	{
	std::string roomId;
	Event event;
	};

	/**
	* Saves an local echo.
	*
	* After dispatching this action, the result should be such that
	* `result.dataStr("txnId")` contains the transaction id to be used
	* in SendMessageAction.
	*/
	struct SaveLocalEchoAction
	{
	/// The room id
	std::string roomId;
	/// The event to send
	Event event;
	/// The chosen txnId for this event. If not specified, generate from the current ClientModel.
	std::optional<std::string> txnId{std::nullopt};
	};

	/**
	* Updates the status of an local echo.
	*
	* After dispatching this action, the local echo's status will be
	* set to the one described in the action.
	*/
	struct UpdateLocalEchoStatusAction
	{
	/// The room id.
	std::string roomId;
	/// The chosen txnId for this event.
	std::string txnId;
	/// The updated status of this local echo.
	LocalEchoDesc::Status status;
	};

	struct RedactEventAction
	{
	std::string roomId;
	std::string eventId;
	std::optional<std::string> reason;
	};

	struct CreateRoomAction
	{
	using Visibility = RoomVisibility;
	using Preset = CreateRoomPreset;
	Visibility visibility;
	std::optional<std::string> roomAliasName;
	std::optional<std::string> name;
	std::optional<std::string> topic;
	immer::array<std::string> invite;
	//immer::array<Invite3pid> invite3pid;
	std::optional<std::string> roomVersion;
	JsonWrap creationContent;
	immer::array<Event> initialState;
	std::optional<Preset> preset;
	std::optional<bool> isDirect;
	JsonWrap powerLevelContentOverride;
	};

	struct GetRoomStatesAction
	{
	std::string roomId;
	};

	struct GetStateEventAction
	{
	std::string roomId;
	std::string type;
	std::string stateKey;
	};

	struct InviteToRoomAction
	{
	std::string roomId;
	std::string userId;
	};

	struct JoinRoomByIdAction
	{
	std::string roomId;
	};

	struct JoinRoomAction
	{
	std::string roomIdOrAlias;
	immer::array<std::string> serverName;
	};

	struct LeaveRoomAction
	{
	std::string roomId;
	};

	struct ForgetRoomAction
	{
	std::string roomId;
	};

	struct KickAction
	{
	std::string roomId;
	std::string userId;
	std::optional<std::string> reason;
	};

	struct BanAction
	{
	std::string roomId;
	std::string userId;
	std::optional<std::string> reason;
	};

	struct UnbanAction
	{
	std::string roomId;
	std::string userId;
	};

	struct SetAccountDataPerRoomAction
	{
	std::string roomId;
	Event accountDataEvent;
	};

	struct SetTypingAction
	{
	std::string roomId;
	bool typing;
	std::optional<int> timeoutMs;
	};

	struct PostReceiptAction
	{
	std::string roomId;
	std::string eventId;
	};

	struct SetReadMarkerAction
	{
	std::string roomId;
	std::string eventId;
	};

	struct UploadContentAction
	{
	FileDesc content;
	std::optional<std::string> filename;
	std::optional<std::string> contentType;
	std::string uploadId; // to be used by library users
	};

	struct DownloadContentAction
	{
	std::string mxcUri;
	std::optional<FileDesc> downloadTo;
	};

	struct DownloadThumbnailAction
	{
	std::string mxcUri;
	int width;
	int height;
	std::optional<ThumbnailResizingMethod> method;
	std::optional<bool> allowRemote;
	std::optional<FileDesc> downloadTo;
	};

	struct ResubmitJobAction
	{
	BaseJob job;
	};

	struct ProcessResponseAction
	{
	Response response;
	};

	struct PostInitialFiltersAction
	{
	};

	struct SetAccountDataAction
	{
	Event accountDataEvent;
	};

	struct SendToDeviceMessageAction
	{
	Event event;
	immer::map<std::string, immer::flex_vector<std::string>> devicesToSend;
	std::optional<std::string> txnId{std::nullopt};
	};

	/**
	* Send multiple to device messages.
	*
	* Due to limitations of the spec, the type of the Events must be the same.
	*/
	struct SendMultipleToDeviceMessagesAction
	{
	/// A map from user id to device id to the event.
	immer::map<std::string, immer::map<std::string, Event>> userToDeviceToEventMap;
	/// An optional transaction id. Will be generated if not provided.
	std::optional<std::string> txnId{std::nullopt};
	};

	struct UploadIdentityKeysAction
	{
	};

	/**
	* The action to generate one-time keys.
	*
	* `random.size()` must be at least `randomSize(numToGen)`.
	*
	* This action will not generate keys exceeding the local limit of olm.
	*/
	struct GenerateAndUploadOneTimeKeysAction
	{
	/// @return The size of random needed to generate
	/// `numToGen` one-time keys
	static std::size_t randomSize(std::size_t numToGen);
	/// The number of keys to generate
	std::size_t numToGen;
	/// The random data used to generate keys
	RandomData random;
	};

	struct QueryKeysAction
	{
	bool isInitialSync;
	};

	struct ClaimKeysAction
	{
	static std::size_t randomSize(immer::map<std::string, immer::flex_vector<std::string>> devicesToSend);
	std::string roomId;
	std::string sessionId;
	std::string sessionKey;
	immer::map<std::string, immer::flex_vector<std::string>> devicesToSend;
	RandomData random;
	};

	/**
	* The action to encrypt an megolm event for a room.
	*
	* If the action is successful, the result `r` will
	* be such that `r.dataJson("encrypted")` contains the encrypted event json.
	*
	* If the megolm session is rotated, `r.dataStr("key")` will contain the key
	* of the megolm session. Otherwise, `r.data().contains("key")` will be false.
	*
	* The Action may fail due to insufficient random data,
	* when the megolm session needs to be rotated.
	* In this case, the reducer for the Action will fail,
	* and its result `r` will be such that
	* `r.dataStr("reason") == "NotEnoughRandom"`.
	* The user needs to provide random data of
	* at least size `maxRandomSize()`.
	*
	*/
	struct EncryptMegOlmEventAction
	{
	static std::size_t maxRandomSize();
	static std::size_t minRandomSize();

	/// The id of the room to encrypt for.
	std::string roomId;
	/// The event to encrypt.
	Event e;
	/// The timestamp, to determine whether the session should expire.
	Timestamp timeMs;
	/// Random data for the operation. Must be of at least size
	/// `minRandomSize()`. If this is a retry of the previous operation
	/// due to NotEnoughRandom, it must be of at least size `maxRandomSize()`.
	RandomData random;
	};

	struct SetDeviceTrustLevelAction
	{
	std::string userId;
	std::string deviceId;
	DeviceTrustLevel trustLevel;
	};

	struct SetTrustLevelNeededToSendKeysAction
	{
	DeviceTrustLevel trustLevel;
	};

	/// Encrypt room key as olm and add it to the room's
	/// pending keyshare slots.
	/// This is to ensure atomicity and that we do not lose an olm-encrypted event.
	struct PrepareForSharingRoomKeyAction
	{
	using UserIdToDeviceIdMap = immer::map<std::string, immer::flex_vector<std::string>>;
	static std::size_t randomSize(UserIdToDeviceIdMap devices);

	/// The room to share the key event in.
	std::string roomId;
	/// Devices to encrypt for.
	UserIdToDeviceIdMap devices;
	/// The key event to encrypt.
	Event e;
	/// The random data for the encryption. Must be of at least
	/// size `randomSize(devices)`.
	RandomData random;
	};

	struct GetUserProfileAction
	{
	std::string userId;
	};

	struct SetAvatarUrlAction
	{
	std::optional<std::string> avatarUrl;
	};

	struct SetDisplayNameAction
	{
	std::optional<std::string> displayName;
	};

	+ /// Load events from the storage into the model
	+ struct LoadEventsFromStorageAction
	+ {
	+ /// Map from room id to a list of
	+ /// loaded events that should be put into the timeline. From oldest to latest.
	+ immer::map<std::string, EventList> timelineEvents;
	+ /// Map from room id to a list of
	+ /// related events that should not be put into the timeline. From oldest to latest.
	+ /// There might be events in the storage that is needed to display
	+ /// existing events or room state (e.g. pinned events), but
	+ /// the storage may not know its place in the timeline.
	+ immer::map<std::string, EventList> relatedEvents;
	+ };
	+
	template<class Archive>
	void serialize(Archive &ar, ClientModel &m, std::uint32_t const version)
	{
	bool dummySyncing{false};
	ar
	& m.serverUrl
	& m.userId
	& m.token
	& m.deviceId
	& m.loggedIn

	& dummySyncing
	& m.firstRetryMs
	& m.retryTimeFactor
	& m.maxRetryMs
	& m.syncTimeoutMs
	& m.initialSyncFilterId
	& m.incrementalSyncFilterId
	& m.syncToken

	& m.roomList
	& m.presence
	& m.accountData

	& m.nextTxnId

	& m.toDevice;
	// version <= 1 uses std::optional<Crypto>
	// while version >= 2 uses std::optional<immer::box<Crypto>>
	if (version >= 2) {
	ar & m.crypto;
	} else {
	if constexpr (typename Archive::is_loading()) {
	std::optional<Crypto> crypto;
	ar >> crypto;
	if (crypto.has_value()) {
	m.crypto = immer::box<Crypto>(std::move(crypto).value());
	}
	}
	// otherwise is_saving, which will always use the latest version
	// this is unreachable
	}

	ar
	& m.identityKeysUploaded

	& m.deviceLists
	;

	if (version >= 1) { ar & m.trustLevelNeededToSendKeys; }
	}
	}

	BOOST_CLASS_VERSION(Kazv::ClientModel, 2)
	diff --git a/src/client/clientfwd.hpp b/src/client/clientfwd.hpp
	index 1e32d47..a0023b2 100644
	--- a/src/client/clientfwd.hpp
	+++ b/src/client/clientfwd.hpp
	@@ -1,150 +1,154 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2020-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#pragma once
	#include <libkazv-config.hpp>

	#include <tuple>
	#include <variant>

	#include <lager/context.hpp>
	#include <context.hpp>

	#include "room/room-model.hpp"

	namespace Kazv
	{
	using namespace Api;
	class JobInterface;
	class EventInterface;

	struct LoginAction;
	struct TokenLoginAction;
	struct LogoutAction;
	struct HardLogoutAction;
	struct GetWellknownAction;
	struct GetVersionsAction;
	struct SyncAction;
	struct SetShouldSyncAction;
	struct PostInitialFiltersAction;
	struct SetAccountDataAction;
	struct PaginateTimelineAction;
	struct SendMessageAction;
	struct SendStateEventAction;
	struct SaveLocalEchoAction;
	struct UpdateLocalEchoStatusAction;
	struct RedactEventAction;
	struct CreateRoomAction;
	struct GetRoomStatesAction;
	struct GetStateEventAction;
	struct InviteToRoomAction;
	struct JoinRoomByIdAction;
	struct EmitKazvEventsAction;
	struct JoinRoomAction;
	struct LeaveRoomAction;
	struct ForgetRoomAction;
	struct KickAction;
	struct BanAction;
	struct UnbanAction;
	struct SetAccountDataPerRoomAction;

	struct ProcessResponseAction;
	struct SetTypingAction;
	struct PostReceiptAction;
	struct SetReadMarkerAction;

	struct UploadContentAction;
	struct DownloadContentAction;
	struct DownloadThumbnailAction;

	struct SendToDeviceMessageAction;
	struct SendMultipleToDeviceMessagesAction;

	struct UploadIdentityKeysAction;
	struct GenerateAndUploadOneTimeKeysAction;
	struct QueryKeysAction;
	struct ClaimKeysAction;
	struct EncryptMegOlmEventAction;
	struct SetDeviceTrustLevelAction;
	struct SetTrustLevelNeededToSendKeysAction;
	struct PrepareForSharingRoomKeyAction;

	struct GetUserProfileAction;
	struct SetAvatarUrlAction;
	struct SetDisplayNameAction;

	struct ResubmitJobAction;

	+ struct LoadEventsFromStorageAction;
	+
	struct ClientModel;

	using ClientAction = std::variant<
	RoomListAction,

	LoginAction,
	TokenLoginAction,
	LogoutAction,
	HardLogoutAction,
	GetWellknownAction,
	GetVersionsAction,

	SyncAction,
	SetShouldSyncAction,
	PostInitialFiltersAction,
	SetAccountDataAction,

	PaginateTimelineAction,
	SendMessageAction,
	SendStateEventAction,
	SaveLocalEchoAction,
	UpdateLocalEchoStatusAction,
	RedactEventAction,
	CreateRoomAction,
	GetRoomStatesAction,
	GetStateEventAction,
	InviteToRoomAction,
	JoinRoomByIdAction,

	JoinRoomAction,
	LeaveRoomAction,
	ForgetRoomAction,
	KickAction,
	BanAction,
	UnbanAction,
	SetAccountDataPerRoomAction,

	ProcessResponseAction,

	SetTypingAction,
	PostReceiptAction,
	SetReadMarkerAction,

	UploadContentAction,
	DownloadContentAction,
	DownloadThumbnailAction,

	SendToDeviceMessageAction,
	SendMultipleToDeviceMessagesAction,

	UploadIdentityKeysAction,
	GenerateAndUploadOneTimeKeysAction,
	QueryKeysAction,
	ClaimKeysAction,
	EncryptMegOlmEventAction,
	SetDeviceTrustLevelAction,
	SetTrustLevelNeededToSendKeysAction,
	PrepareForSharingRoomKeyAction,

	GetUserProfileAction,
	SetAvatarUrlAction,
	SetDisplayNameAction,

	- ResubmitJobAction
	+ ResubmitJobAction,
	+
	+ LoadEventsFromStorageAction
	>;

	using ClientEffect = Effect<ClientAction, lager::deps<>>;

	using ClientResult = std::pair<ClientModel, ClientEffect>;
	}
	diff --git a/src/client/clientutil.hpp b/src/client/clientutil.hpp
	index b9e636d..b0d7249 100644
	--- a/src/client/clientutil.hpp
	+++ b/src/client/clientutil.hpp
	@@ -1,231 +1,158 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2021-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/


	#pragma once
	#include <libkazv-config.hpp>

	#include <string>
	#include <tuple>
	#include <immer/map.hpp>
	#include <zug/transducer/filter.hpp>
	#include <zug/transducer/eager.hpp>
	#include <lager/deps.hpp>
	#include <boost/container_hash/hash.hpp>
	#include <boost/serialization/string.hpp>

	#include <cursorutil.hpp>
	#include <jobinterface.hpp>
	#include <eventinterface.hpp>
	#include "thread-safety-helper.hpp"

	namespace Kazv
	{
	struct ClientModel;

	template<class K, class V, class List, class Func>
	immer::map<K, V> merge(immer::map<K, V> map, List list, Func keyOf)
	{
	for (auto v : list) {
	auto key = keyOf(v);
	map = std::move(map).set(key, v);
	}
	return map;
	}

	inline std::string keyOfPresence(Event e) {
	return e.sender();
	}

	inline std::string keyOfAccountData(Event e) {
	return e.type();
	}

	inline std::string keyOfTimeline(Event e) {
	return e.id();
	}

	inline std::string keyOfEphemeral(Event e) {
	return e.type();
	}


	struct KeyOfState {
	std::string type;
	std::string stateKey;
	friend bool operator==(const KeyOfState &a, const KeyOfState &b) = default;
	};
	template<class Archive>
	void serialize(Archive &ar, KeyOfState &m, std::uint32_t const /* version */)
	{
	ar & m.type & m.stateKey;
	}

	inline KeyOfState keyOfState(Event e) {
	return {e.type(), e.stateKey()};
	}

	template<class Context>
	JobInterface &getJobHandler(Context &&ctx)
	{
	return lager::get<JobInterface &>(std::forward<Context>(ctx));
	}

	template<class Context>
	EventInterface &getEventEmitter(Context &&ctx)
	{
	return lager::get<EventInterface &>(std::forward<Context>(ctx));
	}

	- namespace
	- {
	- template<class ImmerT>
	- struct ImmerIterator
	- {
	- using value_type = typename ImmerT::value_type;
	- using reference = typename ImmerT::reference;
	- using pointer = const value_type *;
	- using difference_type = long int;
	- using iterator_category = std::random_access_iterator_tag;
	-
	- ImmerIterator(const ImmerT &container, std::size_t index)
	- : m_container(std::ref(container))
	- , m_index(index)
	- {}
	-
	- ImmerIterator &operator+=(difference_type d) {
	- m_index += d;
	- return *this;
	- }
	-
	- ImmerIterator &operator-=(difference_type d) {
	- m_index -= d;
	- return *this;
	- }
	-
	- difference_type operator-(ImmerIterator b) const {
	- return index() - b.index();
	- }
	-
	- ImmerIterator &operator++() {
	- return *this += 1;
	- }
	-
	- ImmerIterator operator++(int) {
	- auto tmp = *this;
	- *this += 1;
	- return tmp;
	- }
	-
	- ImmerIterator &operator--() {
	- return *this -= 1;
	- }
	-
	- ImmerIterator operator--(int) {
	- auto tmp = *this;
	- *this -= 1;
	- return tmp;
	- }
	-
	-
	- reference &operator*() const {
	- return m_container.get().at(m_index);
	- }
	-
	- reference operator[](difference_type d) const;
	-
	- std::size_t index() const { return m_index; }
	-
	- private:
	-
	- std::reference_wrapper<const ImmerT> m_container;
	- std::size_t m_index;
	- };
	-
	- template<class ImmerT>
	- auto ImmerIterator<ImmerT>::operator[](difference_type d) const -> reference
	- {
	- return (this + d);
	- }
	-
	- template<class ImmerT>
	- auto operator+(ImmerIterator<ImmerT> a, long int d)
	- {
	- return a += d;
	- };
	-
	- template<class ImmerT>
	- auto operator+(long int d, ImmerIterator<ImmerT> a)
	- {
	- return a += d;
	- };
	-
	- template<class ImmerT>
	- auto operator-(ImmerIterator<ImmerT> a, long int d)
	- {
	- return a -= d;
	- };
	-
	- template<class ImmerT>
	- auto immerBegin(const ImmerT &c)
	- {
	- return ImmerIterator<ImmerT>(c, 0);
	- }
	-
	- template<class ImmerT>
	- auto immerEnd(const ImmerT &c)
	- {
	- return ImmerIterator<ImmerT>(c, c.size());
	- }
	- }
	-
	+ /**
	+ * Merge `addon` into the sorted container `base`.
	+ *
	+ * This function will look into every item `x` in `addon`. If `exists(x)`,
	+ * nothing is done. Otherwise, it does a binary search in `base`. If
	+ * there is an item `k` where `keyOf(k) == keyOf(x)`, nothing is done.
	+ * Otherwise, `x` is inserted into `base`, keeping the sort order.
	+ *
	+ * This function invokes at most `O(\|addon\|*log(\|base\|))` comparisons; each
	+ * comparison invokes exactly 2 `keyOf`s.
	+ *
	+ * This function invokes at most `\|addon\|` insertions of `base`.
	+ *
	+ * This function invokes `exists` exactly `\|addon\|` times.
	+ *
	+ * @param base An immer sequence container of some type T. `base` must be sorted
	+ * in strict ascending order in terms of `keyOf`. I.e., For any two items x, y: `keyOf(x) < keyOf(y)` iff x is before y.
	+ * @param addon A range of the same type T.
	+ * @param exists A function taking T and producing a boolean value.
	+ * @param keyOf A key function for the sorting of `base`. It must be a strong order.
	+ *
	+ */
	template<class ImmerT1, class RangeT2, class Pred, class Func>
	ImmerT1 sortedUniqueMerge(ImmerT1 base, RangeT2 addon, Pred exists, Func keyOf)
	{
	- auto needToAdd = intoImmer(ImmerT1{},
	- zug::filter([=](auto a) {
	- return !exists(a);
	- }),
	- addon);
	-
	auto cmp = [=](auto a, auto b) {
	return keyOf(a) < keyOf(b);
	};

	- for (auto item : needToAdd) {
	- auto it = std::upper_bound(immerBegin(base), immerEnd(base), item, cmp);
	+ for (auto item : addon) {
	+ if (exists(item)) {
	+ continue;
	+ }
	+ // https://en.cppreference.com/w/cpp/algorithm/upper_bound.html
	+ // (it-1) <= item < it
	+ auto it = std::upper_bound(base.begin(), base.end(), item, cmp);
	+ // If `it` is not the first iterator, and `*(it-1) == item`,
	+ // then `item` is already in the list. Otherwise, we are guaranteed
	+ // that `(it-1)` either does not exist, or `(it-1) < item`.
	+ // In these cases, `item` is not in the list and we will need
	+ // to add them.
	+ if (it.index() != 0 && keyOf(item) == keyOf(*(it - 1))) {
	+ continue;
	+ }
	auto index = it.index();
	base = std::move(base).insert(index, item);
	}

	return base;
	}

	std::string increaseTxnId(std::string cur);

	std::string getTxnId(Event event, ClientModel &m);
	}

	namespace std
	{
	template<> struct hash<Kazv::KeyOfState>
	{
	std::size_t operator()(const Kazv::KeyOfState & k) const noexcept {
	std::size_t seed = 0;
	boost::hash_combine(seed, k.type);
	boost::hash_combine(seed, k.stateKey);
	return seed;
	}
	};
	}

	#define KAZV_WRAP_ATTR(_type, _d, _attr) \
	inline auto _attr() const { \
	KAZV_VERIFY_THREAD_ID(); \
	return (_d)[&_type::_attr]; \
	}

	BOOST_CLASS_VERSION(Kazv::KeyOfState, 0)
	diff --git a/src/client/room/room-model.cpp b/src/client/room/room-model.cpp
	index 7c33cbd..d442325 100644
	--- a/src/client/room/room-model.cpp
	+++ b/src/client/room/room-model.cpp
	@@ -1,683 +1,692 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2020-2024 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>


	#include <lager/util.hpp>
	#include <zug/sequence.hpp>
	#include <zug/transducer/map.hpp>
	#include <zug/transducer/filter.hpp>

	#include "debug.hpp"

	#include "room-model.hpp"
	#include "cursorutil.hpp"
	#include "immer-utils.hpp"

	inline const auto receiptTypes = immer::flex_vector<std::string>{"m.read", "m.read.private"};

	template<class Func>
	static std::string getMaxInTimeline(std::string a, std::string b, Func sortKey)
	{
	if (a.empty() && b.empty()) {
	return std::string();
	} else {
	// for an unexisting event, event id is empty and timestamp is 0
	// for an existing event, event id is not empty and timestamp >= 0
	// so this handles all cases even when we do not have the corresponding event
	return std::max(a, b, [=](const std::string &x, const std::string &y) {
	return sortKey(x) < sortKey(y);
	});
	}
	}

	namespace Kazv
	{
	PendingRoomKeyEvent makePendingRoomKeyEventV0(std::string txnId, Event event, immer::map<std::string, immer::flex_vector<std::string>> devices)
	{
	immer::map<std::string, immer::map<std::string, Event>> messages;
	for (auto [userId, deviceIds] : devices) {
	messages = setIn(std::move(messages), immer::map<std::string, Event>(), userId);
	for (auto deviceId : deviceIds) {
	messages = setIn(
	std::move(messages),
	event,
	userId, deviceId
	);
	}
	}
	return PendingRoomKeyEvent{txnId, messages};
	}

	auto sortKeyForTimelineEvent(Event e) -> std::tuple<Timestamp, std::string>
	{
	return std::make_tuple(e.originServerTs(), e.id());
	}

	RoomModel RoomModel::update(RoomModel r, Action a)
	{
	return lager::match(std::move(a))(
	[&](AddStateEventsAction a) {
	r.stateEvents = merge(std::move(r.stateEvents), a.stateEvents, keyOfState);

	// If m.room.encryption state event appears,
	// configure the room to use encryption.
	if (r.stateEvents.find(KeyOfState{"m.room.encryption", ""})) {
	auto newRoom = update(std::move(r), SetRoomEncryptionAction{});
	r = std::move(newRoom);
	}
	return r;
	},
	[&](MaybeAddStateEventsAction a) {
	for (auto it = a.stateEvents.rbegin();
	it != a.stateEvents.rend();
	++it) {
	const auto &e = *it;
	auto k = keyOfState(e);
	if (!r.stateEvents.count(k)) {
	r.stateEvents = std::move(r.stateEvents).set(k, e);
	}
	}
	return r;
	},
	- [&](AddToTimelineAction a) {
	- auto eventIds = intoImmer(immer::flex_vector<std::string>(),
	- zug::map(keyOfTimeline), a.events);
	-
	- auto oldMessages = r.messages;
	+ [&](AddMessagesAction a) {
	r.messages = merge(std::move(r.messages), a.events, keyOfTimeline);
	- auto exists =
	- [=](auto eventId) -> bool {
	- return !! oldMessages.find(eventId);
	- };
	- auto key =
	- [=](auto eventId) {
	- // sort first by timestamp, then by id
	- return sortKeyForTimelineEvent(r.messages[eventId]);
	- };

	auto handleRedaction =
	[&r](const auto &event) {
	if (event.type() == "m.room.redaction") {
	auto origJson = event.originalJson().get();
	if (origJson.contains("redacts") && origJson.at("redacts").is_string()) {
	auto redactedEventId = origJson.at("redacts").template get<std::string>();
	if (r.messages.find(redactedEventId)) {
	r.messages = std::move(r.messages).update(redactedEventId, [&origJson](const auto &eventToBeRedacted) {
	auto newJson = eventToBeRedacted.originalJson().get();
	newJson.merge_patch(json{
	{"unsigned", {{"redacted_because", std::move(origJson)}}},
	});
	newJson["content"] = json::object();
	return Event(newJson);
	});
	}
	}
	}
	return event;
	};

	immer::for_each(a.events, handleRedaction);

	- r.timeline = sortedUniqueMerge(r.timeline, eventIds, exists, key);
	-
	- // If this is a pagination request, gapEventId
	- // should have value. If this is a sync request,
	- // gapEventId does not have value. The pagination
	- // request does not have the limited field, and
	- // whether it has more paginate back token is determined
	- // by the presence of the prevBatch parameter.
	- // In sync request, limited may not be specified,
	- // and thus, if limited does not have value, it means
	- // it is not limited.
	+ // remove all local echoes that are received
	+ for (const auto &e : a.events) {
	+ auto jw = e.originalJson();
	+ const auto &json = jw.get();
	+ if (json.contains("unsigned")
	+ && json["unsigned"].contains("transaction_id")
	+ && json["unsigned"]["transaction_id"].is_string()) {
	+ r = update(std::move(r), RemoveLocalEchoAction{json["unsigned"]["transaction_id"].template get<std::string>()});
	+ }
	+ }
	+
	+ // calculate event relationships
	+ r.generateRelationships(a.events);
	+
	+ r.addToUndecryptedEvents(a.events);
	+
	+ return r;
	+ },
	+ [&](AddToTimelineAction a) {
	+ auto eventIds = intoImmer(immer::flex_vector<std::string>(),
	+ zug::map(keyOfTimeline), a.events);
	+
	+ auto oldMessages = r.messages;
	+ auto next = RoomModel::update(std::move(r), AddMessagesAction{a.events});
	+ r = std::move(next);
	+ auto key =
	+ [=](auto eventId) {
	+ // sort first by timestamp, then by id
	+ return sortKeyForTimelineEvent(r.messages[eventId]);
	+ };
	+
	+ // Things in messages do not always appear in the timeline.
	+ // Let `exists` function to always return false, so that it is checked for duplicates automatically.
	+ r.timeline = sortedUniqueMerge(r.timeline, eventIds, [](auto &&) { return false; }, key);
	+
	+ // We have 3 possibilities for the source of calling this action:
	+ // pagination, sync, or load from storage.
	+ //
	+ // In pagination: `gapEventId.has_value() && !limited.has_value()`
	+ // If we can paginate back: `prevBatch.has_value()`
	+ //
	+ // In sync: `!gapEventId.has_value()`
	+ // If limited: `limited.has_value() && limited.value()`
	+ // If we can paginate back: `prevBatch.has_value()` (should always be present, but we do not add a Gap if it is not limited)
	+ //
	+ // In load from storage: `!gapEventId.has_value() && !limited.has_value() && !prevBatch.has_value()` (Because of actions/storage.cpp)
	+
	+ // Only pagination and sync can add a Gap
	if (((a.limited.has_value() && a.limited.value())
	\|\| a.gapEventId.has_value())
	&& a.prevBatch.has_value()) {
	// this sync is limited, add a Gap here
	if (!eventIds.empty()) {
	r.timelineGaps = std::move(r.timelineGaps).set(eventIds[0], a.prevBatch.value());
	}
	}

	+ // Only pagination can remove Gaps
	// remove the original Gap, as it is resolved
	if (a.gapEventId.has_value()) {
	r.timelineGaps = std::move(r.timelineGaps).erase(a.gapEventId.value());
	}

	// remove all Gaps between the gapped event and the first event in this batch
	if (!eventIds.empty() && a.gapEventId.has_value()) {
	auto cmp = [=](auto a, auto b) {
	return key(a) < key(b);
	};
	auto thisBatchStart = std::equal_range(r.timeline.begin(), r.timeline.end(), eventIds[0], cmp).first;
	auto origBatchStart = std::equal_range(thisBatchStart, r.timeline.end(), a.gapEventId.value(), cmp).first;

	// Safety assert: we do not want to execute the for_each if the range is empty,
	// or it will go out of bounds.
	if (thisBatchStart.index() < origBatchStart.index()) {
	std::for_each(thisBatchStart + 1, origBatchStart,
	[&](auto eventId) {
	r.timelineGaps = std::move(r.timelineGaps).erase(eventId);
	});
	}
	}

	- // remove all local echoes that are received
	- for (const auto &e : a.events) {
	- auto jw = e.originalJson();
	- const auto &json = jw.get();
	- if (json.contains("unsigned")
	- && json["unsigned"].contains("transaction_id")
	- && json["unsigned"]["transaction_id"].is_string()) {
	- r = update(std::move(r), RemoveLocalEchoAction{json["unsigned"]["transaction_id"].template get<std::string>()});
	- }
	- }
	-
	- // calculate event relationships
	- r.generateRelationships(a.events);
	-
	- r.addToUndecryptedEvents(a.events);
	-
	return r;
	},
	[&](AddAccountDataAction a) {
	r.accountData = merge(std::move(r.accountData), a.events, keyOfAccountData);
	return r;
	},
	[&](ChangeMembershipAction a) {
	r.membership = a.membership;
	return r;
	},
	[&](ChangeInviteStateAction a) {
	r.inviteState = merge(immer::map<KeyOfState, Event>{}, a.events, keyOfState);
	return r;
	},
	[&](AddEphemeralAction a) {
	auto processReceipt = [&](Event e) {
	const auto content = e.content().get();
	for (auto [eventId, receipts] : content.items()) {
	if (!receipts.is_object()) {
	continue;
	}
	for (auto receiptType : receiptTypes) {
	if (!(receipts.contains(receiptType)
	&& receipts[receiptType].is_object())) {
	continue;
	}

	for (auto [user, receipt]: receipts[receiptType].items()) {
	ReadReceipt readReceipt{
	eventId,
	0,
	};

	if (receipt.is_object() && receipt.contains("ts")
	&& receipt["ts"].is_number()) {
	readReceipt.timestamp = receipt["ts"].template get<Timestamp>();
	}

	// Remove old receipts
	if (r.readReceipts.count(user)) {
	auto oldReceiptEventId = r.readReceipts[user].eventId;
	if (r.eventReadUsers.count(oldReceiptEventId)) {
	auto remaining =
	intoImmer(
	immer::flex_vector<std::string>{},
	zug::filter([user=user](auto userId) {
	return userId != user;
	}),
	r.eventReadUsers[oldReceiptEventId]
	);

	if (remaining.empty()) {
	r.eventReadUsers = std::move(r.eventReadUsers).erase(oldReceiptEventId);
	} else {
	r.eventReadUsers = std::move(r.eventReadUsers).set(oldReceiptEventId, remaining);
	}
	}
	}

	// Add new receipt
	r.readReceipts = std::move(r.readReceipts).set(user, readReceipt);
	auto oldReadUsers = r.eventReadUsers[eventId];
	r.eventReadUsers = std::move(r.eventReadUsers).set(eventId, oldReadUsers.push_back(user));
	}
	}
	}
	};

	for (auto e : a.events) {
	if (e.type() == "m.receipt") {
	processReceipt(e);
	}
	}
	r.ephemeral = merge(std::move(r.ephemeral), a.events, keyOfEphemeral);
	return r;
	},
	[&](SetLocalDraftAction a) {
	r.localDraft = a.localDraft;
	return r;
	},
	[&](SetRoomEncryptionAction) {
	r.encrypted = true;
	return r;
	},
	[&](MarkMembersFullyLoadedAction) {
	r.membersFullyLoaded = true;
	return r;
	},
	[&](SetHeroIdsAction a) {
	r.heroIds = a.heroIds;
	return r;
	},
	[&](AddLocalEchoAction a) {
	auto it = std::find_if(r.localEchoes.begin(), r.localEchoes.end(), [a](const auto &desc) {
	return desc.txnId == a.localEcho.txnId;
	});
	if (it == r.localEchoes.end()) {
	r.localEchoes = std::move(r.localEchoes).push_back(a.localEcho);
	} else {
	r.localEchoes = std::move(r.localEchoes).set(it.index(), a.localEcho);
	}
	return r;
	},
	[&](RemoveLocalEchoAction a) {
	auto it = std::find_if(r.localEchoes.begin(), r.localEchoes.end(), [a](const auto &desc) {
	return desc.txnId == a.txnId;
	});
	if (it != r.localEchoes.end()) {
	r.localEchoes = std::move(r.localEchoes).erase(it.index());
	}
	return r;
	},
	[&](AddPendingRoomKeyAction a) {
	auto it = std::find_if(r.pendingRoomKeyEvents.begin(), r.pendingRoomKeyEvents.end(), [a](const auto &p) {
	return p.txnId == a.pendingRoomKeyEvent.txnId;
	});
	if (it == r.pendingRoomKeyEvents.end()) {
	r.pendingRoomKeyEvents = std::move(r.pendingRoomKeyEvents).push_back(a.pendingRoomKeyEvent);
	} else {
	r.pendingRoomKeyEvents = std::move(r.pendingRoomKeyEvents).set(it.index(), a.pendingRoomKeyEvent);
	}
	return r;
	},
	[&](RemovePendingRoomKeyAction a) {
	auto it = std::find_if(r.pendingRoomKeyEvents.begin(), r.pendingRoomKeyEvents.end(), [a](const auto &desc) {
	return desc.txnId == a.txnId;
	});
	if (it != r.pendingRoomKeyEvents.end()) {
	r.pendingRoomKeyEvents = std::move(r.pendingRoomKeyEvents).erase(it.index());
	}
	return r;
	},
	[&](UpdateJoinedMemberCountAction a) {
	r.joinedMemberCount = a.joinedMemberCount;
	return r;
	},
	[&](UpdateInvitedMemberCountAction a) {
	r.invitedMemberCount = a.invitedMemberCount;
	return r;
	},
	[&](AddLocalNotificationsAction a) {
	auto k = [r](const auto &id) {
	return sortKeyForTimelineEvent(r.messages[id]);
	};

	auto readReceiptForCurrentUser = getMaxInTimeline(r.readReceipts[a.myUserId].eventId, r.localReadMarker, k);

	auto newEventIds = intoImmer(
	immer::flex_vector<std::string>{},
	zug::map(&Event::id),
	a.newEvents
	);

	auto needToAddPredicate = [a, r, k, readReceiptForCurrentUser](const auto &eid) {
	if (!readReceiptForCurrentUser.empty()
	&& k(readReceiptForCurrentUser) >= k(eid)) {
	// this means this event is already read
	return false;
	}
	auto e = r.messages[eid];
	return e.sender() != a.myUserId
	&& a.pushRulesDesc.handle(e, r).shouldNotify;
	};

	r.unreadNotificationEventIds = sortedUniqueMerge(std::move(r.unreadNotificationEventIds), newEventIds, [needToAddPredicate](const auto &e) { return !needToAddPredicate(e); }, k);
	return r;
	},
	[&](RemoveReadLocalNotificationsAction a) {
	auto k = [r](const auto &id) {
	return sortKeyForTimelineEvent(r.messages[id]);
	};
	auto cmp = [k](const auto &a, const auto &b) {
	return k(a) < k(b);
	};

	auto rr = getMaxInTimeline(
	r.readReceipts[a.myUserId].eventId,
	r.localReadMarker,
	k
	);
	if (rr.empty()) {
	return r;
	}

	auto it = std::upper_bound(
	r.unreadNotificationEventIds.begin(),
	r.unreadNotificationEventIds.end(),
	rr,
	cmp
	);
	// it > rr, (it - 1) <= rr (if it - 1 is valid)
	if (it == r.unreadNotificationEventIds.end()) {
	// If it == end(), it means everything is read
	r.unreadNotificationEventIds = {};
	} else if (it == r.unreadNotificationEventIds.begin()) {
	// If it == begin(), it means everything is unread, so nothing to do
	} else {
	// it is somewhere in the middle, pointing to the first element that is unread
	r.unreadNotificationEventIds = std::move(r.unreadNotificationEventIds).erase(0, it.index());
	}
	return r;
	},
	[&](UpdateLocalReadMarkerAction a) {
	r.localReadMarker = a.localReadMarker;
	auto next = RoomModel::update(std::move(r), RemoveReadLocalNotificationsAction{a.myUserId});
	return next;
	}
	);
	}

	RoomListModel RoomListModel::update(RoomListModel l, Action a)
	{
	return lager::match(std::move(a))(
	[&](UpdateRoomAction a) {
	l.rooms = std::move(l.rooms)
	.update(a.roomId,
	[=](RoomModel oldRoom) {
	oldRoom.roomId = a.roomId; // in case it is a new room
	return RoomModel::update(std::move(oldRoom), a.roomAction);
	});
	return l;
	}
	);
	}

	static auto membershipTransducer(const std::string &membership)
	{
	return zug::filter([](auto val) {
	auto [k, v] = val;
	auto [type, stateKey] = k;
	return type == "m.room.member"s;
	})
	\| zug::map([](auto val) {
	auto [k, v] = val;
	auto [type, stateKey] = k;
	return std::pair<std::string, Kazv::Event>{stateKey, v};
	})
	\| zug::filter([&membership](auto val) {
	auto [stateKey, ev] = val;
	return ev.content().get()
	.at("membership"s) == membership;
	});
	}

	static auto memberIdsByMembership(immer::map<KeyOfState, Event> stateEvents, const std::string &membership)
	{
	return intoImmer(
	immer::flex_vector<std::string>{},
	membershipTransducer(membership)
	\| zug::map([](auto val) {
	auto [stateKey, ev] = val;
	return stateKey;
	}),
	stateEvents);
	}

	auto memberEventsByMembership(immer::map<KeyOfState, Event> stateEvents, const std::string &membership)
	{
	return intoImmer(
	EventList{},
	membershipTransducer(membership)
	\| zug::map([](auto val) {
	auto [stateKey, ev] = val;
	return ev;
	}),
	stateEvents);
	}

	immer::flex_vector<std::string> RoomModel::joinedMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "join"s);
	}

	immer::flex_vector<std::string> RoomModel::invitedMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "invite"s);
	}

	immer::flex_vector<std::string> RoomModel::knockedMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "knock"s);
	}

	immer::flex_vector<std::string> RoomModel::leftMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "leave"s);
	}

	immer::flex_vector<std::string> RoomModel::bannedMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "ban"s);
	}

	EventList RoomModel::joinedMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "join"s);
	}

	EventList RoomModel::invitedMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "invite"s);
	}

	EventList RoomModel::knockedMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "knock"s);
	}

	EventList RoomModel::leftMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "leave"s);
	}

	EventList RoomModel::bannedMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "ban"s);
	}

	EventList RoomModel::heroMemberEvents() const
	{
	return intoImmer(
	EventList{},
	zug::filter([heroIds=heroIds](auto val) {
	auto [k, ev] = val;
	auto [type, stateKey] = k;
	return type == "m.room.member"s &&
	std::find(heroIds.begin(), heroIds.end(), stateKey) != heroIds.end();
	})
	\| zug::map([](auto val) {
	auto [_, ev] = val;
	return ev;
	}),
	stateEvents);
	}

	static Timestamp defaultRotateMs = 604800000;
	static int defaultRotateMsgs = 100;

	MegOlmSessionRotateDesc RoomModel::sessionRotateDesc() const
	{
	auto k = KeyOfState{"m.room.encryption", ""};
	auto content = stateEvents[k].content().get();
	auto ms = content.contains("rotation_period_ms")
	? content["rotation_period_ms"].get<Timestamp>()
	: defaultRotateMs;
	auto msgs = content.contains("rotation_period_msgs")
	? content["rotation_period_msgs"].get<int>()
	: defaultRotateMsgs;
	return MegOlmSessionRotateDesc{ ms, msgs };
	}

	bool RoomModel::hasUser(std::string userId) const
	{
	try {
	auto ev = stateEvents.at(KeyOfState{"m.room.member", userId});
	if (ev.content().get().at("membership") == "join") {
	return true;
	}
	} catch (const std::exception &) {
	return false;
	}
	return false;
	}

	std::optional<LocalEchoDesc> RoomModel::getLocalEchoByTxnId(std::string txnId) const
	{
	auto it = std::find_if(localEchoes.begin(), localEchoes.end(), [txnId](const auto &desc) {
	return txnId == desc.txnId;
	});
	if (it != localEchoes.end()) {
	return *it;
	} else {
	return std::nullopt;
	}
	}

	std::optional<PendingRoomKeyEvent> RoomModel::getPendingRoomKeyEventByTxnId(std::string txnId) const
	{
	auto it = std::find_if(pendingRoomKeyEvents.begin(), pendingRoomKeyEvents.end(), [txnId](const auto &desc) {
	return txnId == desc.txnId;
	});
	if (it != pendingRoomKeyEvents.end()) {
	return *it;
	} else {
	return std::nullopt;
	}
	}

	static double getTagOrder(const json &tag)
	{
	// https://spec.matrix.org/v1.7/client-server-api/#events-12
	// If a room has a tag without an order key then it should appear after the rooms with that tag that have an order key.
	return tag.contains("order") && tag["order"].is_number()
	? tag["order"].template get<double>()
	: ROOM_TAG_DEFAULT_ORDER;
	}

	immer::map<std::string, double> RoomModel::tags() const
	{
	auto content = accountData["m.tag"].content().get();
	if (!content.contains("tags") \|\| !content["tags"].is_object()) {
	return {};
	}

	auto tagsObject = content["tags"];
	auto tagsItems = tagsObject.items();
	return std::accumulate(tagsItems.begin(), tagsItems.end(), immer::map<std::string, double>(),
	[=](auto acc, const auto &cur) {
	auto [id, tag] = cur;
	return std::move(acc).set(id, getTagOrder(tag));
	}
	);
	}

	static auto normalizeTagEventJson(Event e)
	{
	auto content = e.content().get();
	if (!content.contains("tags") \|\| !content["tags"].is_object()) {
	content["tags"] = json::object();
	}
	return json{
	{"content", content},
	{"type", "m.tag"},
	};
	}

	Event RoomModel::makeAddTagEvent(std::string tagId, std::optional<double> order) const
	{
	auto eventJson = normalizeTagEventJson(accountData["m.tag"]);
	auto tag = json::object();
	if (order.has_value()) {
	tag["order"] = order.value();
	}

	eventJson["content"]["tags"][tagId] = tag;
	return Event(eventJson);
	}

	Event RoomModel::makeRemoveTagEvent(std::string tagId) const
	{
	auto eventJson = normalizeTagEventJson(accountData["m.tag"]);
	eventJson["content"]["tags"].erase(tagId);
	return Event(eventJson);
	}

	void RoomModel::generateRelationships(EventList newEvents)
	{
	for (const auto &event: newEvents) {
	auto [relType, eventId] = event.relationship();
	if (!relType.empty()) {
	reverseEventRelationships = updateIn(std::move(reverseEventRelationships), [event](auto &&evs) {
	return evs.push_back(event.id());
	}, eventId, relType);
	}
	}
	}

	void RoomModel::regenerateRelationships()
	{
	generateRelationships(intoImmer(EventList{}, zug::map([](const auto &kv) {
	return kv.second;
	}), messages));
	}

	void RoomModel::addToUndecryptedEvents(EventList newEvents)
	{
	if (!encrypted) {
	return;
	}

	for (auto event : newEvents) {
	if (event.encrypted() && !event.decrypted()) {
	auto original = event.originalJson();
	const auto &o = original.get();
	if (o.contains("content")
	&& o["content"].contains("session_id")
	&& o["content"]["session_id"].is_string()
	) {
	auto sessionId = o["content"]["session_id"].template get<std::string>();
	undecryptedEvents = std::move(undecryptedEvents)
	.update(sessionId, [id=event.id()](const auto &v) {
	return v.push_back(id);
	});
	}
	}
	}
	}

	void RoomModel::recalculateUndecryptedEvents()
	{
	if (!encrypted) {
	return;
	}

	addToUndecryptedEvents(intoImmer(EventList{}, zug::map([](const auto &kv) {
	return kv.second;
	}), messages));
	}
	}
	diff --git a/src/client/room/room-model.hpp b/src/client/room/room-model.hpp
	index 5eac465..6ff3274 100644
	--- a/src/client/room/room-model.hpp
	+++ b/src/client/room/room-model.hpp
	@@ -1,454 +1,462 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2021-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/


	#pragma once
	#include <libkazv-config.hpp>

	#include <string>
	#include <variant>
	#include <immer/flex_vector.hpp>
	#include <immer/map.hpp>

	#include <serialization/immer-flex-vector.hpp>
	#include <serialization/immer-box.hpp>
	#include <serialization/immer-map.hpp>
	#include <serialization/immer-array.hpp>

	#include <csapi/sync.hpp>
	#include <event.hpp>

	#include <crypto.hpp>
	#include "push-rules-desc.hpp"
	#include "local-echo.hpp"
	#include "clientutil.hpp"

	namespace Kazv
	{
	struct PendingRoomKeyEvent
	{
	std::string txnId;
	immer::map<std::string, immer::map<std::string, Event>> messages;

	friend bool operator==(const PendingRoomKeyEvent &a, const PendingRoomKeyEvent &b) = default;
	friend bool operator!=(const PendingRoomKeyEvent &a, const PendingRoomKeyEvent &b) = default;
	};

	PendingRoomKeyEvent makePendingRoomKeyEventV0(std::string txnId, Event event, immer::map<std::string, immer::flex_vector<std::string>> devices);

	struct ReadReceipt
	{
	std::string eventId;
	Timestamp timestamp;
	friend bool operator==(const ReadReceipt &a, const ReadReceipt &b) = default;
	friend bool operator!=(const ReadReceipt &a, const ReadReceipt &b) = default;
	};

	template<class Archive>
	void serialize(Archive &ar, ReadReceipt &r, std::uint32_t const /* version */)
	{
	ar & r.eventId & r.timestamp;
	}


	struct EventReader
	{
	std::string userId;
	Timestamp timestamp;
	friend bool operator==(const EventReader &a, const EventReader &b) = default;
	friend bool operator!=(const EventReader &a, const EventReader &b) = default;
	};

	struct AddStateEventsAction
	{
	immer::flex_vector<Event> stateEvents;
	};

	/// Go from the back of stateEvents to the beginning,
	/// adding the event to room state only if the room
	/// has no state event with that state key.
	struct MaybeAddStateEventsAction
	{
	immer::flex_vector<Event> stateEvents;
	};

	+ /// Add events to the messages map, but not the timeline.
	+ /// Usually because their position in the timeline is not known.
	+ struct AddMessagesAction
	+ {
	+ EventList events;
	+ };
	+
	struct AddToTimelineAction
	{
	/// Events from oldest to latest
	immer::flex_vector<Event> events;
	std::optional<std::string> prevBatch;
	std::optional<bool> limited;
	std::optional<std::string> gapEventId;
	};

	struct AddAccountDataAction
	{
	immer::flex_vector<Event> events;
	};

	struct ChangeMembershipAction
	{
	RoomMembership membership;
	};

	struct ChangeInviteStateAction
	{
	immer::flex_vector<Event> events;
	};

	struct AddEphemeralAction
	{
	EventList events;
	};

	struct SetLocalDraftAction
	{
	std::string localDraft;
	};

	struct SetRoomEncryptionAction
	{
	};

	struct MarkMembersFullyLoadedAction
	{
	};

	struct SetHeroIdsAction
	{
	immer::flex_vector<std::string> heroIds;
	};

	struct AddLocalEchoAction
	{
	LocalEchoDesc localEcho;
	};

	struct RemoveLocalEchoAction
	{
	std::string txnId;
	};

	struct AddPendingRoomKeyAction
	{
	PendingRoomKeyEvent pendingRoomKeyEvent;
	};

	struct RemovePendingRoomKeyAction
	{
	std::string txnId;
	};

	struct UpdateJoinedMemberCountAction
	{
	std::size_t joinedMemberCount;
	};

	struct UpdateInvitedMemberCountAction
	{
	std::size_t invitedMemberCount;
	};

	/// Update local notifications to include the new events
	///
	/// Precondition: newEvents are already in room.messages
	struct AddLocalNotificationsAction
	{
	EventList newEvents;
	PushRulesDesc pushRulesDesc;
	std::string myUserId;
	};

	/// Remove local notifications that are already read
	struct RemoveReadLocalNotificationsAction
	{
	std::string myUserId;
	};

	/// Update the local read marker, removing any read notifications before it.
	struct UpdateLocalReadMarkerAction
	{
	std::string localReadMarker;
	std::string myUserId;
	};

	inline const double ROOM_TAG_DEFAULT_ORDER = 2;

	template<class Archive>
	void serialize(Archive &ar, PendingRoomKeyEvent &e, std::uint32_t const version)
	{
	if (version < 1) {
	// loading an older version where there is only one event
	std::string txnId;
	Event event;
	immer::map<std::string, immer::flex_vector<std::string>> devices;
	ar & txnId & event & devices;
	e = makePendingRoomKeyEventV0(
	std::move(txnId), std::move(event), std::move(devices));
	} else {
	ar & e.txnId & e.messages;
	}
	}

	/**
	* Get the sort key for a timeline event.
	*
	* If the key is larger, the event should be placed
	* at the more recent end of the timeline.
	*
	* @param e The event to get the sort key for.
	* @return The sort key. You MUST use `auto` to store the
	* result.
	*/
	auto sortKeyForTimelineEvent(Event e) -> std::tuple<Timestamp, std::string>;

	struct RoomModel
	{
	using Membership = RoomMembership;
	using ReverseEventRelationshipMap = immer::map<
	std::string /* related event id */,
	immer::map<std::string /* relation type /, immer::flex_vector<std::string / relater event id */>>>;

	std::string roomId;
	immer::map<KeyOfState, Event> stateEvents;
	immer::map<KeyOfState, Event> inviteState;
	// Smaller indices mean earlier events
	// (oldest) 0 --------> n (latest)
	immer::flex_vector<std::string> timeline;
	immer::map<std::string, Event> messages;
	immer::map<std::string, Event> accountData;
	Membership membership{};
	std::string paginateBackToken;
	/// whether this room has earlier events to be fetched
	bool canPaginateBack{true};

	immer::map<std::string /* eventId /, std::string / prevBatch */> timelineGaps;

	immer::map<std::string, Event> ephemeral;

	std::string localDraft;

	bool encrypted{false};
	/// a marker to indicate whether we need to rotate
	/// the session key earlier than it expires
	/// (e.g. when a user in the room's device list changed
	/// or when someone joins or leaves)
	bool shouldRotateSessionKey{true};

	bool membersFullyLoaded{false};
	immer::flex_vector<std::string> heroIds;

	immer::flex_vector<LocalEchoDesc> localEchoes;

	immer::flex_vector<PendingRoomKeyEvent> pendingRoomKeyEvents;

	ReverseEventRelationshipMap reverseEventRelationships;

	std::size_t joinedMemberCount{0};
	std::size_t invitedMemberCount{0};

	/// The local read marker for this room. Indicates that
	/// you have read up to this event.
	std::string localReadMarker;
	/// The local unread count for this room.
	std::size_t localUnreadCount{0};
	/// The local unread notification count for this room.
	/// XXX this is never used.
	std::size_t localNotificationCount{0};
	/// Read receipts for all users
	immer::map<std::string /* userId */, ReadReceipt> readReceipts;
	/// A map from event id to a list of users that has read
	/// receipt at that point
	immer::map<
	std::string /* eventId */,
	immer::flex_vector<std::string /* userId */>> eventReadUsers;

	/// A map from the session id to a list of event ids of events
	/// that cannot (yet) be decrypted.
	immer::map<
	std::string /* sessionId */,
	immer::flex_vector<std::string /* eventId */>> undecryptedEvents;

	immer::flex_vector<std::string> unreadNotificationEventIds;

	immer::flex_vector<std::string> joinedMemberIds() const;
	immer::flex_vector<std::string> invitedMemberIds() const;
	immer::flex_vector<std::string> knockedMemberIds() const;
	immer::flex_vector<std::string> leftMemberIds() const;
	immer::flex_vector<std::string> bannedMemberIds() const;

	EventList joinedMemberEvents() const;
	EventList invitedMemberEvents() const;
	EventList knockedMemberEvents() const;
	EventList leftMemberEvents() const;
	EventList bannedMemberEvents() const;
	EventList heroMemberEvents() const;

	MegOlmSessionRotateDesc sessionRotateDesc() const;

	bool hasUser(std::string userId) const;

	std::optional<LocalEchoDesc> getLocalEchoByTxnId(std::string txnId) const;
	std::optional<PendingRoomKeyEvent> getPendingRoomKeyEventByTxnId(std::string txnId) const;

	immer::map<std::string, double> tags() const;

	Event makeAddTagEvent(std::string tagId, std::optional<double> order) const;
	Event makeRemoveTagEvent(std::string tagId) const;

	/**
	* Fill in reverseEventRelationships by gathering
	* the relationships specified in `newEvents`
	*
	* @param newEvents The events that just came in after last time event relationships
	* are gathered.
	*/
	void generateRelationships(EventList newEvents);

	void regenerateRelationships();

	/**
	* Fill in undecryptedEvents by gathering
	* the session ids specified in `newEvents`.
	*
	* @param newEvents New incoming events.
	*/
	void addToUndecryptedEvents(EventList newEvents);

	void recalculateUndecryptedEvents();

	using Action = std::variant<
	AddStateEventsAction,
	MaybeAddStateEventsAction,
	+ AddMessagesAction,
	AddToTimelineAction,
	AddAccountDataAction,
	ChangeMembershipAction,
	ChangeInviteStateAction,
	AddEphemeralAction,
	SetLocalDraftAction,
	SetRoomEncryptionAction,
	MarkMembersFullyLoadedAction,
	SetHeroIdsAction,
	AddLocalEchoAction,
	RemoveLocalEchoAction,
	AddPendingRoomKeyAction,
	RemovePendingRoomKeyAction,
	UpdateJoinedMemberCountAction,
	UpdateInvitedMemberCountAction,
	AddLocalNotificationsAction,
	RemoveReadLocalNotificationsAction,
	UpdateLocalReadMarkerAction
	>;

	static RoomModel update(RoomModel r, Action a);

	friend bool operator==(const RoomModel &a, const RoomModel &b) = default;
	};

	using RoomAction = RoomModel::Action;

	struct UpdateRoomAction
	{
	std::string roomId;
	RoomAction roomAction;
	};

	struct RoomListModel
	{
	immer::map<std::string, RoomModel> rooms;

	inline auto at(std::string id) const { return rooms.at(id); }
	inline auto operator[](std::string id) const { return rooms[id]; }
	inline bool has(std::string id) const { return rooms.find(id); }

	using Action = std::variant<
	UpdateRoomAction
	>;
	static RoomListModel update(RoomListModel l, Action a);

	friend bool operator==(const RoomListModel &a, const RoomListModel &b) = default;
	};

	using RoomListAction = RoomListModel::Action;

	template<class Archive>
	void serialize(Archive &ar, RoomModel &r, std::uint32_t const version)
	{
	ar
	& r.roomId
	& r.stateEvents
	& r.inviteState

	& r.timeline
	& r.messages
	& r.accountData
	& r.membership
	& r.paginateBackToken
	& r.canPaginateBack

	& r.timelineGaps
	& r.ephemeral

	& r.localDraft

	& r.encrypted
	& r.shouldRotateSessionKey

	& r.membersFullyLoaded
	;

	if (version >= 1) {
	ar
	& r.heroIds
	;
	}
	if (version >= 2) {
	ar & r.localEchoes;
	}
	if (version >= 3) {
	ar & r.pendingRoomKeyEvents;
	}
	if (version >= 4) {
	ar & r.reverseEventRelationships;
	} else { // must be reading from an older version
	if constexpr (typename Archive::is_loading()) {
	r.regenerateRelationships();
	}
	}
	if (version >= 5) {
	ar & r.joinedMemberCount & r.invitedMemberCount;
	}
	if (version >= 6) {
	ar
	& r.localReadMarker
	& r.localUnreadCount
	& r.localNotificationCount
	& r.readReceipts
	& r.eventReadUsers;
	}
	if (version >= 7) {
	ar & r.undecryptedEvents;
	} else {
	if constexpr (typename Archive::is_loading()) {
	r.recalculateUndecryptedEvents();
	}
	}
	if (version >= 8) {
	ar & r.unreadNotificationEventIds;
	}
	}

	template<class Archive>
	void serialize(Archive &ar, RoomListModel &l, std::uint32_t const /version/)
	{
	ar & l.rooms;
	}
	}

	BOOST_CLASS_VERSION(Kazv::PendingRoomKeyEvent, 1)
	BOOST_CLASS_VERSION(Kazv::ReadReceipt, 0)
	BOOST_CLASS_VERSION(Kazv::RoomModel, 8)
	BOOST_CLASS_VERSION(Kazv::RoomListModel, 0)
	diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
	index 31ca7b8..a2afcdd 100644
	--- a/src/tests/CMakeLists.txt
	+++ b/src/tests/CMakeLists.txt
	@@ -1,125 +1,126 @@

	include(CTest)

	set(KAZVTEST_RESPATH ${CMAKE_CURRENT_SOURCE_DIR}/resources)
	configure_file(kazvtest-respath.hpp.in kazvtest-respath.hpp)

	function(libkazv_add_tests)
	set(options "")
	set(oneValueArgs "")
	set(multiValueArgs EXTRA_LINK_LIBRARIES EXTRA_INCLUDE_DIRECTORIES)
	cmake_parse_arguments(PARSE_ARGV 0 libkazv_add_tests "${options}" "${oneValueArgs}" "${multiValueArgs}")
	foreach(test_source ${libkazv_add_tests_UNPARSED_ARGUMENTS})
	string(REGEX REPLACE "\\.cpp$" "" test_executable "${test_source}")
	string(REGEX REPLACE "/\|\\\\" "--" test_executable "${test_executable}")
	message(STATUS "Test ${test_executable} added")
	add_executable("${test_executable}" "${test_source}")
	target_link_libraries("${test_executable}"
	PRIVATE Catch2::Catch2WithMain
	Threads::Threads
	${libkazv_add_tests_EXTRA_LINK_LIBRARIES}
	)

	target_include_directories(
	"${test_executable}"
	PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
	${CMAKE_CURRENT_SOURCE_DIR}
	${CMAKE_CURRENT_SOURCE_DIR}/..
	${libkazv_add_tests_EXTRA_INCLUDE_DIRECTORIES}
	)

	target_compile_definitions("${test_executable}" PRIVATE CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)

	add_test(NAME "${test_executable}" COMMAND "${test_executable}" "--allow-running-no-tests" "~[needs-internet]")
	endforeach()
	endfunction()

	libkazv_add_tests(
	event-test.cpp
	cursorutiltest.cpp
	base/serialization-test.cpp
	base/types-test.cpp
	base/immer-utils-test.cpp
	base/json-utils-test.cpp
	EXTRA_LINK_LIBRARIES kazvbase
	)

	add_library(client-test-lib SHARED client/client-test-util.cpp)
	target_link_libraries(client-test-lib PUBLIC kazvjob kazvclient)
	libkazv_add_tests(
	client/discovery-test.cpp
	client/sync-test.cpp
	client/content-test.cpp
	client/paginate-test.cpp
	+ client/storage-actions-test.cpp
	client/util-test.cpp
	client/serialization-test.cpp
	client/encrypted-file-test.cpp
	client/sdk-test.cpp
	client/thread-safety-test.cpp
	client/room-test.cpp
	client/random-generator-test.cpp
	client/profile-test.cpp
	client/kick-test.cpp
	client/ban-test.cpp
	client/join-test.cpp
	client/keys-test.cpp
	client/device-ops-test.cpp
	client/send-test.cpp
	client/encryption-test.cpp
	client/redact-test.cpp
	client/tagging-test.cpp
	client/account-data-test.cpp
	client/room/room-actions-test.cpp
	client/room/local-echo-test.cpp
	client/room/event-relationships-test.cpp
	client/room/member-membership-test.cpp
	client/push-rules-desc-test.cpp
	client/notification-handler-test.cpp
	client/validator-test.cpp
	client/power-levels-desc-test.cpp
	client/client-test.cpp
	client/create-room-test.cpp
	client/device-list-tracker-test.cpp
	client/device-list-tracker-benchmark-test.cpp
	client/room/read-receipt-test.cpp
	client/room/undecrypted-events-test.cpp
	client/encryption-benchmark-test.cpp
	client/logout-test.cpp
	client/room/pinned-events-test.cpp
	client/get-versions-test.cpp
	client/alias-test.cpp
	client/encode-test.cpp
	EXTRA_LINK_LIBRARIES kazvclient kazveventemitter kazvjob client-test-lib kazvtestfixtures
	EXTRA_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_SOURCE_DIR}/client
	)

	libkazv_add_tests(
	basejobtest.cpp
	kazvjobtest.cpp
	file-desc-test.cpp
	EXTRA_LINK_LIBRARIES kazvbase kazvjob
	)

	libkazv_add_tests(
	promise-test.cpp
	EXTRA_LINK_LIBRARIES kazvbase kazvjob kazvstore
	)

	libkazv_add_tests(
	event-emitter-test.cpp
	EXTRA_LINK_LIBRARIES kazvbase kazveventemitter
	)

	libkazv_add_tests(
	crypto-test.cpp
	crypto/inbound-group-session-test.cpp
	crypto/outbound-group-session-test.cpp
	crypto/session-test.cpp
	crypto/key-export-test.cpp
	EXTRA_LINK_LIBRARIES kazvcrypto
	)

	libkazv_add_tests(
	store-test.cpp
	EXTRA_LINK_LIBRARIES kazvstore kazvjob
	)
	diff --git a/src/tests/client/storage-actions-test.cpp b/src/tests/client/storage-actions-test.cpp
	new file mode 100644
	index 0000000..7bb0b21
	--- /dev/null
	+++ b/src/tests/client/storage-actions-test.cpp
	@@ -0,0 +1,78 @@
	+/*
	+ * This file is part of libkazv.
	+ * SPDX-FileCopyrightText: 2025 tusooa <tusooa@kazv.moe>
	+ * SPDX-License-Identifier: AGPL-3.0-or-later
	+ */
	+
	+#include <libkazv-config.hpp>
	+#include "actions/storage.hpp"
	+#include <catch2/catch_test_macros.hpp>
	+#include <catch2/matchers/catch_matchers_quantifiers.hpp>
	+#include <catch2/matchers/catch_matchers_predicate.hpp>
	+#include <factory.hpp>
	+
	+using namespace Kazv;
	+using namespace Kazv::Factory;
	+using Catch::Matchers::AllMatch;
	+using Catch::Matchers::Predicate;
	+
	+static const std::string roomId = "!test:example.com";
	+
	+template<class T>
	+static auto makeEventInRoom(T modifiers)
	+{
	+ return makeEvent(withEventKV("/room_id"_json_pointer, roomId) \| std::move(modifiers));
	+};
	+
	+static auto makeEventInRoom()
	+{
	+ return makeEvent(withEventKV("/room_id"_json_pointer, roomId));
	+};
	+
	+TEST_CASE("LoadEventsFromStorageAction", "[client][storage-actions]")
	+{
	+ auto existingEvents = EventList{
	+ makeEventInRoom(),
	+ makeEventInRoom(),
	+ };
	+ auto c = makeClient(withRoom(makeRoom(withRoomId(roomId) \| withRoomTimeline(existingEvents))));
	+
	+ auto timelineEvents = EventList{
	+ makeEventInRoom(),
	+ makeEventInRoom(),
	+ };
	+
	+ auto relatedEvents = EventList{
	+ makeEventInRoom(withEventRelationship("moe.kazv.mxc.some-rel", timelineEvents[0].id())),
	+ makeEventInRoom(withEventRelationship("moe.kazv.mxc.other-rel", existingEvents[0].id())),
	+ };
	+
	+ auto [next, _] = updateClient(c, LoadEventsFromStorageAction{
	+ {{roomId, timelineEvents}},
	+ {{roomId, relatedEvents}},
	+ });
	+
	+ {
	+ auto room = next.roomList.rooms[roomId];
	+
	+ REQUIRE(room.timeline == intoImmer(immer::flex_vector<std::string>{}, zug::map(&Event::id), existingEvents + timelineEvents));
	+ REQUIRE_THAT(existingEvents + timelineEvents + relatedEvents,
	+ AllMatch(Predicate<Event>([&room](const auto &e) { return !!room.messages.count(e.id()); }, "should be in messages")));
	+
	+ REQUIRE(room.reverseEventRelationships.count(timelineEvents[0].id()));
	+ REQUIRE(room.reverseEventRelationships.count(existingEvents[0].id()));
	+ }
	+ // Verify the load works when loading into timeline an event in
	+ // messages but not in timeline
	+ auto nextTimelineEvents = relatedEvents + EventList{makeEventInRoom()};
	+ std::tie(next, std::ignore) = updateClient(next, LoadEventsFromStorageAction{
	+ {{roomId, nextTimelineEvents}},
	+ {},
	+ });
	+
	+ {
	+ auto room = next.roomList.rooms[roomId];
	+
	+ REQUIRE(room.timeline == intoImmer(immer::flex_vector<std::string>{}, zug::map(&Event::id), existingEvents + timelineEvents + nextTimelineEvents));
	+ }
	+}
	diff --git a/src/tests/client/util-test.cpp b/src/tests/client/util-test.cpp
	index 58781dc..c8b7242 100644
	--- a/src/tests/client/util-test.cpp
	+++ b/src/tests/client/util-test.cpp
	@@ -1,48 +1,61 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2021 Tusooa Zhu <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>


	#include <catch2/catch_all.hpp>

	#include <clientutil.hpp>

	#include <immer/flex_vector.hpp>

	namespace
	{
	struct Model
	{
	int value;
	std::string data;
	};

	bool operator==(Model a, Model b)
	{
	return a.value == b.value && a.data == b.data;
	}

	bool operator!=(Model a, Model b)
	{
	return !(a == b);
	}
	}

	using namespace Kazv;

	TEST_CASE("sortedUniqueMerge should behave correctly", "[client][clientutil]")
	{
	immer::flex_vector<Model> base = {{50, "foo"}, {100, "bar"}};
	immer::flex_vector<Model> addon = {{1, "a"}, {2, "b"}, {70, "c"}, {110, "d"}};

	auto exists = [base](auto m) { return std::find(base.begin(), base.end(), m) != base.end(); };
	auto key = [](auto m) { return m.value; };

	auto res = sortedUniqueMerge(base, addon, exists, key);

	REQUIRE( res == immer::flex_vector<Model>{{1, "a"}, {2, "b"}, {50, "foo"}, {70, "c"}, {100, "bar"}, {110, "d"}} );
	}
	+
	+TEST_CASE("sortedUniqueMerge should auto detect existing items", "[client][clientutil]")
	+{
	+ immer::flex_vector<Model> base = {{50, "foo"}, {100, "bar"}};
	+ immer::flex_vector<Model> addon = {{1, "a"}, {2, "b"}, {50, "xxx"}, {70, "c"}, {110, "d"}};
	+
	+ auto exists = [](auto) { return false; };
	+ auto key = [](auto m) { return m.value; };
	+
	+ auto res = sortedUniqueMerge(base, addon, exists, key);
	+
	+ REQUIRE( res == immer::flex_vector<Model>{{1, "a"}, {2, "b"}, {50, "foo"}, {70, "c"}, {100, "bar"}, {110, "d"}} );
	+}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Jul 18, 3:09 PM (22 h, 37 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1694484
Default Alt Text: (102 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions