No OneTemporary
Actions

Size

88 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/client/actions/auth.cpp b/src/client/actions/auth.cpp
	index 7020800..d0f96f8 100644
	--- a/src/client/actions/auth.cpp
	+++ b/src/client/actions/auth.cpp
	@@ -1,158 +1,175 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2020-2022 Tusooa Zhu <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>

	#include <debug.hpp>
	#include <jobinterface.hpp>
	#include <eventinterface.hpp>

	#include "auth.hpp"
	#include "status-utils.hpp"

	namespace Kazv
	{
	ClientResult updateClient(ClientModel m, LoginAction a)
	{
	m.addJob(LoginJob{a.serverUrl,
	"m.login.password"s, // type
	UserIdentifier{ "m.id.user"s, json{{"user", a.username}} }, // identifier
	a.password,
	{}, // token, not used
	{}, // device id, not used
	a.deviceName.value_or("libkazv")}
	.withData(json{
	{"serverUrl", a.serverUrl},
	}));
	return { m, lager::noop };
	}

	ClientResult processResponse(ClientModel m, LoginResponse r)
	{
	if (! r.success()) {
	m.addTrigger(LoginFailed{r.errorCode(), r.errorMessage()});
	return { std::move(m), failWithResponse(r) };
	}

	kzo.client.dbg() << "Job success" << std::endl;
	auto jw = r.jsonBody();
	auto const &j = jw.get();
	// TODO: replace this with r.wellKnown()
	std::string serverUrl = j.contains("well_known")
	? j.at("well_known").at("m.homeserver").at("base_url").get<std::string>()
	: r.dataStr("serverUrl");

	// Synapse will return the server url with trailing slash
	// and not recognize double slashes in the middle
	while (serverUrl.back() == '/') {
	serverUrl.pop_back();
	}

	m.serverUrl = serverUrl;
	m.userId = r.userId().value_or(DEFVAL);
	m.token = r.accessToken().value_or(DEFVAL);
	m.deviceId = r.deviceId().value_or(DEFVAL);
	m.loggedIn = true;

	m.addTrigger(LoginSuccessful{});

	return { std::move(m), lager::noop };
	}

	ClientResult updateClient(ClientModel m, TokenLoginAction a)
	{
	m.serverUrl = a.serverUrl;
	m.userId = a.username;
	m.token = a.token;
	m.deviceId = a.deviceId;
	m.loggedIn = true;

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


	ClientResult updateClient(ClientModel m, LogoutAction)
	{
	// Note: this only performs a soft-logout.
	m.serverUrl = "";
	m.userId = "";
	m.token = "";
	m.deviceId = "";
	m.loggedIn = false;

	return { std::move(m), lager::noop };
	}

	+ ClientResult updateClient(ClientModel m, HardLogoutAction)
	+ {
	+ m.addJob(LogoutJob{m.serverUrl, m.token});
	+ return { std::move(m), lager::noop };
	+ }
	+
	+ ClientResult processResponse(ClientModel m, LogoutResponse r)
	+ {
	+ if (r.success()) {
	+ m.token = "";
	+ m.loggedIn = false;
	+ return { std::move(m), lager::noop };
	+ } else {
	+ return { std::move(m), failWithResponse(std::move(r)) };
	+ }
	+ }
	+
	ClientResult updateClient(ClientModel m, GetWellknownAction a)
	{
	auto pos = a.userId.find(':');
	if (pos == std::string::npos \|\| pos == a.userId.size() - 1) {
	return { std::move(m), simpleFail };
	}

	auto serverUrl = "https://" + a.userId.substr(pos + 1);

	m.addJob(GetWellknownJob{serverUrl}
	.withData(json{{"serverUrl", serverUrl}}));
	return { m, lager::noop };
	}

	ClientResult processResponse(ClientModel m, GetWellknownResponse r)
	{
	auto success = r.success() \|\| r.statusCode == 404;
	auto error = std::string();

	std::string serverUrl = r.dataStr("serverUrl");

	if (r.success()) {
	auto data = r.data();
	if (data.homeserver.baseUrl.empty()) {
	success = false;
	error = "FAIL_PROMPT";
	} else {
	serverUrl = data.homeserver.baseUrl;
	}
	} else {
	error = "FAIL_PROMPT";
	}

	return {
	std::move(m),
	[success, serverUrl, error, r](auto &&) {
	auto data = json{
	{"homeserverUrl", serverUrl},
	{"error", error},
	{"errorCode", r.errorCode()},
	};
	return EffectStatus(success, data);
	}
	};
	}

	ClientResult updateClient(ClientModel m, GetVersionsAction a)
	{
	m.addJob(GetVersionsJob{a.serverUrl});
	return { std::move(m), lager::noop };
	}

	ClientResult processResponse(ClientModel m, GetVersionsResponse r)
	{
	return {
	std::move(m),
	[r](auto &&ctx) {
	if (r.success()) {
	return EffectStatus(r.success(), json{
	{"versions", r.versions()},
	});
	} else {
	return failWithResponse(r)(std::forward<decltype(ctx)>(ctx));
	}
	}
	};
	}

	}
	diff --git a/src/client/actions/auth.hpp b/src/client/actions/auth.hpp
	index 05a8834..267989b 100644
	--- a/src/client/actions/auth.hpp
	+++ b/src/client/actions/auth.hpp
	@@ -1,28 +1,32 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2020-2022 Tusooa Zhu <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

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

	#include <csapi/login.hpp>
	#include <csapi/wellknown.hpp>
	#include <csapi/versions.hpp>
	+#include <csapi/logout.hpp>

	#include "client-model.hpp"

	namespace Kazv
	{
	ClientResult updateClient(ClientModel m, LoginAction a);
	ClientResult updateClient(ClientModel m, TokenLoginAction a);
	ClientResult processResponse(ClientModel m, LoginResponse r);
	ClientResult updateClient(ClientModel m, LogoutAction a);

	+ ClientResult updateClient(ClientModel m, HardLogoutAction a);
	+ ClientResult processResponse(ClientModel m, LogoutResponse r);
	+
	ClientResult updateClient(ClientModel m, GetWellknownAction a);
	ClientResult processResponse(ClientModel m, GetWellknownResponse r);

	ClientResult updateClient(ClientModel m, GetVersionsAction a);
	ClientResult processResponse(ClientModel m, GetVersionsResponse r);
	}
	diff --git a/src/client/client-model.cpp b/src/client/client-model.cpp
	index f05d2d7..ad9a875 100644
	--- a/src/client/client-model.cpp
	+++ b/src/client/client-model.cpp
	@@ -1,421 +1,422 @@
	/*
	* 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"

	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();

	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 0fb57b4..74e8e6a 100644
	--- a/src/client/client-model.hpp
	+++ b/src/client/client-model.hpp
	@@ -1,633 +1,634 @@
	/*
	* 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::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;
	};

	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/client.cpp b/src/client/client.cpp
	index 25617cc..0a90c7b 100644
	--- a/src/client/client.cpp
	+++ b/src/client/client.cpp
	@@ -1,438 +1,450 @@
	/*
	* 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 <filesystem>

	#include <lager/constant.hpp>

	#include "client.hpp"

	namespace Kazv
	{
	Client::Client(lager::reader<SdkModel> sdk,
	ContextT ctx, std::nullopt_t)
	: m_sdk(sdk)
	, m_client(sdk.map(&SdkModel::c))
	, m_ctx(std::move(ctx))
	{
	}

	Client::Client(lager::reader<SdkModel> sdk,
	ContextWithDepsT ctx)
	: m_sdk(sdk)
	, m_client(sdk.map(&SdkModel::c))
	, m_ctx(ctx)
	, m_deps(std::move(ctx))
	{
	}

	Client::Client(InEventLoopTag,
	ContextWithDepsT ctx)
	: m_sdk(std::nullopt)
	, m_client(std::nullopt)
	, m_ctx(ctx)
	, m_deps(std::move(ctx))
	#ifdef KAZV_USE_THREAD_SAFETY_HELPER
	, KAZV_ON_EVENT_LOOP_VAR(true)
	#endif
	{
	}

	Client::Client(InEventLoopTag,
	ContextT ctx, DepsT deps)
	: m_sdk(std::nullopt)
	, m_client(std::nullopt)
	, m_ctx(std::move(ctx))
	, m_deps(std::move(deps))
	#ifdef KAZV_USE_THREAD_SAFETY_HELPER
	, KAZV_ON_EVENT_LOOP_VAR(true)
	#endif
	{
	}


	Client Client::toEventLoop() const
	{
	return Client(InEventLoopTag{}, m_ctx, m_deps.value());
	}


	Room Client::room(std::string id) const
	{
	if (m_deps.has_value()) {
	return Room(sdkCursor(), lager::make_constant(id), m_ctx, m_deps.value());
	} else {
	return Room(sdkCursor(), lager::make_constant(id), m_ctx);
	}
	}

	Room Client::roomByCursor(lager::reader<std::string> id) const
	{
	if (m_deps.has_value()) {
	return Room(sdkCursor(), id, m_ctx, m_deps.value());
	} else {
	return Room(sdkCursor(), id, m_ctx);
	}
	}

	auto Client::passwordLogin(std::string homeserver, std::string username,
	std::string password, std::string deviceName) const
	-> PromiseT
	{
	auto p1 = m_ctx.dispatch(LoginAction{
	homeserver, username, password, deviceName});
	p1
	.then([that=toEventLoop()](auto stat) {
	if (! stat.success()) {
	return;
	}
	// It is meaningless to wait for it in a Promise
	// that is never exposed to the user.
	that.startSyncing();
	});

	return p1;
	}

	auto Client::tokenLogin(std::string homeserver, std::string username,
	std::string token, std::string deviceId) const
	-> PromiseT
	{
	auto p1 = m_ctx.dispatch(TokenLoginAction{
	homeserver, username, token, deviceId});
	p1
	.then([that=toEventLoop()](auto stat) {
	if (! stat.success()) {
	return;
	}
	that.startSyncing();
	});

	return p1;
	}

	+ auto Client::shouldSync() const -> lager::reader<bool> {
	+ return this->clientCursor()[&ClientModel::shouldSync];
	+ }
	+
	+ auto Client::logout() const
	+ -> PromiseT
	+ {
	+ return stopSyncing().then([ctx=m_ctx] (auto stat) {
	+ return ctx.dispatch(HardLogoutAction{});
	+ });
	+ }
	+
	auto Client::autoDiscover(std::string userId) const
	-> PromiseT
	{
	return m_ctx.dispatch(GetWellknownAction{userId})
	.then([that=toEventLoop()](auto stat) {
	if (!stat.success()) {
	return that.m_ctx.createResolvedPromise(stat);
	}
	return that.m_ctx.dispatch(GetVersionsAction{stat.dataStr("homeserverUrl")})
	.then([that, stat](auto stat2) {
	if (!stat2.success()) {
	return stat2;
	} else {
	return stat;
	}
	});
	});
	}

	auto Client::createRoom(
	RoomVisibility v,
	std::optional<std::string> name,
	std::optional<std::string> alias,
	immer::array<std::string> invite,
	std::optional<bool> isDirect,
	bool allowFederate,
	std::optional<std::string> topic,
	JsonWrap powerLevelContentOverride,
	std::optional<CreateRoomPreset> preset
	) const
	-> PromiseT
	{
	CreateRoomAction a;
	a.visibility = v;
	a.name = name;
	a.roomAliasName = alias;
	a.invite = invite;
	a.isDirect = isDirect;
	a.topic = topic;
	a.powerLevelContentOverride = powerLevelContentOverride;
	// Synapse won't buy it if we do not provide
	// a creationContent object.
	a.creationContent = json{
	{"m.federate", allowFederate}
	};
	a.preset = preset;
	return m_ctx.dispatch(std::move(a));
	}

	auto Client::joinRoomById(std::string roomId) const -> PromiseT
	{
	return m_ctx.dispatch(JoinRoomByIdAction{roomId});
	}

	auto Client::joinRoom(std::string roomId, immer::array<std::string> serverName) const
	-> PromiseT
	{
	return m_ctx.dispatch(JoinRoomAction{roomId, serverName});
	}

	auto Client::uploadContent(immer::box<Bytes> content,
	std::string uploadId,
	std::optional<std::string> filename,
	std::optional<std::string> contentType) const
	-> PromiseT
	{
	return m_ctx.dispatch(UploadContentAction{
	FileDesc(FileContent{content.get().begin(), content.get().end()}),
	filename, contentType, uploadId});
	}

	auto Client::uploadContent(FileDesc file) const
	-> PromiseT
	{
	auto basename = file.name()
	? std::optional(std::filesystem::path(file.name().value()).filename().string())
	: std::nullopt;
	return m_ctx.dispatch(UploadContentAction{
	file,
	// use only basename to prevent path info being leaked
	basename,
	file.contentType(),
	// uploadId unused
	std::string{}});
	}

	auto Client::downloadContent(std::string mxcUri, std::optional<FileDesc> downloadTo) const
	-> PromiseT
	{
	return m_ctx.dispatch(DownloadContentAction{mxcUri, downloadTo});
	}

	auto Client::downloadThumbnail(
	std::string mxcUri,
	int width,
	int height,
	std::optional<ThumbnailResizingMethod> method,
	std::optional<FileDesc> downloadTo) const
	-> PromiseT
	{
	return m_ctx.dispatch(DownloadThumbnailAction{mxcUri, width, height, method, std::nullopt, downloadTo});
	}

	auto Client::startSyncing() const -> PromiseT
	{
	KAZV_VERIFY_THREAD_ID();
	using namespace Kazv::CursorOp;

	if (+syncing()) {
	return m_ctx.createResolvedPromise(true);
	}

	auto p1 = m_ctx.createResolvedPromise(true)
	.then([that=toEventLoop()](auto) {
	// post filters, if filters are incomplete
	if ((+that.clientCursor()[&ClientModel::initialSyncFilterId]).empty()
	\|\| (+that.clientCursor()[&ClientModel::incrementalSyncFilterId]).empty()) {
	return that.m_ctx.dispatch(PostInitialFiltersAction{});
	}
	return that.m_ctx.createResolvedPromise(true);
	})
	.then([that=toEventLoop()](auto stat) {
	if (! stat.success()) {
	return that.m_ctx.createResolvedPromise(stat);
	}
	// Upload identity keys if we need to
	if (+that.clientCursor()[&ClientModel::crypto]
	&& ! +that.clientCursor()[&ClientModel::identityKeysUploaded]) {
	return that.m_ctx.dispatch(UploadIdentityKeysAction{});
	} else {
	return that.m_ctx.createResolvedPromise(true);
	}
	});

	p1
	.then([m_ctx=m_ctx](auto stat) {
	m_ctx.dispatch(SetShouldSyncAction{true});
	return stat;
	})
	.then([that=toEventLoop()](auto stat) {
	if (stat.success()) {
	that.syncForever();
	}
	});

	return p1;
	}

	auto Client::syncForever(std::optional<int> retryTime) const -> void
	{
	KAZV_VERIFY_THREAD_ID();

	// assert (m_deps);
	using namespace CursorOp;

	bool isInitialSync = ! (+clientCursor()[&ClientModel::syncToken]).has_value();

	bool shouldSync = +clientCursor()[&ClientModel::shouldSync];

	if (! shouldSync) {
	return;
	}
	//

	auto syncRes = m_ctx.dispatch(SyncAction{});

	auto uploadOneTimeKeysRes = syncRes
	.then([that=toEventLoop()](auto stat) {
	if (! stat.success()) {
	return that.m_ctx.createResolvedPromise(stat);
	}
	auto &rg = lager::get<RandomInterface &>(that.m_deps.value());
	bool hasCrypto{+that.clientCursor()[&ClientModel::crypto]};
	if (! hasCrypto) {
	return that.m_ctx.createResolvedPromise(true);
	}
	auto numKeysToGenerate = (+that.clientCursor()).numOneTimeKeysNeeded();
	return that.m_ctx.dispatch(GenerateAndUploadOneTimeKeysAction{
	numKeysToGenerate,
	rg.generateRange<RandomData>(GenerateAndUploadOneTimeKeysAction::randomSize(numKeysToGenerate))
	});
	});

	auto queryKeysRes = syncRes
	.then([that=toEventLoop(), isInitialSync](auto stat) {
	if (! stat.success()) {
	return that.m_ctx.createResolvedPromise(stat);
	}
	bool hasCrypto{+that.clientCursor()[&ClientModel::crypto]};
	return hasCrypto
	? that.m_ctx.dispatch(QueryKeysAction{isInitialSync})
	: that.m_ctx.createResolvedPromise(true);
	});

	m_ctx.promiseInterface()
	.all(std::vector<PromiseT>{uploadOneTimeKeysRes, queryKeysRes})
	.then([that=toEventLoop(), retryTime](auto stat) {
	if (stat.success()) {
	that.syncForever(); // reset retry time
	} else {
	auto firstRetryTime = +that.clientCursor()[&ClientModel::firstRetryMs];
	auto retryTimeFactor = +that.clientCursor()[&ClientModel::retryTimeFactor];
	auto maxRetryTime = +that.clientCursor()[&ClientModel::maxRetryMs];
	auto curRetryTime = retryTime ? retryTime.value() : firstRetryTime;
	if (curRetryTime > maxRetryTime) { curRetryTime = maxRetryTime; }
	auto nextRetryTime = curRetryTime * retryTimeFactor;

	kzo.client.warn() << "Sync failed, retrying in " << curRetryTime << "ms" << std::endl;
	auto &jh = getJobHandler(that.m_deps.value());
	jh.setTimeout([that=that.toEventLoop(), nextRetryTime]() { that.syncForever(nextRetryTime); },
	curRetryTime);
	}
	});
	}

	auto Client::stopSyncing() const -> PromiseT
	{
	return m_ctx.dispatch(SetShouldSyncAction{false});
	}

	lager::reader<ClientModel> Client::clientCursor() const
	{
	KAZV_VERIFY_THREAD_ID();

	if (m_client.has_value()) {
	return m_client.value();
	} else {
	assert(m_deps.has_value());
	return lager::get<SdkModelCursorKey>(m_deps.value())->map(&SdkModel::c);
	}
	}

	const lager::reader<SdkModel> &Client::sdkCursor() const
	{
	KAZV_VERIFY_THREAD_ID();

	if (m_sdk.has_value()) {
	return m_sdk.value();
	} else {
	assert(m_deps.has_value());
	return *(lager::get<SdkModelCursorKey>(m_deps.value()));
	}
	}

	auto Client::getProfile(std::string userId) const -> PromiseT
	{
	return m_ctx.dispatch(GetUserProfileAction{userId});
	}

	auto Client::setAvatarUrl(std::optional<std::string> avatarUrl) const -> PromiseT
	{
	return m_ctx.dispatch(SetAvatarUrlAction{avatarUrl});
	}

	auto Client::setDisplayName(std::optional<std::string> displayName) const -> PromiseT
	{
	return m_ctx.dispatch(SetDisplayNameAction{displayName});
	}

	auto Client::devicesOfUser(std::string userId) const -> lager::reader<immer::flex_vector<DeviceKeyInfo>>
	{
	return clientCursor()
	[&ClientModel::deviceLists]
	[&DeviceListTracker::deviceLists]
	[userId]
	[lager::lenses::or_default]
	.xform(containerMap(immer::flex_vector<DeviceKeyInfo>{}, zug::map([](const auto &pair) {
	const auto &[deviceId, info] = pair;
	(void)deviceId;
	return info;
	})));
	}

	auto Client::setDeviceTrustLevel(std::string userId, std::string deviceId, DeviceTrustLevel trustLevel) const -> PromiseT
	{
	return m_ctx.dispatch(SetDeviceTrustLevelAction{userId, deviceId, trustLevel});
	}

	auto Client::trustLevelNeededToSendKeys() const -> lager::reader<DeviceTrustLevel>
	{
	return clientCursor()[&ClientModel::trustLevelNeededToSendKeys];
	}

	auto Client::setTrustLevelNeededToSendKeys(DeviceTrustLevel trustLevel) const -> PromiseT
	{
	return m_ctx.dispatch(SetTrustLevelNeededToSendKeysAction{trustLevel});
	}

	auto Client::directRoomMap() const -> lager::reader<immer::map<std::string, std::string>>
	{
	return clientCursor().map(&ClientModel::directRoomMap);
	}

	auto Client::roomIdsUnderTag(std::string tagId) const -> lager::reader<immer::map<std::string, double>>
	{
	return clientCursor().map([tagId](const auto &c) {
	return c.roomIdsUnderTag(tagId);
	});
	}

	auto Client::roomIdsByTagId() const -> lager::reader<immer::map<std::string, immer::map<std::string, double>>>
	{
	return clientCursor().map(&ClientModel::roomIdsByTagId);
	}

	auto Client::accountData() const -> lager::reader<immer::map<std::string, Event>>
	{
	return clientCursor()[&ClientModel::accountData];
	}

	auto Client::setAccountData(Event accountDataEvent) const -> PromiseT
	{
	return m_ctx.dispatch(SetAccountDataAction{accountDataEvent});
	}

	NotificationHandler Client::notificationHandler() const
	{
	return NotificationHandler(clientCursor());
	}
	}
	diff --git a/src/client/client.hpp b/src/client/client.hpp
	index 17d6faa..cc79ac5 100644
	--- a/src/client/client.hpp
	+++ b/src/client/client.hpp
	@@ -1,553 +1,569 @@
	/*
	* 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 <lager/reader.hpp>
	#include <immer/box.hpp>
	#include <immer/map.hpp>
	#include <immer/flex_vector.hpp>
	#include <immer/flex_vector_transient.hpp>

	#include "sdk-model.hpp"
	#include "client/client-model.hpp"
	#include "client/actions/content.hpp"
	#include "sdk-model-cursor-tag.hpp"

	#include "room/room.hpp"
	#include "notification-handler.hpp"

	namespace Kazv
	{
	/**
	* Represent a Matrix client.
	*
	* If the Client is constructed from a cursor originated from
	* a root whose event loop is on thread A, then we say that
	* the Client belongs to thread A. If the Client is not constructed
	* from a cursor, then we say that the Client belongs to the thread
	* where the event loop of the context runs.
	*
	* All methods in this class that take a cursor only take a cursor
	* on the same thread as the Client. All methods in this class that
	* return a cursor will return a cursor on the same thread as the Client.
	*
	* All methods in this class must be run on the same thread as the
	* the Client. If the Client is not constructed from a cursor,
	* copy-constructing another Client from this is safe from any thread.
	* If the Client is constructed from a cursor, copy-constructing another
	* Client is safe only from the same thread as this Client.
	*
	* ## Error handling
	*
	* A lot of functions in Client and Room are asynchronous actions.
	* These actions return the result via a Promise.
	* If an API request has failed, the Promise p will satisfy the following:
	* - `!p.success()`
	* - `p.dataStr("error")` will contain the error message from the response.
	* - `p.dataStr("errorCode")` will contain the matrix error code, if available,
	* or the HTTP status code otherwise.
	*
	* What information is resolved if the API request has succeeded is defined
	* by individual functions.
	*/
	class Client
	{
	public:
	using ActionT = ClientAction;

	using DepsT = lager::deps<JobInterface &, EventInterface &, SdkModelCursorKey, RandomInterface &
	#ifdef KAZV_USE_THREAD_SAFETY_HELPER
	, EventLoopThreadIdKeeper &
	#endif

	>;
	using ContextT = Context<ActionT>;
	using ContextWithDepsT = Context<ActionT, DepsT>;

	using PromiseT = SingleTypePromise<DefaultRetType>;

	struct InEventLoopTag {};
	/**
	* Constructor.
	*
	* Construct the client. Without Deps support.
	*
	* @warning You should not use this directly. Use
	* Sdk::client() instead.
	*/
	Client(lager::reader<SdkModel> sdk,
	ContextT ctx, std::nullopt_t);

	/**
	* Constructor.
	*
	* Construct the client, with Deps support.
	*
	* This enables startSyncing() to work properly.
	*
	* @warning You should not use this directly. Use
	* Sdk::client() instead.
	*/
	Client(lager::reader<SdkModel> sdk,
	ContextWithDepsT ctx);

	/**
	* Constructor.
	*
	* Construct the client, with Deps support.
	*
	* The constructed Client belongs to the thread of event loop.
	*
	* @warning You should not use this directly. Use
	* Sdk::client() instead.
	*/
	Client(InEventLoopTag,
	ContextWithDepsT ctx);

	/**
	* Constructor.
	*
	* Construct the client, with Deps support.
	*
	* The constructed Client belongs to the thread of event loop.
	*
	* @warning You should not use this directly. Use
	* Sdk::client() instead.
	*/
	Client(InEventLoopTag, ContextT ctx, DepsT deps);


	/**
	* Create a Client that is not constructed from a cursor.
	*
	* The returned Client belongs to the thread of event loop.
	*
	* This function is thread-safe if every thread calls it
	* using different objects.
	*
	* @return A Client not constructed from a cursor.
	*/
	Client toEventLoop() const;

	/* lager::reader<immer::map<std::string, Room>> */
	inline auto rooms() const {
	return clientCursor()
	[&ClientModel::roomList]
	[&RoomListModel::rooms];
	}

	/* lager::reader<RangeT<std::string>> */
	inline auto roomIds() const {
	return rooms().xform(
	zug::map([](auto m) {
	return intoImmer(
	immer::flex_vector<std::string>{},
	zug::map([](auto val) { return val.first; }),
	m);
	}));
	}

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

	/**
	* Get the room ids under all tags.
	*
	* @return A lager::reader containing the map from tag id to a map from room id to order.
	* Rooms without a tag will be under the tag id of the empty string.
	*/
	auto roomIdsByTagId() const -> lager::reader<immer::map<std::string, immer::map<std::string, double>>>;

	KAZV_WRAP_ATTR(ClientModel, clientCursor(), serverUrl)
	KAZV_WRAP_ATTR(ClientModel, clientCursor(), loggedIn)
	KAZV_WRAP_ATTR(ClientModel, clientCursor(), userId)
	KAZV_WRAP_ATTR(ClientModel, clientCursor(), token)
	KAZV_WRAP_ATTR(ClientModel, clientCursor(), deviceId)
	KAZV_WRAP_ATTR(ClientModel, clientCursor(), toDevice)

	/**
	* Get the room with @c id .
	*
	* This is equivalent to `roomByCursor(lager::make_constant(id))`.
	*
	* @param id The room id.
	* @return A Room representing the room with `id`.
	*/
	Room room(std::string id) const;

	/**
	* Get the room with `id`.
	*
	* The Room returned will change as the content in `id` changes.
	*
	* For example, you can have the Room that is always the first
	* alphabetically in all rooms by:
	*
	* \code{.cpp}
	* auto someProcessing =
	* zug::map([=](auto ids) {
	* std::sort(ids.begin(), ids.end(), [=](auto id1, auto id2) {
	* using namespace Kazv::CursorOp;
	* return (+client.room(id1).name()) < (+client.room(id2).name());
	* });
	* return ids;
	* });
	* auto room =
	* client.roomByCursor(
	* client.roomIds().xform(someProcessing)[0]);
	* \endcode
	*
	* @param id A lager::reader<std::string> containing the room id.
	* @return A Room representing the room with `id`.
	*/
	Room roomByCursor(lager::reader<std::string> id) const;

	/**
	* Login using the password.
	*
	* This will create a new session on the homeserver.
	*
	* If the returned Promise resolves successfully, this will
	* call `startSyncing()`.
	*
	* @param homeserver The base url of the homeserver. E.g. `https://tusooa.xyz`.
	* @param username The username. This can be the full user id or
	* just the local part. E.g. `tusooa`, `@tusooa:tusooa.xyz`.
	* @param password The password.
	* @param deviceName Optionally, a custom device name. If empty, `libkazv`
	* will be used.
	* @return A Promise that resolves when logging in successfully, or
	* when there is an error.
	*/
	PromiseT passwordLogin(std::string homeserver, std::string username,
	std::string password, std::string deviceName) const;

	/**
	* Login using `token` and `deviceId`.
	*
	* This will not make a request. Library users should make sure
	* the information is correct and the token and the device id are valid.
	*
	* If the returned Promise resolves successfully, this will
	* call `startSyncing()`.
	*
	* @param homeserver The base url of the homeserver. E.g. `https://tusooa.xyz`.
	* @param username The full user id. E.g. `@tusooa:tusooa.xyz`.
	* @param token The access token.
	* @param deviceId The device id that is paired with `token`.
	* @return A Promise that resolves when the account information is filled in.
	*/
	PromiseT tokenLogin(std::string homeserver, std::string username,
	std::string token, std::string deviceId) const;

	+ /**
	+ * Get the `shouldSync` field of current ClientModel.
	+ *
	+ * @return A lager::reader of bool of the `shouldSync` field of the ClientModel
	+ */
	+ auto shouldSync() const -> lager::reader<bool>;
	+
	+ /**
	+ * Stop syncing and then logout current session.
	+ *
	+ * Meanwhile, clear the current token and set loggedIn to false.
	+ *
	+ * @return A promise that resolves when the syncing is stopped.
	+ */
	+ PromiseT logout() const;
	+
	/**
	* Automatically discover the homeserver for `userId`.
	*
	* If the operation succeeds, `r.dataStr("homeserverUrl")` will contain
	* the url suitable to pass to `tokenLogin()` and `passwordLogin()`.
	*
	* If there is no well-known file (i.e. server responds with 404),
	* `r.dataStr("homeserverUrl")` will contain the domain part of the user
	* id (`https://example.org` for `@foo:example.org`).
	*
	* @param userId The full user id. E.g. `@foo:example.org`.
	* @return A Promise that resolves when the auto-discovery finishes.
	*/
	PromiseT autoDiscover(std::string userId) const;

	/**
	* Create a room.
	*
	* @param v The visibility of the room.
	* @param name The name of the room.
	* @param alias The alias of the room.
	* @param invite User ids to invite to this room.
	* @param isDirect Whether this room is a direct chat.
	* @param allowFederate Whether to allow users from other homeservers
	* to join this room.
	* @param topic The topic of the room.
	* @param powerLevelContentOverride The content of the m.room.power_levels
	* state event to override the default.
	* @param preset The preset to create the room with.
	* @return A Promise that resolves when the room is created,
	* or when there is an error.
	*/
	PromiseT createRoom(
	RoomVisibility v,
	std::optional<std::string> name = {},
	std::optional<std::string> alias = {},
	immer::array<std::string> invite = {},
	std::optional<bool> isDirect = {},
	bool allowFederate = true,
	std::optional<std::string> topic = {},
	JsonWrap powerLevelContentOverride = json::object(),
	std::optional<CreateRoomPreset> preset = std::nullopt
	) const;

	/**
	* Join a room by its id.
	*
	* @param roomId The id of the room to join.
	* @return A Promise that resolves when the room is joined,
	* or when there is an error.
	*/
	PromiseT joinRoomById(std::string roomId) const;

	/**
	* Join a room by its id or alias.
	*
	* @param roomId The id or alias of the room to join.
	* @param serverName A list of servers to use when joining the room.
	* This corresponds to the `via` parameter in a matrix.to url.
	* @return A Promise that resolves when the room is joined,
	* or when there is an error.
	*/
	PromiseT joinRoom(std::string roomId, immer::array<std::string> serverName) const;

	/**
	* Upload content to the content repository.
	*
	* @param content The content to upload.
	* @param uploadId
	* @param filename The name of the file.
	* @param contentType The content type of the file.
	* @return A Promise that resolves when the upload is successful,
	* or when there is an error. If it successfully resolves to `r`,
	* `r.dataStr("mxcUri")` will be the MXC URI of the uploaded
	* content.
	*/
	PromiseT uploadContent(immer::box<Bytes> content,
	std::string uploadId,
	std::optional<std::string> filename = std::nullopt,
	std::optional<std::string> contentType = std::nullopt) const;

	/**
	* Upload content to the content repository.
	*
	* @param file The file to upload.
	* @return A Promise that resolves when the upload is successful,
	* or when there is an error. If it successfully resolves to `r`,
	* `r.dataStr("mxcUri")` will be the MXC URI of the uploaded
	* content.
	*/
	PromiseT uploadContent(FileDesc file) const;


	/**
	* Convert a MXC URI to an HTTP(s) URI.
	*
	* The converted URI will be using the homeserver of
	* this Client.
	*
	* @param mxcUri The MXC URI to convert.
	* @return The HTTP(s) URI that has the content indicated
	* by `mxcUri`.
	*/
	inline std::string mxcUriToHttp(std::string mxcUri) const {
	using namespace CursorOp;
	auto [serverName, mediaId] = mxcUriToMediaDesc(mxcUri);
	return (+clientCursor())
	.template job<GetContentJob>()
	.make(serverName, mediaId).url();
	}

	/**
	* Download content from the content repository
	*
	* After the returned Promise resolves successfully,
	* if @c downloadTo is provided, the content will be available
	* in that file; if it is not provided, `r.dataStr("content")`
	* will contain the content of the downloaded file.
	*
	* @param mxcUri The MXC URI of the content.
	* @param downloadTo The file to write the content to. Must not be
	* an in-memory file.
	* @return A Promise that is resolved after the content
	* is downloaded, or when there is an error.
	*/
	PromiseT downloadContent(std::string mxcUri,
	std::optional<FileDesc> downloadTo = std::nullopt) const;

	/**
	* Download a thumbnail from the content repository
	*
	* After the returned Promise resolves successfully,
	* if @c downloadTo is provided, the content will be available
	* in that file; if it is not provided, `r.dataStr("content")`
	* will contain the content of the downloaded file.
	*
	* @param mxcUri The MXC URI of the content.
	* @param width,height The dimension wanted for the thumbnail
	* @param method The method to generate the thumbnail. Either `Crop`
	* or `Scale`.
	* @param downloadTo The file to write the content to. Must not be
	* an in-memory file.
	* @return A Promise that is resolved after the thumbnail
	* is downloaded, or when there is an error.
	*/
	PromiseT downloadThumbnail(std::string mxcUri,
	int width,
	int height,
	std::optional<ThumbnailResizingMethod> method = std::nullopt,
	std::optional<FileDesc> downloadTo = std::nullopt) const;

	/**
	* Fetch the profile of a user.
	*
	* @param userId The id of the user to fetch.
	* @return A Promise that resolves when the fetch is completed.
	* If successful, `r.dataStr("avatarUrl")` will contain the
	* avatar url of that user, and `r.dataStr("displayName")` will
	* contain the display name of that user.
	*/
	PromiseT getProfile(std::string userId) const;

	/**
	* Change the avatar url of the current user.
	*
	* @param avatarUrl The url of the new avatar. Should be an MXC URI.
	* If it is std::nullopt, remove the user avatar.
	* @return A Promise that resolves when the request is completed.
	*/
	PromiseT setAvatarUrl(std::optional<std::string> avatarUrl) const;

	/**
	* Change the display name of the current user.
	*
	* @param displayName The new display name. If it is std::nullopt,
	* remove the user avatar.
	* @return A Promise that resolves when the request is completed.
	*/
	PromiseT setDisplayName(std::optional<std::string> displayName) const;

	// lager::reader<bool>
	inline auto syncing() const {
	return clientCursor()[&ClientModel::syncing];
	}

	/**
	* Start syncing if the Client is not syncing.
	*
	* Syncing will continue indefinitely, if the preparation of
	* the sync (posting filters and uploading identity keys,
	* if needed) is successful, or until stopSyncing() is called.
	*
	* @return A Promise that resolves when the Client is syncing
	* (more exactly, when syncing() contains true), or when there
	* is an error in the preparation of the sync.
	*/
	PromiseT startSyncing() const;

	/**
	* Stop the indefinite syncing.
	*
	* After this, no more syncing actions will be dispatched.
	*
	* @return A Promise that resolves when syncing is stopped.
	*/
	PromiseT stopSyncing() const;

	/**
	* Get the info of all devices of user `userId` that supports encryption.
	*
	* @param userId The id of the user to get the devices of.
	*
	* @return a lager::reader of a RangeT of DeviceKeyInfo representing the devices of that user.
	*/
	auto devicesOfUser(std::string userId) const -> lager::reader<immer::flex_vector<DeviceKeyInfo>>;

	/**
	* Set the trust level of a device.
	*
	* @param userId The id of the user to whom the device belongs.
	* @param deviceId The id of the device.
	*
	* @return a Promise that resolves when the setting is changed.
	*/
	PromiseT setDeviceTrustLevel(std::string userId, std::string deviceId, DeviceTrustLevel trustLevel) const;

	/**
	* Get the trust level needed to send keys to a device.
	*
	* @return a lager::reader of the trust level threshold.
	*/
	auto trustLevelNeededToSendKeys() const -> lager::reader<DeviceTrustLevel>;

	/**
	* Set the trust level needed to send keys to a device.
	*
	* @param trustLevel The trust level threshold.
	*
	* @return a Promise that resolves when the setting is changed.
	*/
	PromiseT setTrustLevelNeededToSendKeys(DeviceTrustLevel trustLevel) const;

	/**
	* Get the map from direct messaging room ids to user ids.
	*
	* @return a lager::reader of such mapping.
	*/
	auto directRoomMap() const -> lager::reader<immer::map<std::string, std::string>>;

	/**
	* Get the account data that is not associated with any room.
	*
	* @return A lager::reader of a map from the type to the account data event.
	*/
	auto accountData() const -> lager::reader<immer::map<std::string, Event>>;

	/**
	* Set the account data that is not associated with any room.
	*
	* @return A Promise that resolves when the account data
	* has been set, or when there is an error.
	*/
	PromiseT setAccountData(Event accountDataEvent) const;

	/**
	* Get a notification handler that works on this Client.
	*
	* @return A notification handler that works on this Client.
	*/
	NotificationHandler notificationHandler() const;

	/**
	* Serialize the model to a Boost.Serialization archive.
	*
	* @param ar A Boost.Serialization output archive.
	*
	* This function can be used to save the model. For loading,
	* you should use the makeSdk function. For example:
	*
	* ```c++
	* client.serializeTo(outputAr);
	*
	* SdkModel m;
	* inputAr >> m;
	* auto newSdk = makeSdk(m, ...);
	* ```
	*/
	template<class Archive>
	void serializeTo(Archive &ar) const {
	ar << sdkCursor().get();
	}

	private:
	void syncForever(std::optional<int> retryTime = std::nullopt) const;

	const lager::reader<SdkModel> &sdkCursor() const;
	lager::reader<ClientModel> clientCursor() const;

	std::optional<lager::reader<SdkModel>> m_sdk;
	std::optional<lager::reader<ClientModel>> m_client;
	ContextT m_ctx;
	std::optional<DepsT> m_deps;
	KAZV_DECLARE_THREAD_ID();
	KAZV_DECLARE_EVENT_LOOP_THREAD_ID_KEEPER(m_deps.has_value() ? &lager::get<EventLoopThreadIdKeeper &>(m_deps.value()) : 0);
	};

	}
	diff --git a/src/client/clientfwd.hpp b/src/client/clientfwd.hpp
	index 513617e..1e32d47 100644
	--- a/src/client/clientfwd.hpp
	+++ b/src/client/clientfwd.hpp
	@@ -1,148 +1,150 @@
	/*
	* 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 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
	>;

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

	using ClientResult = std::pair<ClientModel, ClientEffect>;
	}
	diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
	index 4248197..bc63309 100644
	--- a/src/tests/CMakeLists.txt
	+++ b/src/tests/CMakeLists.txt
	@@ -1,116 +1,117 @@

	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/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-benchmark-test.cpp
	client/room/read-receipt-test.cpp
	client/room/undecrypted-events-test.cpp
	client/encryption-benchmark-test.cpp
	+ client/logout-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/deterministic-test.cpp
	EXTRA_LINK_LIBRARIES kazvcrypto
	)

	libkazv_add_tests(
	store-test.cpp
	EXTRA_LINK_LIBRARIES kazvstore kazvjob
	)
	diff --git a/src/tests/client/logout-test.cpp b/src/tests/client/logout-test.cpp
	new file mode 100644
	index 0000000..d8733c3
	--- /dev/null
	+++ b/src/tests/client/logout-test.cpp
	@@ -0,0 +1,100 @@
	+/*
	+ * This file is part of libkazv.
	+ * SPDX-FileCopyrightText: 2024 April Simone <apr3vau@outlook.com>
	+ * SPDX-License-Identifier: AGPL-3.0-or-later
	+ */
	+
	+#include <libkazv-config.hpp>
	+
	+#include <lager/event_loop/boost_asio.hpp>
	+#include <cprjobhandler.hpp>
	+#include <lagerstoreeventemitter.hpp>
	+
	+#include <catch2/catch_all.hpp>
	+#include <boost/asio.hpp>
	+#include <asio-promise-handler.hpp>
	+#include <cursorutil.hpp>
	+#include <sdk-model.hpp>
	+#include <client/client.hpp>
	+#include <client/client-model.hpp>
	+
	+#include "client-test-util.hpp"
	+#include "action-mock-utils.hpp"
	+#include "factory.hpp"
	+
	+using namespace Kazv::Factory;
	+
	+TEST_CASE("Send logout job", "[client][auth]")
	+{
	+ ClientModel loggedInModel = makeClient({});
	+ auto [resModel, dontCareEffect] = ClientModel::update(
	+ loggedInModel, HardLogoutAction{});
	+ assert1Job(resModel);
	+ for1stJob(resModel, [] (const auto &job) {
	+ REQUIRE(job.jobId() == "Logout");
	+ REQUIRE(job.url() == "example.com/_matrix/client/v3/logout");
	+ });
	+}
	+
	+TEST_CASE("Process logout response", "[client][auth]")
	+{
	+ boost::asio::io_context io;
	+ AsioPromiseHandler ph{io.get_executor()};
	+
	+ auto store = createTestClientStore(ph);
	+
	+ WHEN("Success response")
	+ {
	+ auto succResponse = makeResponse("Logout");
	+ store.dispatch(ProcessResponseAction{succResponse})
	+ .then([&] (auto stat) {
	+ REQUIRE(stat.success());
	+ REQUIRE(store.reader().get().token == "");
	+ REQUIRE(store.reader().get().loggedIn == false);
	+ });
	+ }
	+ WHEN("Failed response")
	+ {
	+ auto failResponse = makeResponse("Logout", withResponseStatusCode(404));
	+ store.dispatch(ProcessResponseAction{failResponse})
	+ .then([] (auto stat) {
	+ REQUIRE(!stat.success());
	+ });
	+ }
	+ io.run();
	+}
	+
	+TEST_CASE("Test for stop syncing", "[client][auth]")
	+{
	+ boost::asio::io_context io;
	+ SingleTypePromiseInterface<EffectStatus> sgph{AsioPromiseHandler{io.get_executor()}};
	+
	+ ClientModel m = makeClient({});
	+
	+ auto jh = Kazv::CprJobHandler{io.get_executor()};
	+ auto ee = Kazv::LagerStoreEventEmitter(lager::with_boost_asio_event_loop{io.get_executor()});
	+
	+ auto sdk = Kazv::makeSdk(
	+ SdkModel{m},
	+ jh,
	+ ee,
	+ Kazv::AsioPromiseHandler{io.get_executor()},
	+ zug::identity
	+ );
	+ auto ctx = sdk.context();
	+ auto dispatcher = getMockDispatcher(
	+ sgph,
	+ ctx,
	+ passDown<SetShouldSyncAction>(),
	+ returnEmpty<HardLogoutAction>()
	+ );
	+ auto mockContext = getMockContext(sgph, dispatcher);
	+ auto client = Client(Client::InEventLoopTag{}, mockContext, sdk.context());
	+ client.logout()
	+ .then([&] (auto stat) {
	+ REQUIRE(stat.success());
	+ REQUIRE(client.shouldSync().make().get() == false);
	+ io.stop();
	+ });
	+ io.run();
	+}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 8, 9:48 AM (1 d, 6 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1723069
Default Alt Text: (88 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions