fix(account): align concentration labels and chart accessibility (WealthLedger/main#48)

.ai/architecture.md

@@ -8,7 +8,7 @@ Vitest — отдельную JSDOM конфигурацию. Точные versi
 [package.json](../package.json), реализация — source of truth.
 
 ```text
-app → pages → features → entities → shared
+app → pages → widgets → features → entities → shared
 page container → page VM → entity/feature query → shared/api → backend /api/v1
                          ↓
                  props → state/section views
@@ -30,13 +30,14 @@ contract; frontend не читает его checkout для генерации
 | --- | --- |
 | Bootstrap, глобальные providers, routes | `app` |
 | Композиция маршрута и поведение, нужное только этому экрану | `pages/<page>` |
+| Крупная переиспользуемая композиция экрана | `widgets/<widget>` |
 | Самостоятельная пользовательская возможность с собственным смыслом | `features/<capability>` |
 | Представление/поведение бизнес-сущности | `entities/<entity>` |
 | Переиспользуемый код без WealthLedger domain meaning | `shared` |
 
-Локальный FSD profile: `app → pages → features → entities → shared`.
+Локальный FSD profile: `app → pages → widgets → features → entities → shared`.
-Слой `widgets` не используется: композиция экрана и компонент для одной page
+Widget собирает несколько нижних слоёв в самостоятельный UI-блок; компонент для
-остаются у page. Form, mutation или click handler сами по себе не
+одной page остаётся у page. Form, mutation или click handler сами по себе не
 требуют feature. Два callers не делают domain helper generic shared.
 Slice именуется по ответственности, а не `helpers`, `hooks` или `types`.
 
@@ -48,12 +49,12 @@ Slice именуется по ответственности, а не `helpers`,
 
 Cross-slice consumer использует `@/` и `index.ts` владельца, например
 `@/entities/portfolio`. Alias Vite и TypeScript согласован. Другой slice не
-импортирует внутренний файл напрямую. Slices `pages`, `features`, `entities` не зависят от соседнего slice своего слоя;
+импортирует внутренний файл напрямую. Slices `pages`, `widgets`, `features`, `entities` не зависят от соседнего slice своего слоя;
 композиция принадлежит вышележащему owner. Existing меж-slice исключения
 не являются разрешением добавлять новые.
 
 Направление зависимостей, public imports и запрет соседних slices в
-`pages`, `features`, `entities` проверяет `npm run deps`. Внутренние imports
+`pages`, `widgets`, `features`, `entities` проверяет `npm run deps`. Внутренние imports
 одного slice и связи shared segments этот запрет не ограничивает.
 Knip проверяет использование exports, а не смысл placement.
 

CHANGELOG.md

@@ -1,61 +1,5 @@
 # Changelog
 
-## [1.4.0](https://git.personal.ksv741.ru/WealthLedger/frontend/compare/v1.3.0...v1.4.0) (2026-11-06)
-
-### Features
-
-* **investments:** warn and offer retry after exhausted read retries (WealthLedger/frontend[#55](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/55)) ([#136](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/136)) ([8ce1e8e](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/8ce1e8e44486dcc23d4c074559ca2bb517880b60))
-
-### Bug Fixes
-
-* **account:** show source metadata on empty account and income (WealthLedger/frontend[#55](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/55)) ([#133](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/133)) ([9619dc9](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/9619dc979172dbc16391206e801ed67862d20116))
-* align audit findings for Events, currency and auth (WealthLedger/frontend[#155](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/155)) ([668f2ef](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/668f2ef70e535a1222e7f600b1be4a31fefc6f8b))
-
-### Refactoring
-
-* **api:** consume bank operation oneOf contract (WealthLedger/frontend[#144](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/144)) ([#152](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/152)) ([2d070ce](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/2d070ce2b54bbee466ecf6cc18b437910f0c07f8))
-* drop dead query helpers and simplify read deadline (WealthLedger/frontend[#141](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/141)) ([#149](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/149)) ([5077bd4](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/5077bd4f0baa4a59643e875485c2f08253cc198d))
-* move portfolio structure into account page, drop widgets (WealthLedger/frontend[#139](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/139)) ([#140](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/140)) ([e2d143d](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/e2d143df46e650139e49b7c80a886008ede86d2a))
-* normalize view models and share breadcrumbs and titles (WealthLedger/frontend[#143](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/143)) ([#153](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/153)) ([2db39f2](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/2db39f25d9478350ad56a1b2e2ca6496068257c5))
-* replace repeated lazy page wrappers with lazyPage helper ([#131](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/131)) ([#132](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/132)) ([71fbe77](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/71fbe7774d3ed63fcb84bc644da997921bc049b2))
-* share path-root query predicate (WealthLedger/frontend[#142](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/142)) ([#154](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/154)) ([cadba8d](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/cadba8d075daf9b20c0c9de97ad5bd8f5a3e74fc))
-
-### Maintenance
-
-* **api:** update OpenAPI snapshot with UpcomingEventsDto.window (WealthLedger/frontend[#134](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/134)) ([#135](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/135)) ([aaee959](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/aaee9591d7880193ee9b0c14339e8477264e4a94))
-* **deps:** set Renovate release age, PR limit and update groups (WealthLedger/main[#6](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/6)) ([#137](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/137)) ([ad93725](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/ad93725a84615ec329631b71ed8db33337085740))
-
-## [1.3.0](https://git.personal.ksv741.ru/WealthLedger/frontend/compare/v1.2.1...v1.3.0) (2026-11-01)
-
-### Features
-
-* **account:** add concentration tab with top-5 slices and chart (WealthLedger/main[#48](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/48)) ([#127](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/127)) ([70a2c33](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/70a2c335fdddb8b6a99e3f609befe06aeb8cc45d))
-* group all-account rows by instrument and day (WealthLedger/main[#47](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/47)) ([#126](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/126)) ([71126c9](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/71126c91f0b30f4d65a313ddc7d7f86963340455))
-* make brokerage account list compact ([#111](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/111)) ([c24704a](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/c24704affacbe7fbc08f5e2b61bb6e7ffa6053b9))
-* remove top header and rework mobile bottom navigation ([#109](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/109)) ([1a92f02](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/1a92f023c1c79f646424f72710ab74de63386a11))
-* replace account page accordion with tabs and show open position result ([#112](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/112)) ([3075081](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/3075081df188de0630d314ba15a34fe6efd1eea9))
-* show return, cash and structure on account cards ([#114](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/114)) ([431559b](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/431559be0fca9eb37f6a09d930d502f939884e39))
-
-### Bug Fixes
-
-* round money to currency minor units without negative zero (WealthLedger/frontend[#118](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/118)) ([#119](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/119)) ([1d49904](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/1d4990491f254e1ec6bafad8204872eaae2982d0))
-* show account source sync status (WealthLedger/frontend[#120](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/120)) ([#121](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/121)) ([a56edf2](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/a56edf2b3757ef0b0f6c42ecbd422a1a563f6505))
-* show history loading alert only while loading (WealthLedger/frontend[#124](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/124)) ([#125](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/125)) ([6792f5b](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/6792f5b70aa3ba90b2eb2df7e63d3ae2f669e295))
-* stabilize auth client registration (WealthLedger/frontend[#95](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/95)) ([#122](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/122)) ([5796d2d](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/5796d2d789963e66a3a4bcd79eab44700f16bd31))
-
-### Refactoring
-
-* derive api error codes from contract (WealthLedger/backend[#117](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/117)) ([#123](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/123)) ([32e8fe9](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/32e8fe9402665ea0c350f5f247d87e328ffd44c8))
-
-### Tests
-
-* pin date in all accounts events test ([#115](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/115)) ([58b4e12](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/58b4e126330d01c1d6865bd0e9dd066a028fba08))
-
-### Maintenance
-
-* **deps:** resolve minimatch and glob audit advisories (WealthLedger/main[#49](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/49)) ([#128](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/128)) ([7242240](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/7242240b2188e9d1ca1325e65d0e1a0a3655d882))
-* sync brokerage accounts contract (WealthLedger/backend[#138](https://git.personal.ksv741.ru/WealthLedger/frontend/issues/138)) ([0e4bbec](https://git.personal.ksv741.ru/WealthLedger/frontend/commit/0e4bbec2a7b814579095ea7ef6db68a70508fa29))
-
 ## [1.2.1](https://git.personal.ksv741.ru/WealthLedger/frontend/compare/v1.2.0...v1.2.1) (2026-10-24)
 
 ### Bug Fixes

dependency-cruiser.cjs

@@ -29,17 +29,17 @@ module.exports = {
 		},
 		{
 			from: {
-				path: "^src/(app|pages|features|entities|shared)/([^/]+)/",
+				path: "^src/(app|pages|widgets|features|entities|shared)/([^/]+)/",
 			},
 			name: "slices-must-use-public-api",
 			severity: "error",
 			to: {
-				path: String.raw`^src/(app|pages|features|entities|shared)/([^/]+)/(?!index\.ts$)`,
+				path: String.raw`^src/(app|pages|widgets|features|entities|shared)/([^/]+)/(?!index\.ts$)`,
 				pathNot: "^src/$1/$2/",
 			},
 		},
 		{
-			from: { path: "^src/(pages|features|entities)/([^/]+)/" },
+			from: { path: "^src/(pages|widgets|features|entities)/([^/]+)/" },
 			name: "no-same-layer-cross-slice-imports",
 			severity: "error",
 			to: { path: "^src/$1/", pathNot: "^src/$1/$2/" },
@@ -48,18 +48,24 @@ module.exports = {
 			from: { path: "^src/shared/" },
 			name: "shared-must-not-depend-on-layers",
 			severity: "error",
-			to: { path: "^src/(entities|features|pages|app)/" },
+			to: { path: "^src/(entities|features|widgets|pages|app)/" },
 		},
 		{
 			from: { path: "^src/entities/" },
 			name: "entities-must-not-depend-on-higher-layers",
 			severity: "error",
-			to: { path: "^src/(features|pages|app)/" },
+			to: { path: "^src/(features|widgets|pages|app)/" },
 		},
 		{
 			from: { path: "^src/features/" },
 			name: "features-must-not-depend-on-higher-layers",
 			severity: "error",
+			to: { path: "^src/(widgets|pages|app)/" },
+		},
+		{
+			from: { path: "^src/widgets/" },
+			name: "widgets-must-not-depend-on-higher-layers",
+			severity: "error",
 			to: { path: "^src/(pages|app)/" },
 		},
 		{

docker/nginx.conf

@@ -17,21 +17,12 @@ http {
         default $http_x_forwarded_proto;
         '' $scheme;
     }
-    # One shared budget: the external proxy's client-IP forwarding is not verified.
-    map "$request_method:$uri" $auth_admission_key {
-        default "";
-        POST:/api/v1/auth/login auth;
-        POST:/api/v1/auth/register auth;
-    }
-    limit_req_zone $auth_admission_key zone=auth_admission:1m rate=2r/s;
-    limit_req_status 429;
     server {
         listen 8080;
         server_name _;
         root /usr/share/nginx/html;
         resolver 127.0.0.11 valid=5s ipv6=off;
         location /api/ {
-            limit_req zone=auth_admission burst=5 nodelay;
             set $backend http://backend:3000;
             proxy_pass $backend$request_uri;
             proxy_set_header Host $http_host;

eslint-rules.mjs

@@ -25,11 +25,7 @@ const readability = {
 				)
 					context.report({ messageId: "schema", node });
 			},
-			FunctionDeclaration(node) {
+			FunctionDeclaration: checkParameters,
-				checkParameters(node);
-				if (node.id?.name?.endsWith?.("ViewModel"))
-					context.report({ messageId: "vmName", node: node.id });
-			},
 			FunctionExpression: checkParameters,
 			ImportDeclaration(node) {
 				if (
@@ -99,7 +95,6 @@ const readability = {
 			schema: "Declare Zod schemas in a dedicated *.schema.ts file.",
 			svg: "Own SVG markup in packages/icons, and import its public component.",
 			union: "Put complex union members on separate lines.",
-			vmName: "Name custom hooks use*Vm, not use*ViewModel.",
 		},
 		schema: [],
 		type: "suggestion",

package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "wealth-ledger-frontend",
-	"version": "1.4.0",
+	"version": "1.2.1",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "wealth-ledger-frontend",
-			"version": "1.4.0",
+			"version": "1.2.1",
 			"workspaces": [
 				"packages/*"
 			],

package.json

@@ -1,7 +1,7 @@
 {
 	"name": "wealth-ledger-frontend",
 	"private": true,
-	"version": "1.4.0",
+	"version": "1.2.1",
 	"type": "module",
 	"engines": {
 		"node": "24.22.1"

renovate.json

@@ -1,30 +1,15 @@
 {
 	"$schema": "https://docs.renovatebot.com/renovate-schema.json",
-	"extends": ["config:recommended", ":semanticCommitTypeAll(chore)", "security:minimumReleaseAgeNpm"],
+	"extends": ["config:recommended", ":semanticCommitTypeAll(chore)"],
 	"timezone": "Europe/Moscow",
 	"labels": ["dependencies"],
 	"dependencyDashboard": true,
 	"rangeStrategy": "pin",
-	"prConcurrentLimit": 5,
-	"lockFileMaintenance": {
-		"enabled": true,
-		"schedule": ["before 4am on the first day of the month"]
-	},
 	"packageRules": [
 		{
 			"matchUpdateTypes": ["minor", "patch"],
 			"groupName": "non-major dependencies"
 		},
-		{
-			"matchManagers": ["github-actions"],
-			"matchUpdateTypes": ["minor", "patch"],
-			"groupName": "non-major github actions"
-		},
-		{
-			"matchManagers": ["docker-compose", "dockerfile"],
-			"matchUpdateTypes": ["minor", "patch"],
-			"groupName": "non-major container images"
-		},
 		{
 			"matchUpdateTypes": ["major"],
 			"dependencyDashboardApproval": true

src/app/routes/AppRoutes/AllAccounts.test.tsx

@@ -55,12 +55,12 @@ const position: Portfolio["positions"][number]
 	};
 
 const portfolio: Portfolio = {
-	cash: { currency: "RUB", value: "0" },
+	cashBalances: [],
 	isStale: false,
 	lastSuccessfulAt: "2026-08-15T12:00:00Z",
 	positions: accounts.map(account => ({ ...position, account })),
-	structure: { categories: [], hasNegativeValues: false, totalValue: "0", unvaluedCategories: [] },
+	structure: { currencies: [], unvaluedCategories: [] },
-	totals: { currency: "RUB", value: "1200" },
+	totalsByCurrency: [{ currency: "RUB", value: "1200" }],
 };
 
 const receipt: BrokerageOperation
@@ -106,11 +106,14 @@ const analytics: IncomeAnalytics
 			},
 		],
 		period: { from: "2026-08-01", to: "2026-08-31" },
-		total: {
+		totalsByCurrency: [
+			{
 				coupon: { currency: "RUB", value: "2" },
+				currency: "RUB",
 				dividend: { currency: "RUB", value: "0" },
 				total: { currency: "RUB", value: "2" },
 			},
+		],
 	};
 
 const CurrentLocation: FC = () => {
@@ -213,8 +216,7 @@ beforeEach(() => {
 								type: "coupon",
 							}),
 					),
-					incomeTotal: { currency: "RUB", value: "0" },
+					incomeTotalsByCurrency: [],
-					window: { from: "2026-09-01", to: "2026-10-01" },
 				}),
 			),
 		),
@@ -224,9 +226,9 @@ beforeEach(() => {
 describe("All accounts routes", () => {
 	it.each([
 		["/accounts/all", "Все счета"],
-		["/accounts/all/operations", "История операций"],
+		["/accounts/all/operations", "Журнал операций"],
 		["/accounts/all/income?from=2026-08-01&to=2026-08-31", "Пассивный доход"],
-		["/accounts/all/events", "Предстоящие события"],
+		["/accounts/all/events", "Будущие события"],
 	])("opens %s directly", async (path, title) => {
 		renderPage(path);
 		expect(
@@ -308,9 +310,9 @@ describe("All accounts routes", () => {
 			);
 
 		for (const [suffix, tab] of [
-			["operations", "История операций"],
+			["operations", "Операции"],
 			["income", "Доход"],
-			["events", "Предстоящие события"],
+			["events", "События"],
 		]) {
 			fireEvent.click(screen.getByRole("tab", { name: tab }));
 			expect(screen.getByRole("link", { name: "Подробнее" }))

src/app/routes/AppRoutes/AppRoutes.tsx

@@ -1,4 +1,4 @@
-import type { ComponentType, FC } from "react";
+import type { FC } from "react";
 
 import { lazy } from "react";
 import { Navigate, Route, Routes } from "react-router";
@@ -6,35 +6,101 @@ import { Navigate, Route, Routes } from "react-router";
 import { LazyPage } from "../RouteFallback";
 import { Protected, Public } from "../RouteGuards";
 
-// Pages use named exports; React.lazy needs a default export per dynamic import (one chunk each).
+const CardPage = lazy(async () => {
-function lazyPage<Name extends string>(
+	const { CardPage } = await import("@/pages/card");
-	load: () => Promise<Record<Name, ComponentType>>,
-	name: Name,
-) {
-	return lazy(async () => {
-		const page = await load();
 
-		// eslint-disable-next-line security/detect-object-injection -- `name` is a compile-time literal checked against the module's exports.
+	return { default: CardPage };
-		return { default: page[name] };
+});
-	});
-}
 
-const CardPage = lazyPage(async () => import("@/pages/card"), "CardPage");
+const CardsPage = lazy(async () => {
-const CardsPage = lazyPage(async () => import("@/pages/cards"), "CardsPage");
+	const { CardsPage } = await import("@/pages/cards");
-const BondPage = lazyPage(async () => import("@/pages/bond"), "BondPage");
+
-const BondsPage = lazyPage(async () => import("@/pages/bonds"), "BondsPage");
+	return { default: CardsPage };
-const StockPage = lazyPage(async () => import("@/pages/stock"), "StockPage");
+});
-const StocksPage = lazyPage(async () => import("@/pages/stocks"), "StocksPage");
+
-const AccountPage = lazyPage(async () => import("@/pages/account"), "AccountPage");
+const BondPage = lazy(async () => {
-const AccountEventsPage = lazyPage(async () => import("@/pages/account-events"), "AccountEventsPage");
+	const { BondPage } = await import("@/pages/bond");
-const AccountOperationsPage = lazyPage(async () => import("@/pages/account-operations"), "AccountOperationsPage");
+
-const AccountIncomePage = lazyPage(async () => import("@/pages/account-income"), "AccountIncomePage");
+	return { default: BondPage };
-const AccountsPage = lazyPage(async () => import("@/pages/accounts"), "AccountsPage");
+});
-const LoginPage = lazyPage(async () => import("@/pages/login"), "LoginPage");
+
-const NotFoundPage = lazyPage(async () => import("@/pages/not-found"), "NotFoundPage");
+const BondsPage = lazy(async () => {
-const RegisterPage = lazyPage(async () => import("@/pages/register"), "RegisterPage");
+	const { BondsPage } = await import("@/pages/bonds");
-const SettingsPage = lazyPage(async () => import("@/pages/settings"), "SettingsPage");
+
-const ProtectedLayout = lazyPage(async () => import("../ProtectedLayout"), "ProtectedLayout");
+	return { default: BondsPage };
+});
+
+const StockPage = lazy(async () => {
+	const { StockPage } = await import("@/pages/stock");
+
+	return { default: StockPage };
+});
+
+const StocksPage = lazy(async () => {
+	const { StocksPage } = await import("@/pages/stocks");
+
+	return { default: StocksPage };
+});
+
+const AccountPage = lazy(async () => {
+	const { AccountPage } = await import("@/pages/account");
+
+	return { default: AccountPage };
+});
+
+const AccountEventsPage = lazy(async () => {
+	const { AccountEventsPage } = await import("@/pages/account-events");
+
+	return { default: AccountEventsPage };
+});
+
+const AccountOperationsPage = lazy(async () => {
+	const { AccountOperationsPage } = await import("@/pages/account-operations");
+
+	return { default: AccountOperationsPage };
+});
+
+const AccountIncomePage = lazy(async () => {
+	const { AccountIncomePage } = await import("@/pages/account-income");
+
+	return { default: AccountIncomePage };
+});
+
+const AccountsPage = lazy(async () => {
+	const { AccountsPage } = await import("@/pages/accounts");
+
+	return { default: AccountsPage };
+});
+
+const LoginPage = lazy(async () => {
+	const { LoginPage } = await import("@/pages/login");
+
+	return { default: LoginPage };
+});
+
+const NotFoundPage = lazy(async () => {
+	const { NotFoundPage } = await import("@/pages/not-found");
+
+	return { default: NotFoundPage };
+});
+
+const RegisterPage = lazy(async () => {
+	const { RegisterPage } = await import("@/pages/register");
+
+	return { default: RegisterPage };
+});
+
+const SettingsPage = lazy(async () => {
+	const { SettingsPage } = await import("@/pages/settings");
+
+	return { default: SettingsPage };
+});
+
+const ProtectedLayout = lazy(async () => {
+	const { ProtectedLayout } = await import("../ProtectedLayout");
+
+	return { default: ProtectedLayout };
+});
 
 const AppRoutes: FC = () => (
 	<Routes>

src/app/routes/DocumentTitle/DocumentTitle.tsx

@@ -1,5 +1,6 @@
 import type { FC } from "react";
 
+import { useDocumentTitle } from "@mantine/hooks";
 import { useTranslation } from "react-i18next";
 
 import { useCurrentRoute } from "@/app/model";
@@ -7,12 +8,12 @@ import { useBankCard } from "@/entities/bank-card";
 import { useBond } from "@/entities/bond";
 import { useBrokerageAccounts } from "@/entities/brokerage-account";
 import { useStock } from "@/entities/stock";
-import { useAppDocumentTitle } from "@/shared/ui";
 
 type DocumentTitleProps = { title: string };
 
 const DocumentTitle: FC<DocumentTitleProps> = (props): undefined => {
-	useAppDocumentTitle(props.title);
+	const { t } = useTranslation();
+	useDocumentTitle(`${props.title} — ${t("appName")}`);
 };
 
 type AccountDocumentTitleProps = {

src/app/routes/RouteErrorBoundary/RouteErrorBoundary.tsx

@@ -1,12 +1,12 @@
 import type { FC, PropsWithChildren } from "react";
 
 import { Button, Stack, Text, Title } from "@mantine/core";
+import { useDocumentTitle } from "@mantine/hooks";
 import { Component } from "react";
 import { useTranslation } from "react-i18next";
 import { Link, useLocation } from "react-router";
 
 import { useAuth } from "@/features/auth";
-import { useAppDocumentTitle } from "@/shared/ui";
 
 type BoundaryProps = PropsWithChildren<{
 	authenticated: boolean;
@@ -37,7 +37,7 @@ class Boundary extends Component<BoundaryProps, State> {
 const RouteErrorFallback: FC<RouteErrorFallbackProps> = (props) => {
 	const { authenticated } = props;
 	const { t } = useTranslation();
-	useAppDocumentTitle(t("routeError.title"));
+	useDocumentTitle(`${t("routeError.title")} — ${t("appName")}`);
 	const to = authenticated ? "/accounts" : "/login";
 
 	return (

src/app/ui/AppBreadcrumbs/AppBreadcrumbs.test.tsx

@@ -55,9 +55,9 @@ describe("AppBreadcrumbs", () => {
 	});
 
 	it.each([
-		["operations", "История операций"],
+		["operations", "Операции"],
-		["OPERATIONS", "История операций"],
+		["OPERATIONS", "Операции"],
-		["events", "Предстоящие события"],
+		["events", "Будущие события"],
 		["income", "Пассивный доход"],
 	])("links to the account hierarchy from %s", (section, title) => {
 		renderBreadcrumbs(`/accounts/account-1/${section}`, [

src/app/ui/AppBreadcrumbs/AppBreadcrumbs.tsx

@@ -7,8 +7,10 @@ import { useCurrentRoute } from "@/app/model";
 
 import { AccountBreadcrumbs } from "./AccountBreadcrumbs";
 import { AccountScopeSwitch } from "./AccountScopeSwitch/AccountScopeSwitch";
+import { BondBreadcrumbs } from "./BondBreadcrumbs";
 import { BreadcrumbTrail } from "./BreadcrumbTrail";
-import { EntityBreadcrumbs } from "./EntityBreadcrumbs";
+import { CardBreadcrumbs } from "./CardBreadcrumbs";
+import { StockBreadcrumbs } from "./StockBreadcrumbs";
 
 const AppBreadcrumbs: FC = () => {
 	const { t } = useTranslation();
@@ -24,16 +26,9 @@ const AppBreadcrumbs: FC = () => {
 		stock,
 	} = useCurrentRoute();
 
-	if (bond) {
+	if (bond) return <BondBreadcrumbs identifier={bond.params.bondId ?? ""} />;
-		return <EntityBreadcrumbs identifier={bond.params.bondId ?? ""} kind="bond" />;
+	if (stock)
-	}
+		return <StockBreadcrumbs identifier={stock.params.stockId ?? ""} />;
-
-	if (stock) {
-		return (
-			<EntityBreadcrumbs identifier={stock.params.stockId ?? ""} kind="stock" />
-		);
-	}
-
 	if (account && (section || !account.params.section))
 		return (
 			<Stack gap={0} mb="md">
@@ -48,13 +43,8 @@ const AppBreadcrumbs: FC = () => {
 				/>
 			</Stack>
 		);
-
+	if (card) return <CardBreadcrumbs identifier={card.params.cardId ?? ""} />;
-	if (card) {
-		return <EntityBreadcrumbs identifier={card.params.cardId ?? ""} kind="card" />;
-	}
-
 	if (cards) return <BreadcrumbTrail items={[{ label: t("bank.title") }]} />;
-
 	if (accounts)
 		return <BreadcrumbTrail items={[{ label: t("breadcrumbs.accounts") }]} />;
 

src/app/ui/AppBreadcrumbs/BondBreadcrumbs.tsx

@@ -0,0 +1,25 @@
+import type { FC } from "react";
+
+import { useTranslation } from "react-i18next";
+
+import { useBond } from "@/entities/bond";
+
+import { BreadcrumbTrail } from "./BreadcrumbTrail";
+
+type BondBreadcrumbsProps = { identifier: string };
+
+const BondBreadcrumbs: FC<BondBreadcrumbsProps> = (props) => {
+	const { data } = useBond(props.identifier);
+	const { t } = useTranslation();
+
+	return (
+		<BreadcrumbTrail
+			items={[
+				{ label: t("bond.searchTitle"), to: "/bonds" },
+				{ label: data?.name ?? t("bond.instrument") },
+			]}
+		/>
+	);
+};
+
+export { BondBreadcrumbs };

src/app/ui/AppBreadcrumbs/BreadcrumbTrail.tsx

@@ -39,4 +39,4 @@ const BreadcrumbTrail: FC<BreadcrumbTrailProps> = (props) => {
 	);
 };
 
-export { BreadcrumbTrail, type Crumb };
+export { BreadcrumbTrail };

src/app/ui/AppBreadcrumbs/CardBreadcrumbs.tsx

@@ -0,0 +1,25 @@
+import type { FC } from "react";
+
+import { useTranslation } from "react-i18next";
+
+import { useBankCard } from "@/entities/bank-card";
+
+import { BreadcrumbTrail } from "./BreadcrumbTrail";
+
+type CardBreadcrumbsProps = { identifier: string };
+
+const CardBreadcrumbs: FC<CardBreadcrumbsProps> = (props) => {
+	const { data } = useBankCard(props.identifier);
+	const { t } = useTranslation();
+
+	return (
+		<BreadcrumbTrail
+			items={[
+				{ label: t("bank.title"), to: "/cards" },
+				{ label: data?.name ?? t("bank.card") },
+			]}
+		/>
+	);
+};
+
+export { CardBreadcrumbs };

src/app/ui/AppBreadcrumbs/EntityBreadcrumbs.tsx

@@ -1,48 +0,0 @@
-import type { FC } from "react";
-
-import { useTranslation } from "react-i18next";
-
-import { useBankCard } from "@/entities/bank-card";
-import { useBond } from "@/entities/bond";
-import { useStock } from "@/entities/stock";
-
-import type { Crumb } from "./BreadcrumbTrail";
-
-import { BreadcrumbTrail } from "./BreadcrumbTrail";
-
-type EntityBreadcrumbsProps = {
-	identifier: string;
-	kind:
-		| "bond"
-		| "card"
-		| "stock";
-};
-
-const EntityBreadcrumbs: FC<EntityBreadcrumbsProps> = (props) => {
-	const { identifier, kind } = props;
-	const { t } = useTranslation();
-
-	const bond = useBond(kind === "bond" ? identifier : "");
-	const card = useBankCard(kind === "card" ? identifier : "");
-	const stock = useStock(kind === "stock" ? identifier : "");
-
-	let parent: Crumb;
-	let name: string;
-
-	if (kind === "bond") {
-		parent = { label: t("bond.searchTitle"), to: "/bonds" };
-		name = bond.data?.name ?? t("bond.instrument");
-	}
-	else if (kind === "stock") {
-		parent = { label: t("stock.searchTitle"), to: "/stocks" };
-		name = stock.data?.name ?? t("stock.share");
-	}
-	else {
-		parent = { label: t("bank.title"), to: "/cards" };
-		name = card.data?.name ?? t("bank.card");
-	}
-
-	return <BreadcrumbTrail items={[parent, { label: name }]} />;
-};
-
-export { EntityBreadcrumbs };

src/app/ui/AppBreadcrumbs/StockBreadcrumbs.tsx

@@ -0,0 +1,25 @@
+import type { FC } from "react";
+
+import { useTranslation } from "react-i18next";
+
+import { useStock } from "@/entities/stock";
+
+import { BreadcrumbTrail } from "./BreadcrumbTrail";
+
+type StockBreadcrumbsProps = { identifier: string };
+
+const StockBreadcrumbs: FC<StockBreadcrumbsProps> = (props) => {
+	const { data } = useStock(props.identifier);
+	const { t } = useTranslation();
+
+	return (
+		<BreadcrumbTrail
+			items={[
+				{ label: t("stock.searchTitle"), to: "/stocks" },
+				{ label: data?.name ?? t("stock.share") },
+			]}
+		/>
+	);
+};
+
+export { StockBreadcrumbs };

src/entities/bank-card/api/mutations.ts

@@ -5,7 +5,6 @@ import {
 	ApiErrorCode,
 	apiErrorCode,
 	isApiErrorCode,
-	isGetUnder,
 } from "@/shared/api";
 
 import type {
@@ -27,14 +26,21 @@ async function mutationData<T>(
 	return data;
 }
 
-const bankCardGetPredicate = isGetUnder(["/api/v1/bank-cards"]);
-
 function useBankMutationOptions() {
 	const queryClient = useQueryClient();
 
 	const invalidate = () =>
 		queryClient.invalidateQueries({
-			predicate: ({ queryKey }) => bankCardGetPredicate(queryKey),
+			predicate: ({ queryKey }) => {
+				const [method, path] = queryKey;
+
+				return (
+					method === "get"
+					&& typeof path === "string"
+					&& (path === "/api/v1/bank-cards"
+						|| path.startsWith("/api/v1/bank-cards/"))
+				);
+			},
 		});
 
 	return {

src/entities/broker-operation/model/display.ts

@@ -49,10 +49,6 @@ function entryLabelKey(operation: BrokerageOperation): string {
 	return `ledger.category.${operation.category}`;
 }
 
-function isCouponPayment(operation: BrokerageOperation): boolean {
-	return isOperationType(operation.type, OperationType.Coupon);
-}
-
 function isIncomePayment(operation: BrokerageOperation): boolean {
 	return [OperationType.Coupon, OperationType.Dividend].some(type =>
 		isOperationType(operation.type, type),
@@ -135,7 +131,6 @@ function paymentPresentation(
 export {
 	brokerageOperationGroupKey,
 	entryLabelKey,
-	isCouponPayment,
 	isIncomePayment,
 	isZeroDecimal,
 	operationLabelKey,

src/entities/broker-operation/ui/OperationGroup.test.tsx

@@ -55,27 +55,23 @@ function renderGroup(
 }
 
 describe("OperationGroup", () => {
-	it("shows the received coupon and positive totals in flat account rows", () => {
+	it("shows the header, exact total and separate card rows per account", () => {
 		renderGroup([
-			{ ...operation("1", { id: "broker", name: "Брокерский" }, "0.1"), description: "Выплата купонов СФО ВТБ РКС Эталон 04" },
+			operation("1", { id: "broker", name: "Брокерский" }, "0.1"),
 			operation("2", { id: "iis", name: "ИИС" }, "0.2"),
 		]);
 
-		expect(screen.getByText("Выплата купонов СФО ВТБ РКС Эталон 04")).toBeInTheDocument();
+		expect(screen.getByText("Купон · BOND")).toBeInTheDocument();
 		expect(screen.getByText("+0,3 ₽")).toBeInTheDocument();
 
 		const accounts = within(screen.getByRole("list", {
-			name: /Выплата купонов СФО ВТБ РКС Эталон 04, Исполнено 14\.08\.2026.*, \+0,3 ₽/,
+			name: /Купон · BOND, Исполнено 14\.08\.2026.*, \+0,3 ₽/,
 		}));
 
 		expect(accounts.getByRole("listitem", { name: "Брокерский, +0,1 ₽" }))
 			.toHaveTextContent("Купон");
-		expect(accounts.getByText("+0,1 ₽")).toHaveClass(/positive/);
 		expect(accounts.getByRole("listitem", { name: "ИИС, +0,2 ₽" }))
 			.toHaveTextContent("Купон");
-		expect(accounts.getByText("+0,2 ₽")).toHaveClass(/positive/);
-		expect(accounts.getByRole("listitem", { name: "ИИС, +0,2 ₽" }))
-			.not.toHaveClass("EntryGroup_accountCardRow");
 		expect(accounts.queryByText(/Исполнено/)).not.toBeInTheDocument();
 		expect(accounts.queryByRole("link")).not.toBeInTheDocument();
 	});
@@ -87,10 +83,8 @@ describe("OperationGroup", () => {
 		]);
 
 		expect(screen.getByRole("list", {
-			name: /Выплата купонов BOND, Исполнено .*Итог недоступен/,
+			name: /Купон · BOND, Исполнено .*Итог недоступен/,
 		})).toBeInTheDocument();
-		expect(screen.getByText("Итог недоступен")).toBeInTheDocument();
-		expect(screen.getByText("—")).not.toHaveClass(/positive/);
 	});
 
 	it.each(["0", "0.000"])(
@@ -120,7 +114,6 @@ describe("OperationGroup", () => {
 			operation("2", { id: "iis", name: "ИИС" }, "-100"),
 		]);
 		expect(screen.getByText("0 ₽")).toBeInTheDocument();
-		expect(screen.getByText("−100 ₽")).toHaveClass(/negative/);
 	});
 
 	it("renders repeated ids inside one group as separate rows", () => {
@@ -130,7 +123,7 @@ describe("OperationGroup", () => {
 		]);
 
 		expect(screen.getByText("+30 ₽")).toBeInTheDocument();
-		const accounts = within(screen.getByRole("list", { name: /Выплата купонов/ }));
+		const accounts = within(screen.getByRole("list", { name: /Купон/ }));
 		expect(accounts.getAllByText("Брокерский")).toHaveLength(1);
 		expect(accounts.getAllByText("ИИС")).toHaveLength(1);
 		expect(accounts.getAllByRole("listitem")).toHaveLength(2);

src/entities/broker-operation/ui/OperationGroup.tsx

@@ -9,13 +9,12 @@ import {
 	sumMoney,
 	totalText,
 } from "@/shared/lib";
-import { AccountCardRow, AccountRow, EntryGroup, EntryGroupTotal } from "@/shared/ui";
+import { AccountCardRow, EntryGroup, EntryGroupTotal } from "@/shared/ui";
 
 import type { BrokerageOperation } from "../api/useBrokerageOperations";
 
 import {
 	entryLabelKey,
-	isCouponPayment,
 	isZeroDecimal,
 	operationLabelKey,
 	paymentPresentation,
@@ -38,8 +37,6 @@ const OperationGroup: FC<OperationGroupProps> = (props) => {
 		? entryLabelKey(first)
 		: operationLabelKey(first.type));
 
-	const isCoupon = isCouponPayment(first);
-
 	const instrument
 		= first.ticker ?? first.instrumentType ?? t("ledger.noInstrument");
 
@@ -55,21 +52,9 @@ const OperationGroup: FC<OperationGroupProps> = (props) => {
 		: null;
 
 	const date = formatSnapshotDay(first.occurredAt);
-	const description = first.description.trim();
+	const title = `${typeLabel} · ${instrument}`;
-	let title = `${typeLabel} · ${instrument}`;
-
-	if (isCoupon) {
-		title = description && description.toLocaleLowerCase() !== "купон"
-			? description
-			: t("ledger.couponPayment", { instrument });
-	}
-
 	const totalsText = totalText(totals, true);
 
-	const totalTone = isCoupon && totals && !isZeroDecimal(totals.value) && !totals.value.startsWith("-")
-		? "positive"
-		: "neutral";
-
 	const accessibleName = [
 		title,
 		t("payout.executedAt", { date }),
@@ -78,14 +63,13 @@ const OperationGroup: FC<OperationGroupProps> = (props) => {
 
 	return (
 		<EntryGroup
-			flat={isCoupon}
 			header={(
 				<EntryCard
 					imageSrc={instrumentLogoUrl(first.logoName)}
 					initial={(first.ticker?.trim()[0] ?? "?").toUpperCase()}
 					metadata={t("payout.executedAt", { date })}
 					title={title}
-					tone={totalTone}
+					tone="neutral"
 					value={<EntryGroupTotal isSigned totals={totals} />}
 					valueLabel={typeLabel}
 					wrap
@@ -96,15 +80,14 @@ const OperationGroup: FC<OperationGroupProps> = (props) => {
 			{props.entries.map(({ key, operation }) => {
 				const payment = paymentPresentation(operation);
 
-				const accountRowProps = {
+				return (
-					accountName: operation.account?.name ?? "—",
+					<AccountCardRow
-					value: payment.amount,
+						accountName={operation.account?.name ?? "—"}
-					valueLabel: t(payment.label),
+						key={key}
-				};
+						value={payment.amount}
-
+						valueLabel={t(payment.label)}
-				return isCoupon
+					/>
-					? <AccountRow key={key} {...accountRowProps} tone={payment.tone} />
+				);
-					: <AccountCardRow key={key} {...accountRowProps} />;
 			})}
 		</EntryGroup>
 	);

src/entities/brokerage-account/model/display.ts

@@ -4,6 +4,8 @@ import type {
 	BrokerageAccount,
 } from "../api/useBrokerageAccounts";
 
+const VISIBLE_CURRENCY_LIMIT = 2;
+
 type BrokerageAccountCard = {
 	account: BrokerageAccount;
 	positionCounts: null | PositionCounts;
@@ -11,13 +13,18 @@ type BrokerageAccountCard = {
 	summary:
 		| {
 			portfolio: NonNullable<BrokerageAccount["portfolioSummary"]>;
+			remainingCurrencyCount: number;
 			state: "available";
-			totals: NonNullable<BrokerageAccount["portfolioSummary"]>["totals"];
+			totals: Money[];
 		}
 		| { state: "empty" }
 		| { state: "unavailable" };
 };
 
+type Money = NonNullable<
+	BrokerageAccount["portfolioSummary"]
+>["totalsByCurrency"][number];
+
 type PositionCounts = { bonds: number; stocks: number; total: number };
 
 function accountTypeKey(type: BrokerageAccount["type"]) {
@@ -50,7 +57,7 @@ function brokerageAccountCards(
 			total: summary.totalPositionCount,
 		};
 
-		if (Number(summary.totals.value) === 0)
+		if (summary.totalsByCurrency.length === 0)
 			return { account, positionCounts, source, summary: { state: "empty" } };
 
 		return {
@@ -59,8 +66,12 @@ function brokerageAccountCards(
 			source,
 			summary: {
 				portfolio: summary,
+				remainingCurrencyCount: Math.max(
+					summary.totalsByCurrency.length - VISIBLE_CURRENCY_LIMIT,
+					0,
+				),
 				state: "available",
-				totals: summary.totals,
+				totals: summary.totalsByCurrency.slice(0, VISIBLE_CURRENCY_LIMIT),
 			},
 		};
 	});

src/entities/brokerage-account/ui/BrokerageAccountList/BrokerageAccountList.module.css

@@ -65,32 +65,18 @@
 
 .summary {
 	font-variant-numeric: tabular-nums lining-nums;
-	align-items: flex-end;
+	white-space: nowrap;
-}
-
-.currencySummary {
-	min-width: 0;
 }
 
 .total {
 	color: var(--wl-color-text);
 	font-size: var(--mantine-font-size-lg);
 	line-height: var(--mantine-line-height-lg);
-	overflow-wrap: anywhere;
 }
 
 .return,
 .cashValue {
 	font-variant-numeric: tabular-nums lining-nums;
-}
-
-.return {
-	justify-content: flex-end;
-	min-width: 0;
-	overflow-wrap: anywhere;
-}
-
-.cashValue {
 	white-space: nowrap;
 }
 
@@ -152,11 +138,7 @@
 		text-align: left;
 	}
 
-	.summary {
+	.balance > div {
-		align-items: flex-start;
-	}
-
-	.return {
 		justify-content: flex-start;
 	}
 }

src/entities/brokerage-account/ui/BrokerageAccountList/BrokerageAccountList.stories.tsx

@@ -14,29 +14,36 @@ type PortfolioSummary = NonNullable<BrokerageAccount["portfolioSummary"]>;
 const rubReturn = {
 	absolute: "136900",
 	costBasis: "1103600.50",
+	currency: "RUB",
 	partial: false,
 	percent: "12.40",
 };
 
 const portfolioSummary = {
 	bondPositionCount: 12,
-	cash: { currency: "RUB", value: "82500.50" },
+	cashBalances: [
+		{ currency: "RUB", value: "82500.50" },
+		{ currency: "USD", value: "1500" },
+	],
 	fundPositionCount: 2,
 	stockPositionCount: 5,
 	structure: {
+		currencies: [{
 			categories: [
 				{ sharePercent: "55.000000", type: "STOCK", value: "682500" },
 				{ sharePercent: "25.000000", type: "BOND", value: "310500" },
 				{ sharePercent: "10.000000", type: "OTHER", value: "124200" },
 				{ sharePercent: "10.000000", type: "CASH", value: "124200" },
 			],
+			currency: "RUB",
 			hasNegativeValues: false,
 			totalValue: "1241400",
+		}],
 		unvaluedCategories: [],
 	},
 	totalPositionCount: 19,
-	totals: { currency: "RUB", value: "1240500.50" },
+	totalsByCurrency: [{ currency: "RUB", value: "1240500.50" }],
-	unrealizedReturn: rubReturn,
+	unrealizedReturnByCurrency: [rubReturn],
 } satisfies PortfolioSummary;
 
 function account(
@@ -56,25 +63,20 @@ function account(
 
 const negativeSummary: PortfolioSummary = {
 	...portfolioSummary,
-	unrealizedReturn: {
+	unrealizedReturnByCurrency: [{
 		...rubReturn,
 		absolute: "-4200",
 		percent: "-3.05",
-	},
+	}],
 };
 
 const emptySummary: PortfolioSummary = {
 	...portfolioSummary,
-	cash: { currency: "RUB", value: "0" },
+	cashBalances: [],
-	structure: {
+	structure: { currencies: [], unvaluedCategories: [] },
-		categories: [],
-		hasNegativeValues: false,
-		totalValue: "0",
-		unvaluedCategories: [],
-	},
 	totalPositionCount: 0,
-	totals: { currency: "RUB", value: "0" },
+	totalsByCurrency: [],
-	unrealizedReturn: rubReturn,
+	unrealizedReturnByCurrency: [],
 };
 
 const meta = {
@@ -92,7 +94,7 @@ const meta = {
 		docs: {
 			description: {
 				component:
-					"Карточки счетов: стоимость и доходность, деньги, структура и свежесть источника. Денежные и процентные значения остаются строками. Все примеры содержат вымышленные данные; ссылки работают только внутри MemoryRouter.",
+					"Карточки счетов: стоимость и доходность по валютам, деньги, структура и свежесть источника. Денежные и процентные значения остаются строками. Все примеры содержат вымышленные данные; ссылки работают только внутри MemoryRouter.",
 			},
 		},
 	},
@@ -106,6 +108,40 @@ type Story = StoryObj<typeof meta>;
 
 export const Normal: Story = {};
 
+export const MultiCurrency: Story = {
+	args: {
+		accounts: brokerageAccountCards([account("multi", "Мультивалютный", {
+			...portfolioSummary,
+			cashBalances: [
+				{ currency: "RUB", value: "82500.50" },
+				{ currency: "USD", value: "1500" },
+			],
+			totalsByCurrency: [
+				{ currency: "RUB", value: "1240500.50" },
+				{ currency: "USD", value: "3200" },
+				{ currency: "EUR", value: "900" },
+			],
+			unrealizedReturnByCurrency: [
+				...portfolioSummary.unrealizedReturnByCurrency,
+				{
+					absolute: "20",
+					costBasis: "3180",
+					currency: "USD",
+					partial: false,
+					percent: "2.10",
+				},
+				{
+					absolute: "0",
+					costBasis: "900",
+					currency: "EUR",
+					partial: false,
+					percent: null,
+				},
+			],
+		})]),
+	},
+};
+
 export const Negative: Story = {
 	args: {
 		accounts: brokerageAccountCards([
@@ -118,10 +154,10 @@ export const Partial: Story = {
 	args: {
 		accounts: brokerageAccountCards([account("partial", "Частичные данные", {
 			...portfolioSummary,
-			unrealizedReturn: {
+			unrealizedReturnByCurrency: [{
 				...rubReturn,
 				partial: true,
-			},
+			}],
 		})]),
 	},
 };

src/entities/brokerage-account/ui/BrokerageAccountList/BrokerageAccountList.test.tsx

@@ -14,28 +14,55 @@ type PortfolioSummary = NonNullable<BrokerageAccount["portfolioSummary"]>;
 
 const portfolioSummary = {
 	bondPositionCount: 12,
-	cash: { currency: "RUB", value: "82500.5" },
+	cashBalances: [
+		{ currency: "RUB", value: "82500.5" },
+		{ currency: "USD", value: "20" },
+	],
 	fundPositionCount: 0,
 	stockPositionCount: 5,
 	structure: {
+		currencies: [{
 			categories: [
 				{ sharePercent: "50.000000", type: "STOCK", value: "100" },
 				{ sharePercent: "30.000000", type: "BOND", value: "60" },
 				{ sharePercent: "0.000000", type: "OTHER", value: "0" },
 				{ sharePercent: "20.000000", type: "CASH", value: "40" },
 			],
+			currency: "RUB",
 			hasNegativeValues: false,
 			totalValue: "200",
+		}],
 		unvaluedCategories: [],
 	},
 	totalPositionCount: 17,
-	totals: { currency: "RUB", value: "123456789012345678901.995" },
+	totalsByCurrency: [
-	unrealizedReturn: {
+		{ currency: "RUB", value: "123456789012345678901.995" },
+		{ currency: "USD", value: "20" },
+		{ currency: "EUR", value: "5" },
+	],
+	unrealizedReturnByCurrency: [
+		{
 			absolute: "136900",
 			costBasis: "1000000",
+			currency: "RUB",
 			partial: true,
 			percent: "12.40",
 		},
+		{
+			absolute: "-4.2",
+			costBasis: "24.2",
+			currency: "USD",
+			partial: false,
+			percent: "-3.05",
+		},
+		{
+			absolute: "0",
+			costBasis: "5",
+			currency: "EUR",
+			partial: false,
+			percent: null,
+		},
+	],
 } satisfies PortfolioSummary;
 
 type BrokerageAccountCardInput = Parameters<typeof BrokerageAccountList>[0][
@@ -70,19 +97,16 @@ describe("BrokerageAccountList", () => {
 	it("renders returns, cash and structure with precise totals", () => {
 		const nullReturnSummary: PortfolioSummary = {
 			...portfolioSummary,
-			structure: {
+			cashBalances: [],
-				categories: [],
+			structure: { currencies: [], unvaluedCategories: [] },
-				hasNegativeValues: false,
+			totalsByCurrency: [{ currency: "EUR", value: "5" }],
-				totalValue: "0",
+			unrealizedReturnByCurrency: [{
-				unvaluedCategories: [],
-			},
-			totals: { currency: "RUB", value: "5" },
-			unrealizedReturn: {
 				absolute: "0",
 				costBasis: "5",
+				currency: "EUR",
 				partial: false,
 				percent: null,
-			},
+			}],
 		};
 
 		renderList(brokerageAccountCards([
@@ -94,38 +118,38 @@ describe("BrokerageAccountList", () => {
 		expect(link).toHaveAttribute("href", "/accounts/account-1");
 		expect(within(link).getByText("123 456 789 012 345 678 902,00 ₽"))
 			.toBeInTheDocument();
-		expect(within(link).getByText("+12,4 %")).toBeInTheDocument();
+		expect(within(link).getByText("Еще 1 валюта")).toBeInTheDocument();
+		expect(within(link).getByText("+12,40 %")).toBeInTheDocument();
 		expect(within(link).getByText("+136 900 ₽")).toBeInTheDocument();
+		expect(within(link).getByText("−3,05 %")).toBeInTheDocument();
+		expect(within(link).getByText("−4,2 USD")).toBeInTheDocument();
 		const nullReturnLink = screen.getByRole("link", { name: /Без доходности/ });
 		expect(within(nullReturnLink).getByText("—")).toBeInTheDocument();
 		expect(within(link).getByText("частично")).toBeInTheDocument();
 		expect(within(link).getByText("82 500,50 ₽")).toBeInTheDocument();
+		expect(within(link).getAllByText("20,00 USD")).not.toHaveLength(0);
 		expect(within(link).getByText("17 позиций")).toBeInTheDocument();
 		expect(screen.getByRole("img", {
-			name: "Структура: Акции 50,0 %; Облигации 30,0 %; "
+			name: "Структура в RUB: Акции 50 %; Облигации 30 %; "
-				+ "Другие активы 0,0 %; Свободные деньги 20,0 %",
+				+ "Другие активы 0 %; Свободные деньги 20 %",
 		})).toBeInTheDocument();
-		const stockLegend = within(link).getByText(/Акции 50,0 %/);
+		const stockLegend = within(link).getByText(/Акции 50 %/);
-		expect(stockLegend).toHaveTextContent("● Акции 50,0 %");
+		expect(stockLegend).toHaveTextContent("● Акции 50 %");
 		// eslint-disable-next-line testing-library/no-node-access -- The legend is aria-hidden, so only DOM traversal reaches its container.
 		expect(stockLegend.parentElement).toHaveAttribute("aria-hidden", "true");
-		expect(within(link).queryByText(/Другие активы 0,0 %/))
+		expect(within(link).queryByText(/Другие активы 0 %/)).not.toBeInTheDocument();
-			.not.toBeInTheDocument();
 		expect(link).toHaveTextContent("По данным брокера");
-		expect(link).toHaveTextContent("Структура: Акции 100");
+		expect(link).toHaveTextContent("Структура RUB: Акции 100");
 	});
 
 	it("preserves empty, unavailable and stale states", () => {
 		const emptySummary: PortfolioSummary = {
 			...portfolioSummary,
-			structure: {
+			cashBalances: [],
-				categories: [],
+			structure: { currencies: [], unvaluedCategories: [] },
-				hasNegativeValues: false,
-				totalValue: "0",
-				unvaluedCategories: [],
-			},
 			totalPositionCount: 0,
-			totals: { currency: "RUB", value: "0" },
+			totalsByCurrency: [],
+			unrealizedReturnByCurrency: [],
 		};
 
 		const cards = brokerageAccountCards([

src/entities/brokerage-account/ui/BrokerageAccountList/BrokerageAccountList.tsx

@@ -15,11 +15,6 @@ import classes from "./BrokerageAccountList.module.css";
 const DECIMAL_PART_COUNT = 2;
 const STRUCTURE_CATEGORY_ORDER = ["STOCK", "BOND", "OTHER", "CASH"] as const;
 
-const percentFormatter = new Intl.NumberFormat("ru-RU", {
-	maximumFractionDigits: 1,
-	minimumFractionDigits: 1,
-});
-
 type AvailableSummary = Extract<
 	BrokerageAccountCard["summary"],
 	{ state: "available" }
@@ -34,23 +29,28 @@ type BrokerageAccountSummaryProps = {
 type PortfolioSummary = AvailableSummary["portfolio"];
 
 type ReturnValueProps = {
-	item: PortfolioSummary["unrealizedReturn"];
+	item: PortfolioSummary["unrealizedReturnByCurrency"][number];
 };
 
-type StructureCurrency = PortfolioSummary["structure"];
+type StructureCurrency = PortfolioSummary["structure"]["currencies"][number];
 
 function formatPercent(value: null | string) {
 	if (value === null) return "—";
 
-	const rounded = percentFormatter.format(Math.abs(Number(value)));
+	const formatted = `${value.replace(".", ",")}\u{A0}%`;
-	let sign = "";
+	if (isZero(value))
-	if (rounded !== "0,0") sign = value.startsWith("-") ? "−" : "+";
+		return value.startsWith("-") ? formatted.slice(1) : formatted;
 
-	return `${sign}${rounded}\u{A0}%`;
+	return value.startsWith("-") ? `−${formatted.slice(1)}` : `+${formatted}`;
 }
 
 function formatStructurePercent(value: string) {
-	return percentFormatter.format(Number(value));
+	let trimmed = value;
+	while (trimmed.includes(".") && trimmed.endsWith("0"))
+		trimmed = trimmed.slice(0, -1);
+	if (trimmed.endsWith(".")) trimmed = trimmed.slice(0, -1);
+
+	return trimmed.replace(".", ",");
 }
 
 function isZero(value: string) {
@@ -65,23 +65,27 @@ const ReturnValue: FC<ReturnValueProps> = (props) => {
 	const { t } = useTranslation();
 	const { item } = props;
 
-	const displayedPercent = formatPercent(item.percent);
+	const isNegative = item.percent !== null
-	const isNegative = displayedPercent.startsWith("−");
+		&& item.percent.startsWith("-")
-	const isPositive = displayedPercent.startsWith("+");
+		&& !isZero(item.percent);
+
+	const isPositive = item.percent !== null
+		&& !item.percent.startsWith("-")
+		&& !isZero(item.percent);
 
 	let toneClass = classes.neutral;
 	if (isNegative) toneClass = classes.negative;
 	else if (isPositive) toneClass = classes.positive;
 
 	return (
-		<Group className={classes.return} gap="xs" wrap="wrap">
+		<Group className={classes.return} gap="xs" wrap="nowrap">
 			<Text className={toneClass} fw={700} size="sm">
-				{displayedPercent}
+				{formatPercent(item.percent)}
 			</Text>
 
 			<Text className={toneClass} size="sm">
 				{formatMoney(
-					{ currency: "RUB", value: item.absolute },
+					{ currency: item.currency, value: item.absolute },
 					{ withSign: true },
 				)}
 			</Text>
@@ -119,6 +123,7 @@ const StructureBar: FC<StructureBarProps> = (props) => {
 	}).join("; ");
 
 	const label = t("accounts.structure.label", {
+		currency: props.item.currency,
 		value: description,
 	});
 
@@ -195,25 +200,51 @@ const BrokerageAccountSummary: FC<BrokerageAccountSummaryProps> = (props) => {
 
 	return (
 		<Stack className={classes.balance} gap="xs">
-			<Stack className={classes.summary} gap="sm">
+			<Group align="flex-start" gap="lg" justify="flex-end" wrap="nowrap">
-				<Stack className={classes.currencySummary} gap={2}>
+				<Stack className={classes.summary} gap={4}>
-					<Text className={classes.total} fw={700}>
+					{summary.totals.map(total => (
-						{formatMoney(summary.totals, { withRoundedCents: true })}
+						<Text className={classes.total} fw={700} key={total.currency}>
+							{formatMoney(total, { withRoundedCents: true })}
 						</Text>
+					))}
 
-					<ReturnValue item={summary.portfolio.unrealizedReturn} />
+					{!!summary.remainingCurrencyCount && (
-				</Stack>
+						<Text c="dimmed" size="sm">
+							{t("accounts.remainingCurrencies", {
+								count: summary.remainingCurrencyCount,
+							})}
+						</Text>
+					)}
 				</Stack>
 
+				<Stack gap={4}>
+					{summary.totals.map((total) => {
+						const item = summary.portfolio.unrealizedReturnByCurrency.find(
+							returnItem => returnItem.currency === total.currency,
+						);
+
+						return item
+							? <ReturnValue item={item} key={total.currency} />
+							: null;
+					})}
+				</Stack>
+			</Group>
+
+			{summary.portfolio.cashBalances.length > 0 && (
 				<Group className={classes.cash} gap="xs" justify="flex-end">
 					<Text c="dimmed" size="xs">
 						{t("accounts.cash")}
 					</Text>
 
-				<Text className={classes.cashValue} size="sm">
+					<Stack gap={0}>
-					{formatMoney(summary.portfolio.cash, { withRoundedCents: true })}
+						{summary.portfolio.cashBalances.map(cash => (
+							<Text className={classes.cashValue} key={cash.currency} size="sm">
+								{formatMoney(cash, { withRoundedCents: true })}
 							</Text>
+						))}
+					</Stack>
 				</Group>
+			)}
 		</Stack>
 	);
 };
@@ -260,31 +291,39 @@ const AccountDescription: FC<AccountDescriptionProps> = (props) => {
 	const { account, summary } = props.account;
 	if (summary.state !== "available") return null;
 
-	const returns = [t("accounts.description.return", {
+	const returns = summary.portfolio.unrealizedReturnByCurrency.map(item =>
+		t("accounts.description.return", {
 			absolute: formatMoney(
-			{ currency: "RUB", value: summary.portfolio.unrealizedReturn.absolute },
+				{ currency: item.currency, value: item.absolute },
 				{ withSign: true },
 			),
-		percent: formatPercent(summary.portfolio.unrealizedReturn.percent),
+			currency: item.currency,
-	})];
+			percent: formatPercent(item.percent),
+		}),
+	);
 
-	const structures = (() => {
+	const structures = summary.portfolio.structure.currencies.map((item) => {
-		const categories = summary.portfolio.structure.categories.map(category =>
+		const categories = item.categories.map(category =>
 			t("accounts.description.structureCategory", {
 				category: t(portfolioCategoryPresentation[category.type].label),
 				value: formatMoney(
-					{ currency: "RUB", value: category.value },
+					{ currency: item.currency, value: category.value },
 					{ withRoundedCents: true },
 				),
 			}),
 		).join(", ");
 
-		return t("accounts.description.structure", { value: categories });
+		return t("accounts.description.structure", {
-	})();
+			currency: item.currency,
+			value: categories,
+		});
+	});
 
-	const hasPartialReturn = summary.portfolio.unrealizedReturn.partial;
+	const hasPartialReturn = summary.portfolio.unrealizedReturnByCurrency.some(
+		item => item.partial,
+	);
 
-	const details = [returns, structures].join(". ");
+	const details = [...returns, ...structures].join(". ");
 
 	return (
 		<VisuallyHidden>
@@ -293,7 +332,8 @@ const AccountDescription: FC<AccountDescriptionProps> = (props) => {
 				type: t(accountTypeKey(account.type)),
 			})}
 			{t("accounts.description.currentValue", {
-				value: formatMoney(summary.portfolio.totals),
+				value: summary.portfolio.totalsByCurrency
+					.map(total => formatMoney(total)).join(", "),
 			})}
 			{details ? `${details}. ` : ""}
 			{hasPartialReturn ? t("accounts.brokerDescription") : ""}
@@ -333,7 +373,9 @@ const BrokerageAccountList: FC<BrokerageAccountListProps> = (props) => {
 
 						{summary.state === "available" && (
 							<Stack className={classes.structure} gap={4}>
-								<StructureBar item={summary.portfolio.structure} />
+								{summary.portfolio.structure.currencies.map(item => (
+									<StructureBar item={item} key={item.currency} />
+								))}
 							</Stack>
 						)}
 

src/entities/brokerage-event/ui/BrokerageEventGroup.test.tsx

@@ -97,13 +97,13 @@ describe("BrokerageEventGroup", () => {
 		expect(screen.getByText("0,00 ₽")).toBeInTheDocument();
 	});
 
-	it("sums forecast totals exactly", () => {
+	it("shows separate forecast totals per currency without conversion", () => {
 		renderGroup([
-			event({ id: "broker", name: "Брокерский" }, "10"),
+			event({ id: "broker", name: "Брокерский" }, "10", "USD"),
 			event({ id: "iis", name: "ИИС" }, "200"),
 		]);
 
-		expect(screen.getByRole("list", { name: /210 ₽/ }))
+		expect(screen.getByRole("list", { name: /10 USD.*200 ₽/ }))
 			.toBeInTheDocument();
 	});
 

src/entities/performance/api/usePerformance.ts

@@ -1,20 +0,0 @@
-import { apiQueryClient, type paths, useAuthenticatedQuery } from "@/shared/api";
-
-type Performance = NonNullable<
-	paths["/api/v1/brokerage-accounts/{accountId}/performance"]["get"]["responses"][200]["content"]["application/json"]["data"]
->;
-
-function usePerformance(accountId: string) {
-	return useAuthenticatedQuery({
-		meta: { accessGroup: "brokerage" },
-		...apiQueryClient.queryOptions(
-			"get",
-			"/api/v1/brokerage-accounts/{accountId}/performance",
-			{ params: { path: { accountId } } },
-		),
-		enabled: Boolean(accountId),
-		staleTime: 30_000,
-	});
-}
-
-export { type Performance, usePerformance };

src/entities/performance/index.ts

@@ -1 +0,0 @@
-export { type Performance, usePerformance } from "./api/usePerformance";

src/entities/portfolio/model/display.ts

@@ -2,7 +2,7 @@ import type { Portfolio } from "../api/usePortfolio";
 
 const PERCENT_SCALE = 100;
 
-type Money = Portfolio["totals"];
+type Money = Portfolio["totalsByCurrency"][number];
 
 function formatShare(
 	numerator: Money | null,

src/features/instrument-details/model/section.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it } from "vitest";
 
 import { resource } from "@/test/resource";
 
@@ -76,29 +76,4 @@ describe("instrument source and transport presentation", () => {
 			loading: false,
 		});
 	});
-
-	it("carries the retry of an exhausted read and only of that read", () => {
-		const refetch = vi.fn(() => Promise.resolve());
-
-		const state = section({
-			data: { rows: [] },
-			error: { code: "TBANK_UNAVAILABLE", status: 503 },
-			isError: true,
-			isFetching: false,
-			refetch,
-		});
-
-		expect(state.readRetry?.exhausted).toBe(true);
-		state.readRetry?.onRetry();
-		expect(refetch).toHaveBeenCalledOnce();
-	});
-
-	it("offers no retry for access loss or a healthy read", () => {
-		const base = { data: undefined, isFetching: false, refetch: vi.fn() };
-
-		expect(section({ ...base, error: { code: "NOT_FOUND" }, isError: true })
-			.readRetry?.exhausted).toBe(false);
-		expect(section({ ...base, error: null, isError: false })
-			.readRetry?.exhausted).toBe(false);
-	});
 });

src/features/instrument-details/model/section.ts

@@ -1,11 +1,10 @@
-import { type InvestmentResourceMeta, readRetry } from "@/shared/api";
+import type { InvestmentResourceMeta } from "@/shared/api";
 
 type SectionState = {
 	error: boolean;
 	hasData: boolean;
 	loading: boolean;
 	partial?: boolean;
-	readRetry?: ReturnType<typeof readRetry>;
 };
 
 function hasSectionData(data: unknown) {
@@ -14,11 +13,8 @@ function hasSectionData(data: unknown) {
 
 function section(query: {
 	data: unknown;
-	error?: unknown;
 	isError: boolean;
-	isFetching?: boolean;
 	meta?: InvestmentResourceMeta;
-	refetch?: () => Promise<unknown>;
 }): SectionState {
 	const isError = query.isError || query.meta?.lastAttempt.state === "failed";
 	const hasData = hasSectionData(query.data);
@@ -28,17 +24,6 @@ function section(query: {
 		hasData,
 		loading: !hasData && !isError,
 		partial: query.meta?.completeness === "incomplete",
-		// Each section retries only its own GET, so sections recover independently.
-		readRetry: query.refetch
-			? readRetry([
-					{
-						error: query.error,
-						isError: query.isError,
-						isFetching: query.isFetching ?? false,
-						refetch: query.refetch,
-					},
-				])
-			: undefined,
 	};
 }
 

src/features/instrument-details/ui/InstrumentChart/InstrumentChart.vm.ts

@@ -19,6 +19,7 @@ function useInstrumentChartVm(props: InstrumentChartProps) {
 	const average = vm.position?.averagePurchasePrice;
 
 	const averageLine = average && props.priceUnit !== "percent"
+		&& average.currency === vm.candles?.currency
 		? Number(average.value)
 		: null;
 
@@ -46,7 +47,7 @@ function useInstrumentChartVm(props: InstrumentChartProps) {
 			currency:
 				props.priceUnit === "percent"
 					? t("bond.percentOfNominal")
-					: "₽",
+					: (vm.candles?.currency ?? ""),
 		},
 	);
 

src/features/instrument-details/ui/InstrumentSection.view.tsx

@@ -12,8 +12,6 @@ import {
 import { LoadingSkeleton } from "@wealthledger/ui";
 import { useTranslation } from "react-i18next";
 
-import { ReadRetry } from "@/shared/ui";
-
 import type { SectionState } from "../model/section";
 
 import classes from "./InstrumentDetails.module.css";
@@ -83,8 +81,6 @@ const InstrumentSection: FC<InstrumentSectionProps> = (props) => {
 				</Alert>
 			)}
 
-			{!!props.state.readRetry && <ReadRetry {...props.state.readRetry} />}
-
 			{sectionContent}
 		</Paper>
 	);

src/features/tbank-connection/model/connection-boundary.ts

@@ -2,18 +2,19 @@ import type { QueryClient } from "@tanstack/react-query";
 
 import {
 	apiQueryClient,
-	isGetUnder,
 	type paths,
 } from "@/shared/api";
 
 type TbankConnectionStatus
 	= paths["/api/v1/tbank-connection"]["get"]["responses"][200]["content"]["application/json"];
 
-const investmentGetPredicate = isGetUnder([
+function isInvestmentPath(path: string) {
+	return [
 		"/api/v1/brokerage-accounts",
 		"/api/v1/stocks",
 		"/api/v1/bonds",
-]);
+	].some(root => path === root || path.startsWith(`${root}/`));
+}
 
 const tbankConnectionQueryOptions = () =>
 	apiQueryClient.queryOptions("get", "/api/v1/tbank-connection");
@@ -26,7 +27,15 @@ function commitTbankConnectionBoundary(
 ) {
 	queryClient.setQueryData(tbankConnectionQueryKey, status);
 	void queryClient.resetQueries({
-		predicate: ({ queryKey }) => investmentGetPredicate(queryKey),
+		predicate: ({ queryKey }) => {
+			const [method, path] = queryKey;
+
+			return (
+				method === "get"
+				&& typeof path === "string"
+				&& isInvestmentPath(path)
+			);
+		},
 	});
 }
 

src/features/tbank-connection/model/screen-sync.test.tsx

@@ -10,9 +10,6 @@ import { server } from "@/test/server";
 
 import { useScreenSync } from "../index";
 
-const TRANSPORT_ATTEMPTS = 3;
-const TRANSPORT_RECOVERY_MS = 3000;
-
 function auth() {
 	configureAuthClient({
 		accessToken: () => "synthetic",
@@ -31,13 +28,11 @@ describe("read-only screen synchronization", () => {
 				gets += 1;
 				syncModes.push(new URL(request.url).searchParams.get("sync"));
 
-				// The transport retries a transient read twice (1 s, 2 s) on its own.
+				return gets === 1
-				return gets <= TRANSPORT_ATTEMPTS
 					? HttpResponse.json({ code: "TBANK_UNAVAILABLE" }, { status: 503 })
 					: HttpResponse.json(resource([]));
 			}),
 		);
-		vi.useFakeTimers();
 
 		const { result } = renderHook(
 			() => {
@@ -51,26 +46,12 @@ describe("read-only screen synchronization", () => {
 			{ wrapper: createQueryWrapper().wrapper },
 		);
 
-		try {
+		await waitFor(() => expect(gets).toBe(1));
-			// Exhaust the transport back-off so the query settles in error.
-			await vi.waitFor(async () => {
-				await act(() => vi.advanceTimersByTimeAsync(TRANSPORT_RECOVERY_MS));
-				expect(result.current.sync.transportError).toBe(true);
-			});
-			expect(gets).toBe(TRANSPORT_ATTEMPTS);
-
 		await act(async () => result.current.sync.retry());
-			await vi.waitFor(async () => {
+		await waitFor(() => expect(result.current.accounts.data).toEqual([]));
-				await act(() => vi.advanceTimersByTimeAsync(0));
-				expect(result.current.accounts.data).toEqual([]);
-			});
-		}
-		finally {
-			vi.useRealTimers();
-		}
 
-		expect(gets).toBe(TRANSPORT_ATTEMPTS + 1);
+		expect(gets).toBe(2);
-		expect(syncModes).toEqual(Array.from({ length: gets }, () => null));
+		expect(syncModes).toEqual([null, null]);
 	});
 
 	it("refreshes the currently open resources together", async () => {

src/features/tbank-connection/ui/InvestmentRefreshState/InvestmentRefreshState.stories.tsx

@@ -23,7 +23,7 @@ const meta = {
 	},
 	render: arguments_ => (
 		<Stack>
-			<Text>125 000,50 ₽</Text>
+			<Text>125 000,50 ₽ · 320 USD</Text>
 
 			<InvestmentRefreshState {...arguments_} />
 		</Stack>

src/features/tbank-connection/ui/TbankConnectionSection/TbankConnectionSection.tsx

@@ -4,16 +4,16 @@ import {
 	TbankConnectionError,
 	TbankConnectionLoading,
 } from "./TbankConnectionSection.view";
-import { useTbankConnectionSectionVm } from "./TbankConnectionSection.vm";
+import { useTbankConnectionViewModel } from "./TbankConnectionSection.vm";
 import { TbankConnectionSectionLoaded } from "./TbankConnectionSectionLoaded";
 
 const TbankConnectionSection: FC = () => {
-	const vm = useTbankConnectionSectionVm();
+	const viewModel = useTbankConnectionViewModel();
-	if (vm.state === "loading") return <TbankConnectionLoading />;
+	if (viewModel.state === "loading") return <TbankConnectionLoading />;
 
-	return vm.state === "error"
+	return viewModel.state === "error"
-		? <TbankConnectionError retry={vm.retry} />
+		? <TbankConnectionError retry={viewModel.retry} />
-		: <TbankConnectionSectionLoaded {...vm} />;
+		: <TbankConnectionSectionLoaded {...viewModel} />;
 };
 
 export { TbankConnectionSection };

src/features/tbank-connection/ui/TbankConnectionSection/TbankConnectionSection.vm.ts

@@ -2,7 +2,7 @@ import { useAuthenticatedQuery } from "@/shared/api";
 
 import { tbankConnectionQueryOptions } from "../../model/connection-boundary";
 
-function useTbankConnectionSectionVm() {
+function useTbankConnectionViewModel() {
 	const status = useAuthenticatedQuery({
 		...tbankConnectionQueryOptions(),
 	});
@@ -22,4 +22,4 @@ function useTbankConnectionSectionVm() {
 	};
 }
 
-export { useTbankConnectionSectionVm };
+export { useTbankConnectionViewModel };

src/pages/account-events/ui/AccountEventsPage/AccountEventsPage.filters.test.tsx

@@ -26,7 +26,7 @@ import { resource } from "@/test/resource";
 import { server } from "@/test/server";
 
 import { AccountEventsPage } from "./AccountEventsPage";
-import { useAccountEventsPageVm } from "./AccountEventsPage.vm";
+import { useAccountEventsPageViewModel } from "./AccountEventsPage.vm";
 
 const Navigation: FC = () => {
 	const location = useLocation();
@@ -100,7 +100,7 @@ describe("Upcoming event date filters", () => {
 		);
 		const queryClient = createTestQueryClient();
 
-		const { result } = renderHook(() => useAccountEventsPageVm(), {
+		const { result } = renderHook(() => useAccountEventsPageViewModel(), {
 			wrapper: ({ children }) => (
 				<QueryClientProvider client={queryClient}>
 					<MemoryRouter initialEntries={["?from=2099-02-01"]}>
@@ -146,7 +146,7 @@ describe("Upcoming event date filters", () => {
 			const queryClient = createTestQueryClient();
 
 			const { result } = renderHook(
-				() => useAccountEventsPageVm(),
+				() => useAccountEventsPageViewModel(),
 				{
 					wrapper: ({ children }) => (
 						<QueryClientProvider client={queryClient}>
@@ -176,11 +176,7 @@ describe("Upcoming event date filters", () => {
 					({ request }) => {
 						searches.push(new URL(request.url).search);
 
-						return HttpResponse.json(resource({
+						return HttpResponse.json(resource({ events: [] }));
-							calculatedAt: "2026-08-14T00:00:00Z",
-							events: [],
-							window: { from: "2026-08-14", to: "2026-09-13" },
-						}));
 					},
 				),
 			);
@@ -227,11 +223,7 @@ describe("Upcoming event date filters", () => {
 					"*/api/v1/brokerage-accounts/:accountId/events",
 					({ request }) =>
 						new URL(request.url).searchParams.get("from") === defaultFrom
-							? HttpResponse.json(resource({
+							? HttpResponse.json(resource({ events: [] }))
-									calculatedAt: "2026-08-14T00:00:00Z",
-									events: [],
-									window: { from: "2026-08-14", to: "2026-09-13" },
-								}))
 							: HttpResponse.json({ code: "VALIDATION_ERROR" }, { status: 400 }),
 				),
 			);
@@ -263,8 +255,7 @@ describe("Upcoming event date filters", () => {
 								accountId,
 								calculatedAt: "2099-01-01T00:00:00Z",
 								events: [],
-								incomeTotal: { currency: "RUB", value: "0" },
+								incomeTotalsByCurrency: [],
-								window: { from: "2099-01-01", to: "2099-01-31" },
 							}),
 						);
 					},
@@ -273,7 +264,6 @@ describe("Upcoming event date filters", () => {
 			renderEvents(accountId, ["?from=2026-02-01&to=2026-02-28"]);
 			const from = await screen.findByLabelText("Период");
 			expect(from).toHaveTextContent("01.02.2026 – 28.02.2026");
-			expect(screen.getByText(/Прогноз от .* на 01\.01\.2099 – 31\.01\.2099/)).toBeVisible();
 			expect(screen.getByRole("button", { name: "Применить" })).toBeDisabled();
 			expect(searches).toEqual(["?from=2026-02-01&to=2026-02-28"]);
 
@@ -330,7 +320,7 @@ describe("Upcoming event date filters", () => {
 			expect(screen.getByLabelText("URL")).toBeEmptyDOMElement();
 			expect(screen.getByRole("button", { name: "Применить" })).toBeDisabled();
 			expect(
-				screen.getByText("На выбранный период предстоящих событий не найдено"),
+				screen.getByText("За выбранный период событий не найдено"),
 			).toBeVisible();
 		},
 	);
@@ -353,7 +343,7 @@ it("retains the previous complete forecast when its source refresh fails", async
 	];
 
 	const snapshot = resource(
-		{ events, incomeTotal: { currency: "RUB", value: "123.45" } },
+		{ events, incomeTotalsByCurrency: [{ currency: "RUB", value: "123.45" }] },
 		{
 			lastAttempt: {
 				finishedAt: "2026-08-14T00:01:00Z",
@@ -371,7 +361,7 @@ it("retains the previous complete forecast when its source refresh fails", async
 	);
 	const queryClient = createTestQueryClient();
 
-	const { result } = renderHook(() => useAccountEventsPageVm(), {
+	const { result } = renderHook(() => useAccountEventsPageViewModel(), {
 		wrapper: ({ children }) => (
 			<QueryClientProvider client={queryClient}>
 				<MemoryRouter initialEntries={["/accounts/all/events"]}>

src/pages/account-events/ui/AccountEventsPage/AccountEventsPage.retry.test.tsx

@@ -1,167 +0,0 @@
-import { MantineProvider } from "@mantine/core";
-import { QueryClientProvider } from "@tanstack/react-query";
-import { fireEvent, render, screen, waitFor } from "@testing-library/react";
-import { http, HttpResponse } from "msw";
-import { MemoryRouter, Route, Routes } from "react-router";
-import { describe, expect, it, vi } from "vitest";
-
-import { configureAuthClient } from "@/shared/api";
-import { createTestQueryClient } from "@/test/query";
-import { resource } from "@/test/resource";
-import { server } from "@/test/server";
-
-import { AccountEventsPage } from "./AccountEventsPage";
-
-// Automatic read retries wait 1s + 2s before the failure is final.
-const RETRIES_EXHAUSTED_MS = 6000;
-const TEST_MS = 10_000;
-
-const snapshot = resource({
-	accountId: "account-1",
-	calculatedAt: "2026-08-14T00:00:00Z",
-	events: [
-		{
-			date: "2026-10-01",
-			dateKind: "event",
-			displayName: "Synthetic coupon",
-			figi: null,
-			instrumentUid: null,
-			isin: null,
-			logoName: null,
-			projectedAmount: { currency: "RUB", value: "123.45" },
-			ticker: "SYN",
-			type: "coupon",
-		},
-	],
-	incomeTotal: { currency: "RUB", value: "123.45" },
-	window: { from: "2026-08-14", to: "2026-09-13" },
-});
-
-function renderEvents() {
-	configureAuthClient({
-		accessToken: () => "token",
-		clear: vi.fn(),
-		refresh: () => Promise.resolve(true),
-	});
-	const queryClient = createTestQueryClient();
-
-	render(
-		<QueryClientProvider client={queryClient}>
-			<MantineProvider env="test">
-				<MemoryRouter initialEntries={["/accounts/account-1/events"]}>
-					<Routes>
-						<Route
-							element={<AccountEventsPage />}
-							path="/accounts/:accountId/events"
-						/>
-					</Routes>
-				</MemoryRouter>
-			</MantineProvider>
-		</QueryClientProvider>,
-	);
-
-	return { queryClient };
-}
-
-describe("AccountEventsPage read retry", () => {
-	it(
-		"offers retry after an initial failure and recovers in place",
-		{ timeout: TEST_MS },
-		async () => {
-			let isFailing = true;
-			let requests = 0;
-			server.use(
-				http.get("*/api/v1/brokerage-accounts/:accountId/events", () => {
-					requests += 1;
-
-					return isFailing
-						? HttpResponse.json({ code: "TBANK_UNAVAILABLE" }, { status: 503 })
-						: HttpResponse.json(snapshot);
-				}),
-			);
-			renderEvents();
-
-			const retry = await screen.findByRole(
-				"button",
-				{ name: "Повторить" },
-				{ timeout: RETRIES_EXHAUSTED_MS },
-			);
-
-			expect(requests).toBe(3);
-
-			isFailing = false;
-			fireEvent.click(retry);
-
-			expect(await screen.findByText("Купон · Synthetic coupon")).toBeInTheDocument();
-			expect(requests).toBe(4);
-		},
-	);
-
-	it(
-		"keeps cached events, warns and retries the same GET",
-		{ timeout: TEST_MS },
-		async () => {
-			let isFailing = false;
-			let requests = 0;
-			let imports = 0;
-			server.use(
-				http.post("*/api/v1/tbank-sync", () => {
-					imports += 1;
-
-					return HttpResponse.json({}, { status: 202 });
-				}),
-				http.get("*/api/v1/brokerage-accounts/:accountId/events", () => {
-					requests += 1;
-
-					return isFailing
-						? HttpResponse.json({ code: "TBANK_UNAVAILABLE" }, { status: 503 })
-						: HttpResponse.json(snapshot);
-				}),
-			);
-			const { queryClient } = renderEvents();
-			await screen.findByText("Купон · Synthetic coupon");
-			expect(screen.getByText(/Прогноз от .* на 14\.08\.2026 – 13\.09\.2026/)).toBeVisible();
-			expect(screen.queryByRole("button", { name: "Повторить" }))
-				.not.toBeInTheDocument();
-
-			isFailing = true;
-			void queryClient.invalidateQueries({
-				queryKey: ["get", "/api/v1/brokerage-accounts/{accountId}/events"],
-			});
-
-			const retry = await screen.findByRole(
-				"button",
-				{ name: "Повторить" },
-				{ timeout: RETRIES_EXHAUSTED_MS },
-			);
-
-			expect(screen.getByText("Не удалось обновить данные")).toBeInTheDocument();
-			expect(screen.getByText("Купон · Synthetic coupon")).toBeInTheDocument();
-			expect(screen.getByText(/Прогноз от .* на 14\.08\.2026 – 13\.09\.2026/)).toBeVisible();
-			expect(requests).toBe(4);
-
-			isFailing = false;
-			fireEvent.click(retry);
-
-			await waitFor(() =>
-				expect(screen.queryByText("Не удалось обновить данные"))
-					.not.toBeInTheDocument());
-			expect(requests).toBe(5);
-			expect(imports).toBe(0);
-		},
-	);
-
-	it("does not offer a plain retry when the account is gone", async () => {
-		server.use(
-			http.get("*/api/v1/brokerage-accounts/:accountId/events", () =>
-				HttpResponse.json({ code: "NOT_FOUND" }, { status: 404 })),
-		);
-		renderEvents();
-
-		await waitFor(() =>
-			expect(screen.queryByRole("heading", { name: "Загрузка" }))
-				.not.toBeInTheDocument());
-		expect(screen.queryByRole("button", { name: "Повторить" }))
-			.not.toBeInTheDocument();
-	});
-});

src/pages/account-events/ui/AccountEventsPage/AccountEventsPage.test.tsx

@@ -47,7 +47,6 @@ describe("AccountEventsPage", () => {
 					accountId: "account",
 					calculatedAt: "2026-08-14T00:00:00Z",
 					events: [],
-					window: { from: "2026-08-14", to: "2026-09-13" },
 				},
 				isError: false,
 				isLoading: false,
@@ -137,7 +136,6 @@ describe("AccountEventsPage", () => {
 							type: "offer",
 						},
 					],
-					window: { from: "2026-08-14", to: "2026-09-13" },
 				},
 				isError: false,
 				isLoading: false,
@@ -171,18 +169,15 @@ describe("AccountEventsPage", () => {
 		expect(screen.getAllByText("O")).toHaveLength(2);
 	});
 
-	it("renders empty and error states with retry", async () => {
+	it("renders empty and quiet error states", async () => {
 		const { rerender } = renderPage();
 		expect(
-			screen.getByText("На выбранный период предстоящих событий не найдено"),
+			screen.getByText("За выбранный период событий не найдено"),
 		).toBeInTheDocument();
 		query.mockReturnValue({
 			data: undefined,
-			error: { code: "TBANK_UNAVAILABLE", status: 503 },
 			isError: true,
-			isFetching: false,
 			isLoading: false,
-			refetch: vi.fn(),
 		} as never);
 		rerender(
 			<MantineProvider>
@@ -192,7 +187,7 @@ describe("AccountEventsPage", () => {
 			</MantineProvider>,
 		);
 		expect(await screen.findByRole("button", { name: "Сбросить" })).toBeVisible();
-		expect(screen.getByRole("button", { name: "Повторить" })).toBeVisible();
+		expect(screen.queryByRole("button", { name: "Повторить" })).not.toBeInTheDocument();
 	});
 
 	it("shows a structural busy state before events are available", () => {
@@ -239,7 +234,7 @@ describe("AccountEventsPage", () => {
 			"true",
 		);
 		expect(
-			screen.queryByText("На выбранный период предстоящих событий не найдено"),
+			screen.queryByText("За выбранный период событий не найдено"),
 		).not.toBeInTheDocument();
 	});
 
@@ -278,7 +273,6 @@ describe("AccountEventsPage", () => {
 				accountId: "all",
 				calculatedAt: "2026-08-14T00:00:00Z",
 				events: [...events],
-				window: { from: "2026-08-14", to: "2026-09-13" },
 			},
 			isError: false,
 			isLoading: false,

src/pages/account-events/ui/AccountEventsPage/AccountEventsPage.tsx

@@ -1,17 +1,17 @@
 import type { FC } from "react";
 
-import { useAccountEventsPageVm } from "./AccountEventsPage.vm";
+import { useAccountEventsPageViewModel } from "./AccountEventsPage.vm";
 import { AccountEventsPageError } from "./components/AccountEventsPageError.view";
 import { AccountEventsPageLoaded } from "./components/AccountEventsPageLoaded.view";
 import { AccountEventsPageLoading } from "./components/AccountEventsPageLoading.view";
 
 const AccountEventsPage: FC = () => {
-	const vm = useAccountEventsPageVm();
+	const viewModel = useAccountEventsPageViewModel();
-	if (vm.state === "loading") return <AccountEventsPageLoading />;
+	if (viewModel.state === "loading") return <AccountEventsPageLoading />;
 
-	return vm.state === "error"
+	return viewModel.state === "error"
-		? <AccountEventsPageError {...vm} />
+		? <AccountEventsPageError {...viewModel} />
-		: <AccountEventsPageLoaded {...vm} />;
+		: <AccountEventsPageLoaded {...viewModel} />;
 };
 
 export { AccountEventsPage };

src/pages/account-events/ui/AccountEventsPage/AccountEventsPage.vm.ts

@@ -1,12 +1,13 @@
 import { useState } from "react";
 import { useParams } from "react-router";
 
+import type { InvestmentResourceMeta } from "@/shared/api";
+
 import {
 	type BrokerageEvent,
 	useBrokerageEvents,
 } from "@/entities/brokerage-event";
 import { useScreenSync } from "@/features/tbank-connection";
-import { type InvestmentResourceMeta, readRetry } from "@/shared/api";
 import {
 	defaultPeriod,
 	isValidPeriod,
@@ -18,7 +19,6 @@ import {
 type AccountEventsPageViewModel
 	= | {
 		allAccounts: boolean;
-		calculatedAt: string;
 		canApply: boolean;
 		draftPeriod: [null | string, null | string];
 		events: BrokerageEvent[];
@@ -28,20 +28,14 @@ type AccountEventsPageViewModel
 		onPeriodPopoverOpen: () => void;
 		onReset: () => void;
 		partial?: boolean;
-		readRetry: ReturnType<typeof readRetry>;
 		source?: InvestmentResourceMeta;
 		state: "loaded";
 		totalVisible: boolean;
-		window: { from: string; to: string };
-	}
-	| {
-		onReset: () => void;
-		readRetry: ReturnType<typeof readRetry>;
-		state: "error";
 	}
+	| { onReset: () => void; state: "error" }
 	| { state: "loading" };
 
-function useAccountEventsPageVm(): AccountEventsPageViewModel {
+function useAccountEventsPageViewModel(): AccountEventsPageViewModel {
 	const { accountId = "" } = useParams();
 
 	const {
@@ -89,8 +83,6 @@ function useAccountEventsPageVm(): AccountEventsPageViewModel {
 		isFetching: events.isFetching,
 	});
 
-	const retry = readRetry([events]);
-
 	if (availability === "loading" && events.isLoading)
 		return { state: "loading" };
 
@@ -102,17 +94,15 @@ function useAccountEventsPageVm(): AccountEventsPageViewModel {
 	if ((events.isError || events.meta?.lastAttempt.state === "failed") && !events.data)
 		return {
 			onReset,
-			readRetry: retry,
 			state: "error",
 		};
 	if (!events.data)
 		return availability === "unavailable"
-			? { onReset, readRetry: retry, state: "error" }
+			? { onReset, state: "error" }
 			: { state: "loading" };
 
 	return {
 		allAccounts: accountId === "all",
-		calculatedAt: events.data.calculatedAt,
 		canApply:
 			(draftFrom !== appliedFrom || draftTo !== appliedTo)
 			&& isValidPeriod(draftFrom, draftTo),
@@ -132,12 +122,10 @@ function useAccountEventsPageVm(): AccountEventsPageViewModel {
 		onPeriodPopoverOpen: () => setMinDate(moscowDate(new Date())),
 		onReset,
 		partial: events.meta?.completeness === "incomplete",
-		readRetry: retry,
 		source: events.meta,
 		state: "loaded",
 		totalVisible: events.meta?.completeness === "complete",
-		window: events.data.window,
 	};
 }
 
-export { type AccountEventsPageViewModel, useAccountEventsPageVm };
+export { type AccountEventsPageViewModel, useAccountEventsPageViewModel };

src/pages/account-events/ui/AccountEventsPage/components/AccountEventsPageError.view.tsx

@@ -4,12 +4,7 @@ import { Button, Group } from "@mantine/core";
 import { StateView } from "@wealthledger/ui";
 import { useTranslation } from "react-i18next";
 
-import { ReadRetryButton, type ReadRetryProps } from "@/shared/ui";
+type AccountEventsPageErrorProps = { onReset: () => void };
-
-type AccountEventsPageErrorProps = {
-	onReset: () => void;
-	readRetry: ReadRetryProps;
-};
 
 const AccountEventsPageError: FC<AccountEventsPageErrorProps> = (props) => {
 	const { t } = useTranslation();
@@ -18,13 +13,6 @@ const AccountEventsPageError: FC<AccountEventsPageErrorProps> = (props) => {
 		<StateView
 			action={(
 				<Group>
-					{props.readRetry.exhausted && (
-						<ReadRetryButton
-							onRetry={props.readRetry.onRetry}
-							retrying={props.readRetry.retrying}
-						/>
-					)}
-
 					<Button onClick={props.onReset} variant="default">
 						{t("ledger.reset")}
 					</Button>

src/pages/account-events/ui/AccountEventsPage/components/AccountEventsPageLoaded.view.tsx

@@ -17,8 +17,8 @@ import {
 	brokerageEventGroupKey,
 	brokerageEventKey,
 } from "@/entities/brokerage-event";
-import { formatDate, formatSnapshotTime, groupItems } from "@/shared/lib";
+import { groupItems } from "@/shared/lib";
-import { ReadRetry, SourceSyncStatus } from "@/shared/ui";
+import { SourceSyncStatus } from "@/shared/ui";
 
 import type { AccountEventsPageViewModel } from "../AccountEventsPage.vm";
 
@@ -83,20 +83,10 @@ const AccountEventsPageLoaded: FC<AccountEventsPageLoadedProps> = (props) => {
 				stale={props.source?.freshness === "stale"}
 			/>
 
-			<ReadRetry {...props.readRetry} />
-
 			{!!props.partial && <Alert role="status">{t("investment.partial")}</Alert>}
 
 			<Text c="dimmed">{t("events.hint")}</Text>
 
-			<Text c="dimmed" size="sm">
-				{t("events.forecastWindow", {
-					date: formatSnapshotTime(props.calculatedAt),
-					from: formatDate(props.window.from),
-					to: formatDate(props.window.to),
-				})}
-			</Text>
-
 			<Group align="end">
 				<DatePickerInput
 					allowSingleDateInRange

src/pages/account-income/ui/AccountIncomePage/AccountIncomePage.test.tsx

@@ -26,7 +26,6 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import type { IncomeAnalytics } from "@/entities/income";
 
 import { configureAuthClient } from "@/shared/api";
-import { formatSnapshotTime } from "@/shared/lib";
 import { createTestQueryClient } from "@/test/query";
 import { resource } from "@/test/resource";
 import { server } from "@/test/server";
@@ -34,14 +33,10 @@ import { server } from "@/test/server";
 import { toIncomeDisplayModel } from "../../model/display";
 import { AccountIncomePage } from "./AccountIncomePage";
 import {
-	useAccountIncomePageVm,
+	useAccountIncomePageViewModel,
 } from "./AccountIncomePage.vm";
 import { IncomePayments } from "./components/IncomePayments.view";
 
-// Automatic read retries wait 1s + 2s before the failure is final.
-const RETRIES_EXHAUSTED_MS = 6000;
-const TEST_MS = 10_000;
-
 const analytics
 	= {
 		accountId: "account-1",
@@ -49,7 +44,7 @@ const analytics
 		buckets: [
 			{
 				period: { from: "2026-08-01", to: "2026-08-01" },
-				total: summary("10", "2"),
+				totalsByCurrency: [summary("RUB", "10", "2")],
 			},
 		],
 		calculatedAt: "2026-08-27T00:00:00Z",
@@ -77,7 +72,7 @@ const analytics
 			},
 		],
 		period: { from: "2026-08-01", to: "2026-08-27" },
-		total: summary("10", "2"),
+		totalsByCurrency: [summary("RUB", "10", "2")],
 	} satisfies IncomeAnalytics & { instruments: [unknown] };
 
 function entry(): IncomeAnalytics["entries"][number] {
@@ -145,11 +140,12 @@ function renderPage(
 	return { ...view, queryClient };
 }
 
-function summary(coupon: string, dividend: string) {
+function summary(currency: string, coupon: string, dividend: string) {
 	return {
-		coupon: money("RUB", coupon),
+		coupon: money(currency, coupon),
-		dividend: money("RUB", dividend),
+		currency,
-		total: money("RUB", String(Number(coupon) + Number(dividend))),
+		dividend: money(currency, dividend),
+		total: money(currency, String(Number(coupon) + Number(dividend))),
 	};
 }
 
@@ -170,7 +166,7 @@ describe("AccountIncomePage", () => {
 		);
 		const queryClient = createTestQueryClient();
 
-		const { result } = renderHook(() => useAccountIncomePageVm(), {
+		const { result } = renderHook(() => useAccountIncomePageViewModel(), {
 			wrapper: ({ children }) => (
 				<QueryClientProvider client={queryClient}>
 					<MemoryRouter initialEntries={["?from=2024-02-29&to=2024-03-01"]}>
@@ -307,7 +303,7 @@ describe("AccountIncomePage", () => {
 						buckets: [],
 						entries: [],
 						instruments: [],
-						total: summary("0", "0"),
+						totalsByCurrency: [],
 					}),
 				),
 			),
@@ -407,124 +403,21 @@ describe("AccountIncomePage", () => {
 		expect(screen.queryByText(/Сравнение с/)).not.toBeInTheDocument();
 	});
 
-	it.each([
+	it("shows a quiet realized error", async () => {
-		["full", analytics],
-		["empty", { ...analytics, buckets: [], entries: [], instruments: [], total: summary("0", "0") }],
-	])("shows the server source time and last attempt for a %s result", async (_name, data) => {
 		server.use(
-			http.get("*/api/v1/brokerage-accounts/account-1/income-analytics", () =>
+			http.get(
-				HttpResponse.json(
+				"*/api/v1/brokerage-accounts/account-1/income-analytics",
-					resource(data, {
+				() => new HttpResponse(null, { status: 503 }),
-						freshness: "stale",
-						lastAttempt: {
-							finishedAt: "2026-08-27T01:00:00Z",
-							problems: [],
-							startedAt: "2026-08-27T00:59:00Z",
-							state: "failed",
-						},
-						lastSuccessfulAt: "2026-08-26T12:00:00Z",
-					}),
-				),
 			),
 		);
 		renderPage();
-		expect(await screen.findByText(/^Данные на /)).toHaveTextContent(
+		expect(
-			formatSnapshotTime("2026-08-26T12:00:00Z"),
+			await screen.findByText("Не удалось рассчитать пассивный доход", undefined, {
-		);
+				timeout: 4000,
-		expect(screen.getByText("Обновление не удалось")).toBeInTheDocument();
+			}),
-		expect(screen.getByText("Данные требуют обновления")).toBeInTheDocument();
+		).toBeInTheDocument();
 		expect(screen.queryByRole("button", { name: "Повторить" })).not.toBeInTheDocument();
 	});
-
-	it(
-		"offers retry after an initial failure and recovers in place",
-		{ timeout: TEST_MS },
-		async () => {
-			let isFailing = true;
-			let requests = 0;
-			server.use(
-				http.get(
-					"*/api/v1/brokerage-accounts/account-1/income-analytics",
-					() => {
-						requests += 1;
-
-						return isFailing
-							? new HttpResponse(null, { status: 503 })
-							: HttpResponse.json(resource(analytics));
-					},
-				),
-			);
-			renderPage();
-			expect(
-				await screen.findByText(
-					"Не удалось рассчитать пассивный доход",
-					undefined,
-					{ timeout: RETRIES_EXHAUSTED_MS },
-				),
-			).toBeInTheDocument();
-			const retry = screen.getByRole("button", { name: "Повторить" });
-			expect(requests).toBe(3);
-
-			isFailing = false;
-			fireEvent.click(retry);
-
-			expect(
-				await screen.findByRole("region", { name: "Выплаты" }),
-			).toBeInTheDocument();
-			expect(requests).toBe(4);
-		},
-	);
-
-	it(
-		"keeps cached income, warns and retries the same GET",
-		{ timeout: TEST_MS },
-		async () => {
-			let isFailing = false;
-			let requests = 0;
-			server.use(
-				http.get(
-					"*/api/v1/brokerage-accounts/account-1/income-analytics",
-					() => {
-						requests += 1;
-
-						return isFailing
-							? HttpResponse.json(
-									{ code: "TBANK_UNAVAILABLE" },
-									{ status: 503 },
-								)
-							: HttpResponse.json(resource(analytics));
-					},
-				),
-			);
-			const { queryClient } = renderPage();
-			await screen.findByRole("region", { name: "Выплаты" });
-			expect(screen.queryByRole("button", { name: "Повторить" }))
-				.not.toBeInTheDocument();
-
-			isFailing = true;
-			void queryClient.invalidateQueries({
-				queryKey: ["get", "/api/v1/brokerage-accounts/{accountId}/income-analytics"],
-			});
-
-			const retry = await screen.findByRole(
-				"button",
-				{ name: "Повторить" },
-				{ timeout: RETRIES_EXHAUSTED_MS },
-			);
-
-			expect(screen.getByText("Не удалось обновить данные")).toBeInTheDocument();
-			expect(screen.getByRole("region", { name: "Выплаты" })).toBeInTheDocument();
-			expect(requests).toBe(4);
-
-			isFailing = false;
-			fireEvent.click(retry);
-
-			await waitFor(() =>
-				expect(screen.queryByText("Не удалось обновить данные"))
-					.not.toBeInTheDocument());
-			expect(requests).toBe(5);
-		},
-	);
 });
 
 const LocationProbe: FC = () => {
@@ -736,11 +629,11 @@ describe("income period and snapshot boundary", () => {
 		const instruments = [
 			{
 				...analytics.instruments[0],
-				coupon: money("RUB", "10"),
+				coupon: money("USD", "10"),
-				dividend: money("RUB", "0"),
+				dividend: money("USD", "0"),
-				key: "rub-positive",
+				key: "usd",
 				receiptCount: 1,
-				total: money("RUB", "10"),
+				total: money("USD", "10"),
 			},
 			{
 				...analytics.instruments[0],
@@ -769,7 +662,7 @@ describe("income period and snapshot boundary", () => {
 				payment: instrument.total,
 			})),
 			instruments,
-			total: summary("-5", "0"),
+			totalsByCurrency: [summary("RUB", "-5", "0"), summary("USD", "10", "0")],
 		});
 
 		render(
@@ -781,9 +674,10 @@ describe("income period and snapshot boundary", () => {
 			screen.getByRole("heading", { name: "Выплаты" }),
 		).toBeInTheDocument();
 		expect(screen.queryByText("RUB")).not.toBeInTheDocument();
+		expect(screen.queryByText("USD")).not.toBeInTheDocument();
 		const cards = screen.getAllByRole("listitem");
 		expect(cards).toHaveLength(3);
-		expect(cards[0]).toHaveTextContent("+10 ₽");
+		expect(cards[0]).toHaveTextContent("+10 USD");
 		expect(cards[1]).toHaveTextContent("−2 ₽");
 		expect(cards[2]).toHaveTextContent("−3 ₽");
 		expect(screen.queryByText(/Итого:|Выплат:/)).not.toBeInTheDocument();
@@ -815,11 +709,11 @@ describe("income period and snapshot boundary", () => {
 		);
 		renderPage(undefined, "all");
 
-		expect(await screen.findByText("Выплата купонов BOND")).toBeInTheDocument();
+		expect(await screen.findByText("Купон · BOND")).toBeInTheDocument();
 		expect(screen.getByText("+30 ₽")).toBeInTheDocument();
 
 		const accounts = within(screen.getByRole("list", {
-			name: /Выплата купонов BOND, Исполнено/,
+			name: /Купон · BOND, Исполнено/,
 		}));
 
 		expect(accounts.getByText("Брокерский")).toBeInTheDocument();
@@ -854,7 +748,7 @@ describe("income period and snapshot boundary", () => {
 		expect(await screen.findByText("+30 ₽")).toBeInTheDocument();
 
 		const accounts = within(screen.getByRole("list", {
-			name: /Выплата купонов BOND/,
+			name: /Купон · BOND/,
 		}));
 
 		expect(accounts.getAllByRole("listitem")).toHaveLength(2);
@@ -887,7 +781,7 @@ describe("income period and snapshot boundary", () => {
 		);
 		const view = renderPage(undefined, "all");
 
-		await screen.findByText("Выплата купонов BOND");
+		await screen.findByText("Купон · BOND");
 		expect(screen.queryByText("+30 ₽")).not.toBeInTheDocument();
 		view.unmount();
 

src/pages/account-income/ui/AccountIncomePage/AccountIncomePage.tsx

@@ -1,17 +1,17 @@
 import type { FC } from "react";
 
-import { useAccountIncomePageVm } from "./AccountIncomePage.vm";
+import { useAccountIncomePageViewModel } from "./AccountIncomePage.vm";
 import { AccountIncomePageError } from "./components/AccountIncomePageError.view";
 import { AccountIncomePageLoaded } from "./components/AccountIncomePageLoaded.view";
 import { AccountIncomePageLoading } from "./components/AccountIncomePageLoading.view";
 
 const AccountIncomePage: FC = () => {
-	const vm = useAccountIncomePageVm();
+	const viewModel = useAccountIncomePageViewModel();
-	if (vm.state === "loading") return <AccountIncomePageLoading />;
+	if (viewModel.state === "loading") return <AccountIncomePageLoading />;
 
-	return vm.state === "error"
+	return viewModel.state === "error"
-		? <AccountIncomePageError {...vm} />
+		? <AccountIncomePageError {...viewModel} />
-		: <AccountIncomePageLoaded {...vm} />;
+		: <AccountIncomePageLoaded {...viewModel} />;
 };
 
 export { AccountIncomePage };

src/pages/account-income/ui/AccountIncomePage/AccountIncomePage.vm.ts

@@ -5,7 +5,6 @@ import { useParams, useSearchParams } from "react-router";
 
 import { type IncomeAnalytics, useIncomeAnalytics } from "@/entities/income";
 import { useScreenSync } from "@/features/tbank-connection";
-import { type InvestmentResourceMeta, readRetry } from "@/shared/api";
 import { isValidPeriod, moscowDate, useInitialAvailability } from "@/shared/lib";
 
 import {
@@ -31,19 +30,16 @@ type AccountIncomePageViewModel
 		onReset: () => void;
 		onSubmit: (values: IncomeForm) => void;
 		partial?: boolean;
-		readRetry: ReturnType<typeof readRetry>;
-		source?: InvestmentResourceMeta;
 		state: "loaded";
 		totalVisible: boolean;
 	}
 	| {
 		period: IncomePeriod;
-		readRetry: ReturnType<typeof readRetry>;
 		state: "error";
 	}
 	| { state: "loading" };
 
-const useAccountIncomePageVm = (): AccountIncomePageViewModel => {
+const useAccountIncomePageViewModel = (): AccountIncomePageViewModel => {
 	const { accountId = "" } = useParams();
 	const [searchParameters, setSearchParameters] = useSearchParams();
 
@@ -88,14 +84,12 @@ const useAccountIncomePageVm = (): AccountIncomePageViewModel => {
 		isFetching: analytics.isFetching,
 	});
 
-	const retry = readRetry([analytics]);
-
 	if (availability === "loading" && analytics.isLoading)
 		return { state: "loading" };
 
 	if (!analytics.data)
 		return availability === "unavailable"
-			? { period, readRetry: retry, state: "error" }
+			? { period, state: "error" }
 			: { state: "loading" };
 
 	const display = toIncomeDisplayModel(analytics.data);
@@ -122,8 +116,6 @@ const useAccountIncomePageVm = (): AccountIncomePageViewModel => {
 		onReset,
 		onSubmit,
 		partial: analytics.meta?.completeness === "incomplete",
-		readRetry: retry,
-		source: analytics.meta,
 		state: "loaded",
 		totalVisible: analytics.meta?.completeness === "complete",
 	};
@@ -146,5 +138,5 @@ function isValidIncomePeriod(period: IncomePeriod): boolean {
 
 export {
 	type AccountIncomePageViewModel,
-	useAccountIncomePageVm,
+	useAccountIncomePageViewModel,
 };

src/pages/account-income/ui/AccountIncomePage/components/AccountIncomePageError.view.tsx

@@ -3,27 +3,15 @@ import type { FC } from "react";
 import { StateView } from "@wealthledger/ui";
 import { useTranslation } from "react-i18next";
 
-import { ReadRetryButton } from "@/shared/ui";
-
 import type { AccountIncomePageViewModel } from "../AccountIncomePage.vm";
 
 type ErrorProps = Extract<AccountIncomePageViewModel, { state: "error" }>;
 
-const AccountIncomePageError: FC<ErrorProps> = (props) => {
+const AccountIncomePageError: FC<ErrorProps> = () => {
 	const { t } = useTranslation();
 
-	const retry = props.readRetry.exhausted
-		? (
-				<ReadRetryButton
-					onRetry={props.readRetry.onRetry}
-					retrying={props.readRetry.retrying}
-				/>
-			)
-		: undefined;
-
 	return (
 		<StateView
-			action={retry}
 			error
 			text={t("income.errorText")}
 			title={t("income.errorTitle")}

src/pages/account-income/ui/AccountIncomePage/components/AccountIncomePageLoaded.view.tsx

@@ -5,11 +5,10 @@ import {
 	Stack,
 	Title,
 } from "@mantine/core";
+import { StateView } from "@wealthledger/ui";
 import { FormProvider } from "react-hook-form";
 import { useTranslation } from "react-i18next";
 
-import { ReadRetry, SourceSyncStatus } from "@/shared/ui";
-
 import type { AccountIncomePageViewModel } from "../AccountIncomePage.vm";
 
 import classes from "../AccountIncomePage.module.css";
@@ -24,9 +23,13 @@ const AccountIncomePageLoadedSummary: FC<LoadedProps> = (props) => {
 
 	const { analytics } = props;
 
-	return props.partial
+	if (props.partial) {
-		? <Alert role="status">{t("investment.partial")}</Alert>
+		return <Alert role="status">{t("investment.partial")}</Alert>;
-		: <IncomeSummary totals={analytics.total} />;
+	}
+
+	return analytics.totalsByCurrency.length > 0
+		? <IncomeSummary totals={analytics.totalsByCurrency} />
+		: <StateView text={t("income.emptyText")} title={t("income.emptyTitle")} />;
 };
 
 const AccountIncomePageLoaded: FC<LoadedProps> = (props) => {
@@ -46,14 +49,6 @@ const AccountIncomePageLoaded: FC<LoadedProps> = (props) => {
 				/>
 			</FormProvider>
 
-			<SourceSyncStatus
-				lastAttempt={props.source?.lastAttempt}
-				lastSuccessfulAt={props.source?.lastSuccessfulAt}
-				stale={props.source?.freshness === "stale"}
-			/>
-
-			<ReadRetry {...props.readRetry} />
-
 			<AccountIncomePageLoadedSummary {...props} />
 
 			<Alert color="blue">{t("income.taxBoundary")}</Alert>

src/pages/account-income/ui/AccountIncomePage/components/IncomeSummary.view.tsx

@@ -7,7 +7,7 @@ import type { IncomeAnalytics } from "@/entities/income";
 
 import { formatMoney } from "@/shared/lib";
 
-type IncomeSummaryProps = { totals: IncomeAnalytics["total"] };
+type IncomeSummaryProps = { totals: IncomeAnalytics["totalsByCurrency"] };
 
 const IncomeSummary: FC<IncomeSummaryProps> = (props) => {
 	const { t } = useTranslation();
@@ -16,14 +16,16 @@ const IncomeSummary: FC<IncomeSummaryProps> = (props) => {
 		<Stack>
 			<Title order={2}>{t("income.summaryTitle")}</Title>
 
-			<Paper p="md" radius="md" withBorder>
+			{props.totals.map(total => (
-				<Text fw={700}>{formatMoney(props.totals.total)}</Text>
+				<Paper key={total.currency} p="md" radius="md" withBorder>
+					<Text fw={700}>{formatMoney(total.total)}</Text>
 
 					<Text c="dimmed" size="sm">
-					{t("income.coupon")}: {formatMoney(props.totals.coupon)} ·{" "}
+						{t("income.coupon")}: {formatMoney(total.coupon)} ·{" "}
-					{t("income.dividend")}: {formatMoney(props.totals.dividend)}
+						{t("income.dividend")}: {formatMoney(total.dividend)}
 					</Text>
 				</Paper>
+			))}
 		</Stack>
 	);
 };

src/pages/account-operations/ui/AccountOperationsPage/AccountOperationsPage.test.tsx

@@ -90,13 +90,9 @@ function configureTestAuth() {
 	});
 }
 
-function renderPage(
+function renderPage(search = "", accountId = "account-1") {
-	search = "",
-	accountId = "account-1",
-	queryClient = createTestQueryClient(),
-) {
 	return render(
-		<QueryClientProvider client={queryClient}>
+		<QueryClientProvider client={createTestQueryClient()}>
 			<MantineProvider>
 				<MemoryRouter
 					initialEntries={[`/accounts/${accountId}/operations${search}`]}
@@ -113,18 +109,6 @@ function renderPage(
 	);
 }
 
-// Automatic read retries wait 1s + 2s before the failure is final.
-const RETRIES_EXHAUSTED_MS = 6000;
-const TEST_MS = 10_000;
-
-const loadedOperations = {
-	accountId: "account-1",
-	hasNext: false,
-	items: [operation],
-	nextCursor: null,
-	observedAt: "2026-08-14T00:00:00Z",
-};
-
 describe("LedgerEntryRow", () => {
 	it("marks cashless operations without rendering operation details", () => {
 		render(
@@ -440,7 +424,7 @@ describe("AccountOperationsPage", () => {
 		renderPage();
 
 		expect(
-			await screen.findByRole("heading", { name: "История операций" }),
+			await screen.findByRole("heading", { name: "Журнал операций" }),
 		).toBeInTheDocument();
 		expect(
 			screen.queryByRole("link", { name: "К счету" }),
@@ -482,7 +466,7 @@ describe("AccountOperationsPage", () => {
 		renderPage();
 
 		expect(
-			await screen.findByRole("heading", { name: "История операций" }),
+			await screen.findByRole("heading", { name: "Журнал операций" }),
 		).toBeInTheDocument();
 		await waitFor(() => expect(searches.length).toBeGreaterThan(0));
 		const countBefore = searches.length;
@@ -521,7 +505,7 @@ describe("AccountOperationsPage", () => {
 		renderPage();
 
 		expect(
-			await screen.findByRole("heading", { name: "История операций" }),
+			await screen.findByRole("heading", { name: "Журнал операций" }),
 		).toBeInTheDocument();
 		fireEvent.click(screen.getByRole("combobox", { name: "Категории" }));
 		fireEvent.click(await screen.findByText("Налог"));
@@ -561,88 +545,21 @@ describe("AccountOperationsPage", () => {
 		).toBeInTheDocument();
 	});
 
-	it(
+	it("renders an error state", async () => {
-		"renders an error state with retry that recovers in place",
-		{ timeout: TEST_MS },
-		async () => {
 		configureTestAuth();
-			let isFailing = true;
-			let requests = 0;
 		server.use(
-				http.get("*/api/v1/brokerage-accounts/:accountId/operations", () => {
+			http.get("*/api/v1/brokerage-accounts/:accountId/operations", () =>
-					requests += 1;
+				HttpResponse.json({ code: "TBANK_UNAVAILABLE" }, { status: 503 }),
-
+			),
-					return isFailing
-						? HttpResponse.json({ code: "TBANK_UNAVAILABLE" }, { status: 503 })
-						: HttpResponse.json(resource(loadedOperations));
-				}),
 		);
 		renderPage();
 		expect(
-				await screen.findByText("Не удалось загрузить историю операций", undefined, {
+			await screen.findByText("Не удалось загрузить журнал", undefined, {
-					timeout: RETRIES_EXHAUSTED_MS,
+				timeout: 4000,
 			}),
 		).toBeInTheDocument();
-			expect(requests).toBe(3);
-
-			isFailing = false;
-			fireEvent.click(screen.getByRole("button", { name: "Повторить" }));
-
-			expect(await screen.findByText("Покупка акций")).toBeInTheDocument();
-			expect(requests).toBe(4);
-		},
-	);
-
-	it(
-		"keeps cached operations, warns and retries the same GET",
-		{ timeout: TEST_MS },
-		async () => {
-			configureTestAuth();
-			let isFailing = false;
-			let requests = 0;
-			server.use(
-				http.get("*/api/v1/brokerage-accounts/:accountId/operations", () => {
-					requests += 1;
-
-					return isFailing
-						? HttpResponse.json({ code: "TBANK_UNAVAILABLE" }, { status: 503 })
-						: HttpResponse.json(resource(loadedOperations));
-				}),
-			);
-			const queryClient = createTestQueryClient();
-			renderPage("", "account-1", queryClient);
-			await screen.findByText("Покупка акций");
-			expect(screen.queryByRole("button", { name: "Повторить" }))
-				.not.toBeInTheDocument();
-
-			isFailing = true;
-			void queryClient.invalidateQueries({
-				queryKey: [
-					"get",
-					"/api/v1/brokerage-accounts/{accountId}/operations",
-				],
 	});
 
-			const retry = await screen.findByRole(
-				"button",
-				{ name: "Повторить" },
-				{ timeout: RETRIES_EXHAUSTED_MS },
-			);
-
-			expect(screen.getByText("Не удалось обновить данные")).toBeInTheDocument();
-			expect(screen.getByText("Покупка акций")).toBeInTheDocument();
-			expect(requests).toBe(4);
-
-			isFailing = false;
-			fireEvent.click(retry);
-
-			await waitFor(() =>
-				expect(screen.queryByText("Не удалось обновить данные"))
-					.not.toBeInTheDocument());
-			expect(requests).toBe(5);
-		},
-	);
-
 	it("keeps a null operations envelope loading instead of a confirmed empty period", async () => {
 		configureTestAuth();
 		server.use(
@@ -787,10 +704,10 @@ describe("all-account operation groups", () => {
 		fireEvent.click(screen.getByRole("button", { name: "Далее" }));
 
 		const accounts = await screen.findByRole("list", {
-			name: /Выплата купонов BOND, Исполнено/,
+			name: /Купон · BOND, Исполнено/,
 		});
 
-		expect(screen.getByText("Выплата купонов BOND")).toBeInTheDocument();
+		expect(screen.getByText("Купон · BOND")).toBeInTheDocument();
 		expect(screen.getByText("+200 ₽")).toBeInTheDocument();
 		expect(within(accounts).getAllByRole("listitem")).toHaveLength(2);
 

src/pages/account-operations/ui/AccountOperationsPage/AccountOperationsPage.tsx

@@ -6,15 +6,15 @@ import { AccountOperationsPageLoaded } from "./components/AccountOperationsPageL
 import { AccountOperationsPageLoading } from "./components/AccountOperationsPageLoading.view";
 
 const AccountOperationsPage: FC = () => {
-	const vm = useAccountOperationsPageVm();
+	const viewModel = useAccountOperationsPageVm();
 
-	if (vm.state === "loading") {
+	if (viewModel.state === "loading") {
 		return <AccountOperationsPageLoading />;
 	}
 
-	return vm.state === "error"
+	return viewModel.state === "error"
-		? <AccountOperationsPageError {...vm} />
+		? <AccountOperationsPageError {...viewModel} />
-		: <AccountOperationsPageLoaded {...vm} />;
+		: <AccountOperationsPageLoaded {...viewModel} />;
 };
 
 export { AccountOperationsPage };

src/pages/account-operations/ui/AccountOperationsPage/AccountOperationsPage.vm.ts

@@ -12,12 +12,7 @@ import {
 	useBrokerageOperationHistory,
 } from "@/entities/broker-operation";
 import { useScreenSync } from "@/features/tbank-connection";
-import {
+import { ApiErrorCode, apiErrorCode, isApiErrorCode } from "@/shared/api";
-	ApiErrorCode,
-	apiErrorCode,
-	isApiErrorCode,
-	readRetry,
-} from "@/shared/api";
 import {
 	defaultPeriod,
 	isValidPeriod,
@@ -47,16 +42,11 @@ type AccountOperationsPageViewModel
 		onPrevious: () => void;
 		onReset: () => void;
 		partial?: boolean;
-		readRetry: ReturnType<typeof readRetry>;
 		source?: InvestmentResourceMeta;
 		state: "loaded";
 		totalVisible: boolean;
 	}
-	| {
+	| { onReset: () => void; state: "error" }
-		onReset: () => void;
-		readRetry: ReturnType<typeof readRetry>;
-		state: "error";
-	}
 	| { state: "loading" };
 
 const useAccountOperationsPageVm = (): AccountOperationsPageViewModel => {
@@ -117,8 +107,6 @@ const useAccountOperationsPageVm = (): AccountOperationsPageViewModel => {
 		isFetching: operations.isFetching,
 	});
 
-	const retry = readRetry([operations]);
-
 	if (availability === "loading" && operations.isLoading)
 		return { state: "loading" };
 
@@ -146,11 +134,11 @@ const useAccountOperationsPageVm = (): AccountOperationsPageViewModel => {
 		(isInvalidCursor || !operations.data)
 		&& (operations.isError || operations.meta?.lastAttempt.state === "failed")
 	)
-		return { onReset, readRetry: retry, state: "error" };
+		return { onReset, state: "error" };
 
 	if (!operations.data)
 		return availability === "unavailable"
-			? { onReset, readRetry: retry, state: "error" }
+			? { onReset, state: "error" }
 			: { state: "loading" };
 
 	const nextCursor = operations.data.nextCursor;
@@ -194,7 +182,6 @@ const useAccountOperationsPageVm = (): AccountOperationsPageViewModel => {
 		onPrevious: history.onPrevious,
 		onReset,
 		partial: operations.meta?.completeness === "incomplete",
-		readRetry: retry,
 		source: operations.meta,
 		state: "loaded",
 		totalVisible: operations.meta?.completeness === "complete",

src/pages/account-operations/ui/AccountOperationsPage/components/AccountOperationsPageError.view.tsx

@@ -1,11 +1,9 @@
 import type { FC } from "react";
 
-import { Button, Group } from "@mantine/core";
+import { Button } from "@mantine/core";
 import { StateView } from "@wealthledger/ui";
 import { useTranslation } from "react-i18next";
 
-import { ReadRetryButton } from "@/shared/ui";
-
 import type { AccountOperationsPageViewModel } from "../AccountOperationsPage.vm";
 
 type AccountOperationsPageErrorProps = Extract<
@@ -21,18 +19,9 @@ const AccountOperationsPageError: FC<AccountOperationsPageErrorProps> = (
 	return (
 		<StateView
 			action={(
-				<Group gap="sm" justify="center">
-					{props.readRetry.exhausted && (
-						<ReadRetryButton
-							onRetry={props.readRetry.onRetry}
-							retrying={props.readRetry.retrying}
-						/>
-					)}
-
 				<Button onClick={props.onReset} variant="default">
 					{t("ledger.reset")}
 				</Button>
-				</Group>
 			)}
 			text={t("ledger.errorText")}
 			title={t("ledger.errorTitle")}

src/pages/account-operations/ui/AccountOperationsPage/components/AccountOperationsPageLoaded.view.tsx

@@ -19,7 +19,7 @@ import {
 	OperationGroup,
 } from "@/entities/broker-operation";
 import { groupItems } from "@/shared/lib";
-import { ReadRetry, SourceSyncStatus } from "@/shared/ui";
+import { SourceSyncStatus } from "@/shared/ui";
 
 import type { AccountOperationsPageViewModel } from "../AccountOperationsPage.vm";
 
@@ -102,8 +102,6 @@ const AccountOperationsPageLoaded: FC<AccountOperationsPageLoadedProps> = (
 				stale={props.source?.freshness === "stale"}
 			/>
 
-			<ReadRetry {...props.readRetry} />
-
 			{!!props.partial && <Alert role="status">{t("investment.partial")}</Alert>}
 
 			{!!props.historyLoading && <Alert>{t("investment.history")}</Alert>}

src/pages/account/model/concentration.test.ts

@@ -35,13 +35,15 @@ describe("account concentration", () => {
 		const model = toConcentration(snapshot([
 			stock("A", "1"), stock("B", "15"),
 			stock("C", "0"), stock("D", "-50"), stock("E", null),
-		]), "stocks", labels);
+			stock("F", null, "USD"), stock("G", "-3", "USD"),
+		]), "stocks", "RUB", labels);
 
+		expect(model.currencies).toEqual(["RUB", "USD"]);
 		expect(model.total).toBe("16");
 		expect(model.items.map(item => item.share)).toEqual(["93,8 %", "6,3 %"]);
-		expect(model.unaccounted).toBe(2);
+		expect(model.unaccounted).toBe(3);
-		const negative = snapshot([stock("A", "-3")]);
+		const negative = snapshot([stock("A", "-3", "USD")]);
-		expect(toConcentration(negative, "stocks", labels))
+		expect(toConcentration(negative, "stocks", "USD", labels))
 			.toMatchObject({ empty: true, unaccounted: 1 });
 	});
 
@@ -50,7 +52,7 @@ describe("account concentration", () => {
 			stock("A", "400"), stock("B", "250"), stock("C", "150"),
 			stock("D", "100"), stock("E", "50"), stock("F", "30"),
 			stock("G", "20"),
-		]), "stocks", labels);
+		]), "stocks", "RUB", labels);
 
 		expect(model.items.map(item => item.amount)).toEqual([
 			"400", "250", "150", "100", "50",
@@ -69,7 +71,7 @@ describe("account concentration", () => {
 			stock("Сбер", "100"), stock("X5", "100"),
 			stock("VK", "100"), stock("D", "100"),
 			stock("E", "100"), stock("F", "100"),
-		]), "stocks", labels);
+		]), "stocks", "RUB", labels);
 
 		expect(model.items).toHaveLength(6);
 		expect(model.other).toBeNull();
@@ -81,7 +83,7 @@ describe("account concentration", () => {
 			stock("Large", "100000000"), stock("Small", "1"),
 		]);
 
-		expect(toConcentration(tiny, "stocks", labels).items[1]?.share)
+		expect(toConcentration(tiny, "stocks", "RUB", labels).items[1]?.share)
 			.toBe("< 0,1 %");
 	});
 
@@ -101,9 +103,9 @@ describe("account concentration", () => {
 			stock("D", "50", "RUB", { issuer: null, sector: null }),
 		];
 
-		expect(toConcentration(snapshot(positions), "sectors", labels)
+		expect(toConcentration(snapshot(positions), "sectors", "RUB", labels)
 			.items.map(item => item.amount)).toEqual(["500", "100", "50"]);
-		expect(toConcentration(snapshot(positions), "issuers", labels)
+		expect(toConcentration(snapshot(positions), "issuers", "RUB", labels)
 			.items.map(item => [item.name, item.amount])).toEqual([
 			["Сбербанк", "500"], ["", "50"],
 		]);
@@ -121,7 +123,7 @@ describe("account concentration", () => {
 			stock("D", "100", "RUB", { issuer: null, sector: "energy" }),
 		]);
 
-		expect(toConcentration(issuers, "issuers", labels)
+		expect(toConcentration(issuers, "issuers", "RUB", labels)
 			.items.map(item => [item.label, item.amount])).toEqual([
 			["Газпром", "300"], ["Сбер", "300"], ["Эмитент не указан", "300"],
 		]);
@@ -138,7 +140,7 @@ describe("account concentration", () => {
 				: "Энергетика",
 		};
 
-		expect(toConcentration(sectors, "sectors", sectorLabels)
+		expect(toConcentration(sectors, "sectors", "RUB", sectorLabels)
 			.items.map(item => item.label))
 			.toEqual(["Информационные технологии", "Энергетика"]);
 	});
@@ -156,7 +158,7 @@ describe("account concentration", () => {
 			}),
 		]);
 
-		expect(toConcentration(data, "issuers", labels).items
+		expect(toConcentration(data, "issuers", "RUB", labels).items
 			.map(item => [item.name, item.label, item.amount])).toEqual([
 			["Альфа", "Альфа", "400"], ["Бета", "Бета", "400"],
 		]);
@@ -167,7 +169,7 @@ describe("account concentration", () => {
 			isin: "RU000A0JX0J2", ticker: "BOND", type: "BOND",
 		})]);
 
-		expect(toConcentration(data, "bonds", labels)
+		expect(toConcentration(data, "bonds", "RUB", labels)
 			.items[0]?.logo?.subtitle).toBe("RU000A0JX0J2");
 	});
 });

src/pages/account/model/concentration.ts

@@ -9,6 +9,7 @@ import {
 } from "@/shared/lib";
 
 type Concentration = {
+	currencies: string[];
 	empty: boolean;
 	items: ConcentrationItem[];
 	other: ConcentrationOther | null;
@@ -82,9 +83,11 @@ function addPosition(
 	index: number,
 	slice: Slice,
 	labels: ConcentrationLabels,
+	selected: null | string,
 ): number {
 	if (!isIncluded(slice, position.type)) return 0;
 	if (!position.currentValue) return 1;
+	if (position.currentValue.currency !== selected) return 0;
 	const value = decimalFromString(position.currentValue.value);
 	if (value.value < 0n) return 1;
 	if (value.value === 0n) return 0;
@@ -132,6 +135,16 @@ function compareDecimal(a: Decimal, b: Decimal): number {
 	return left < right ? -1 : 0;
 }
 
+function concentrationCurrencies(portfolio: Portfolio): string[] {
+	return [...new Set(portfolio.positions
+		.filter(position => eligibleTypes.has(position.type))
+		.filter(position => position.currentValue
+			&& decimalFromString(position.currentValue.value).value !== 0n)
+		.map(position => position.currentValue?.currency)
+		.filter((value): value is string => !!value))]
+		.toSorted((a, b) => a.localeCompare(b));
+}
+
 function groupIdentity(
 	position: Position,
 	slice: Slice,
@@ -201,13 +214,22 @@ function share(part: Decimal, total: Decimal): string {
 function toConcentration(
 	portfolio: Portfolio,
 	slice: Slice,
+	currency: null | string,
 	labels: ConcentrationLabels,
 ): Concentration {
+	const currencies = concentrationCurrencies(portfolio);
+
+	const selected = currency && currencies.includes(currency)
+		? currency
+		: currencies[0] ?? null;
+
 	const groups = new Map<string, Group>();
 	let unaccounted = 0;
 
 	for (const [index, position] of portfolio.positions.entries()) {
-		unaccounted += addPosition(groups, position, index, slice, labels);
+		unaccounted += addPosition(
+			groups, position, index, slice, labels, selected,
+		);
 	}
 
 	const ranked = Array.from(groups.values(), group => ({
@@ -256,6 +278,7 @@ function toConcentration(
 		: null;
 
 	return {
+		currencies,
 		empty: !total,
 		items: other ? entries.slice(0, TOP) : entries,
 		other,
@@ -266,6 +289,7 @@ function toConcentration(
 }
 
 export {
+	concentrationCurrencies,
 	toConcentration,
 };
 export type {

src/pages/account/model/performance.ts

@@ -1,104 +0,0 @@
-import type { Performance } from "@/entities/performance";
-
-import { formatDate, formatMoney, formatPercentagePoints, formatSignedPercent } from "@/shared/lib";
-
-type TextValue = { tone: Tone; value: string };
-
-type Tone
-	= | "negative"
-		| "neutral"
-		| "positive";
-
-const reasonLabels: Record<string, string> = {
-	ACCOUNT_VALUATION_DATES_DIFFER: "Оценки счетов сделаны в разные дни",
-	AMBIGUOUS_RETURN: "У расчёта доходности несколько возможных решений",
-	HISTORY_START_UNKNOWN: "Начало истории счёта неизвестно",
-	INDEX_HISTORY_UNAVAILABLE: "История индекса временно недоступна",
-	NO_SOLUTION: "Расчёт доходности не сходится",
-	OPERATIONS_HISTORY_INCOMPLETE: "История операций ещё не получена полностью",
-	PORTFOLIO_VALUATION_INCOMPLETE: "Нет полной оценки портфеля",
-	UNCONFIRMED_TRANSFER: "Перевод между счетами не удалось подтвердить",
-	UNVALUED_SECURITIES_TRANSFER: "Бумаги переведены без денежной оценки",
-};
-
-const unknownReason = "Причину недоступности не удалось определить";
-
-function performanceVm(data: Performance) {
-	return {
-		basis: data.return.basis,
-		comparison: data.outperformance
-			? {
-					money: signedMoney(data.outperformance.money),
-					points: valueText(
-						data.outperformance.percentagePoints,
-						formatPercentagePoints,
-					),
-				}
-			: null,
-		current: formatMoney(data.currentValue),
-		currentPoint: data.series.length > 0
-			? { date: formatDate(`${data.series.at(-1)?.date ?? data.period.to}T00:00:00Z`) }
-			: null,
-		days: data.period.days,
-		excluded: data.excludedAccounts.map(item => ({
-			id: item.accountId,
-			name: item.name,
-			reason: reasonText(item.reason),
-		})),
-		from: data.period.from,
-		indexReason: data.benchmark.unavailableReason
-			? reasonText(data.benchmark.unavailableReason)
-			: null,
-		indexReturn: valueText(data.benchmark.return.value, formatSignedPercent),
-		indexValue: data.benchmark.value ? formatMoney(data.benchmark.value) : "—",
-		invested: formatMoney(data.netInvested),
-		profit: signedMoney(data.profit),
-		returnReason: data.return.unavailableReason
-			? reasonText(data.return.unavailableReason)
-			: null,
-		returnValue: valueText(data.return.value, formatSignedPercent),
-		series: data.series.map(item => ({
-			benchmarkValue: Number(item.benchmarkValue),
-			date: item.date,
-			label: formatDate(`${item.date}T00:00:00Z`),
-			netInvested: Number(item.netInvested),
-			referenceValue: item.referenceValue === null
-				? null
-				: Number(item.referenceValue),
-		})),
-		to: data.period.to,
-	};
-}
-
-function reasonText(reason: string): string {
-	// eslint-disable-next-line security/detect-object-injection -- Lookup accepts only an API reason, with a safe fallback.
-	return reasonLabels[reason] ?? unknownReason;
-}
-
-function signedMoney(value: Performance["profit"]): TextValue {
-	return {
-		tone: tone(value.value),
-		value: formatMoney(value, { withSign: true }),
-	};
-}
-
-function tone(value: string): Tone {
-	const number = Number(value);
-	if (number > 0) return "positive";
-
-	return number < 0 ? "negative" : "neutral";
-}
-
-// Tone follows the displayed text, so "0,0 %" is never coloured.
-function valueText(
-	value: null | string,
-	format: (value: string) => string,
-): TextValue {
-	if (value === null) return { tone: "neutral", value: "—" };
-	const text = format(value);
-	if (text.startsWith("+")) return { tone: "positive", value: text };
-
-	return { tone: text.startsWith("−") ? "negative" : "neutral", value: text };
-}
-
-export { performanceVm, reasonText };

src/pages/account/model/positions.fixtures.ts

@@ -2,7 +2,7 @@ import type { Portfolio } from "@/entities/portfolio";
 
 const portfolio
 	= {
-		cash: { currency: "RUB", value: "1" },
+		cashBalances: [{ currency: "USD", value: "1" }],
 		isStale: true,
 		lastSuccessfulAt: "2026-08-13T10:00:00Z",
 		positions: [
@@ -49,13 +49,8 @@ const portfolio
 				type: "FUND",
 			},
 		] satisfies [Portfolio["positions"][number], ...Portfolio["positions"]],
-		structure: {
+		structure: { currencies: [], unvaluedCategories: [] },
-			categories: [],
+		totalsByCurrency: [{ currency: "RUB", value: "150" }],
-			hasNegativeValues: false,
-			totalValue: "0",
-			unvaluedCategories: [],
-		},
-		totals: { currency: "RUB", value: "150" },
 	} satisfies Portfolio;
 
 const position: Portfolio["positions"][number] = {

src/pages/account/model/positions.test.ts

@@ -23,7 +23,7 @@ function sections(positions: Portfolio["positions"]) {
 }
 
 describe("account position sections", () => {
-	it("excludes currency mirrors from display and share denominators", () => {
+	it("excludes currency instruments only from display, preserving order and share denominators", () => {
 		const otherTypes = [
 			"OPTION",
 			"OTHER",
@@ -35,7 +35,7 @@ describe("account position sections", () => {
 
 		const snapshot: Portfolio = {
 			...portfolio,
-			cash: { currency: "RUB", value: "1000" },
+			cashBalances: [{ currency: "RUB", value: "1000" }],
 			positions: [
 				...portfolio.positions,
 				{
@@ -56,8 +56,8 @@ describe("account position sections", () => {
 						}),
 				),
 			],
-			structure: { categories: [], hasNegativeValues: false, totalValue: "0", unvaluedCategories: [] },
+			structure: { currencies: [], unvaluedCategories: [] },
-			totals: { currency: "RUB", value: "1250" },
+			totalsByCurrency: [{ currency: "RUB", value: "1250" }],
 		};
 
 		const original = structuredClone(snapshot);
@@ -73,30 +73,12 @@ describe("account position sections", () => {
 			"FIGI-FUND",
 			...otherTypes.map(type => `FIGI-${type}-NEXT`),
 		]);
-		expect(sections[0]?.groups[0]?.positions[0].shareText).toBe("50 %");
+		expect(sections[0]?.groups[0]?.positions[0].shareText).toBe("40 %");
-		expect(sections[1]?.groups[0]?.positions[0].shareText).toBe("25 %");
+		expect(sections[1]?.groups[0]?.positions[0].shareText).toBe("20 %");
-		expect(sections[2]?.groups[1]?.positions[0].shareText).toBe("25 %");
+		expect(sections[2]?.groups[1]?.positions[0].shareText).toBe("20 %");
 		expect(snapshot).toEqual(original);
 	});
 
-	it("keeps all-account positions from both accounts without counting mirrored cash", () => {
-		const result = sections([
-			makePosition({ account: { id: "a", name: "Основной" }, currentValue: { currency: "RUB", value: "100" } }),
-			makePosition({ account: { id: "a", name: "Основной" }, currentValue: { currency: "RUB", value: "50" }, type: "CURRENCY" }),
-			makePosition({ account: { id: "b", name: "ИИС" }, currentValue: { currency: "RUB", value: "100" } }),
-		]);
-
-		const visible = result.flatMap(section =>
-			section.groups.flatMap(group => group.positions));
-
-		expect(visible)
-			.toEqual(expect.arrayContaining([
-				expect.objectContaining({ account: { id: "a", name: "Основной" }, shareText: "50 %" }),
-				expect.objectContaining({ account: { id: "b", name: "ИИС" }, shareText: "50 %" }),
-			]));
-		expect(visible).toHaveLength(2);
-	});
-
 	it("prepares grouped position sections with derived display data", () => {
 		expect(
 			toAccountPagePositionSections(portfolio).map(({ groups, kind }) => ({
@@ -193,13 +175,13 @@ describe("account position sections", () => {
 		).toHaveLength(2);
 	});
 
-	it("keeps values and purchase prices attached to their source positions", () => {
+	it("keeps currencies and purchase prices attached to their source positions", () => {
 		const source = [
 			position,
 			{
 				...second,
-				averagePurchasePrice: { currency: "RUB", value: "0.99" },
+				averagePurchasePrice: { currency: "USD", value: "0.99" },
-				currentValue: { currency: "RUB", value: "1.01" },
+				currentValue: { currency: "USD", value: "1.01" },
 			},
 		];
 
@@ -264,6 +246,10 @@ describe("account position returns", () => {
 		{ name: "zero quantity", overrides: { quantity: "0" } },
 		{ name: "negative quantity", overrides: { quantity: "-1" } },
 		{ name: "missing average price", overrides: { averagePurchasePrice: null } },
+		{
+			name: "currency mismatch",
+			overrides: { averagePurchasePrice: { currency: "USD", value: "280" } },
+		},
 		{ name: "zero cost", overrides: { averagePurchasePrice: { currency: "RUB", value: "0" } } },
 	])("returns null for $name", ({ overrides }) => {
 		const result = sections([makePosition({
@@ -297,24 +283,29 @@ describe("account position returns", () => {
 		expect(formatPositionReturnPercent(testCase.value)).toBe(testCase.expected);
 	});
 
-	it("sums complete unrealized returns", () => {
+	it("sums complete unrealized returns by currency", () => {
 		const result = toUnrealizedReturns([
 			makePosition({ absoluteReturn: { currency: "RUB", value: "0.1" } }),
 			makePosition({ absoluteReturn: { currency: "RUB", value: "0.2" } }),
+			makePosition({ absoluteReturn: { currency: "USD", value: "-2.5" } }),
 		]);
 
-		expect(result).toEqual({ currency: "RUB", value: "0.3" });
+		expect(result).toEqual([
+			{ currency: "RUB", value: "0.3" },
+			{ currency: "USD", value: "-2.5" },
+		]);
 	});
 
-	it("returns null when any return is incomplete", () => {
+	it("omits only currencies with incomplete returns", () => {
 		const result = toUnrealizedReturns([
 			makePosition({ absoluteReturn: { currency: "RUB", value: "10" } }),
 			makePosition({
 				absoluteReturn: null,
 				currentValue: { currency: "RUB", value: "100" },
 			}),
+			makePosition({ absoluteReturn: { currency: "USD", value: "2" } }),
 		]);
 
-		expect(result).toBeNull();
+		expect(result).toEqual([{ currency: "USD", value: "2" }]);
 	});
 });

src/pages/account/model/positions.ts

@@ -152,7 +152,7 @@ function toAccountPagePositionSections(
 	const denominators = new Map<string, number>();
 
 	for (const position of portfolio.positions) {
-		if (position.type === "CURRENCY" || !position.currentValue) continue;
+		if (!position.currentValue) continue;
 		const currency = position.currentValue.currency;
 		denominators.set(
 			currency,
@@ -249,23 +249,37 @@ function toSection(
 
 function toUnrealizedReturns(
 	positions: Portfolio["positions"],
-): Money | null {
+): Money[] {
-	const values: Decimal[] = [];
+	const totals = new Map<string, {
+		complete: boolean;
+		values: Decimal[];
+	}>();
 
 	for (const position of positions) {
-		if (!position.absoluteReturn) {
+		const currencies = position.absoluteReturn
-			// A position without any valuation has nothing to contribute.
+			? [position.absoluteReturn.currency]
+			: [...new Set([
+					position.averagePurchasePrice?.currency,
+					position.currentValue?.currency,
+				].filter((currency): currency is string => !!currency))];
 
-			if (!position.averagePurchasePrice && !position.currentValue)
+		for (const currency of currencies) {
-				continue;
+			const total = totals.get(currency) ?? { complete: true, values: [] };
 
-			return null;
+			if (position.absoluteReturn) {
+				total.values.push(decimalFromString(position.absoluteReturn.value));
+			}
+			else {
+				total.complete = false;
 			}
 
-		values.push(decimalFromString(position.absoluteReturn.value));
+			totals.set(currency, total);
+		}
 	}
 
-	return { currency: "RUB", value: decimalToString(sumDecimals(values)) };
+	return [...totals].flatMap(([currency, total]) => total.complete
+		? [{ currency, value: decimalToString(sumDecimals(total.values)) }]
+		: []);
 }
 
 export {

src/pages/account/model/previews.ts

@@ -64,7 +64,7 @@ function toIncomeSummary(
 	if (income.meta?.completeness === "incomplete") return { state: "partial", to };
 	if (!income.data && (income.isError || income.meta?.lastAttempt.state === "failed"))
 		return { state: "error", to };
-	if (!income.data) return { state: "empty", to };
+	if (!income.data?.totalsByCurrency.length) return { state: "empty", to };
 
 	return {
 		state: "loaded",

src/pages/account/ui/AccountPage/AccountPage.test.tsx

@@ -18,7 +18,6 @@ import type { BrokerageEvent } from "@/entities/brokerage-event";
 
 import { type Portfolio, portfolioQueryOptions } from "@/entities/portfolio";
 import { configureAuthClient } from "@/shared/api";
-import { formatSnapshotTime } from "@/shared/lib";
 import { createTestQueryClient } from "@/test/query";
 import { resource } from "@/test/resource";
 import { server } from "@/test/server";
@@ -60,10 +59,6 @@ function configureTestAuth() {
 	});
 }
 
-// Automatic read retries wait 1s + 2s before the failure is final.
-const RETRIES_EXHAUSTED_MS = 6000;
-const TEST_MS = 10_000;
-
 function renderAccountRoute(queryClient: QueryClient, accountId = "account-1") {
 	configureTestAuth();
 
@@ -96,7 +91,7 @@ function renderPage(ui: React.ReactNode) {
 
 const portfolio
 	= {
-		cash: { currency: "RUB", value: "0.5" },
+		cashBalances: [{ currency: "USD", value: "0.5" }],
 		isStale: true,
 		lastSuccessfulAt: "2026-08-13T10:00:00Z",
 		positions: [
@@ -129,8 +124,8 @@ const portfolio
 				type: "BOND",
 			},
 		] satisfies [Portfolio["positions"][number], ...Portfolio["positions"]],
-		structure: { categories: [], hasNegativeValues: false, totalValue: "0", unvaluedCategories: [] },
+		structure: { currencies: [], unvaluedCategories: [] },
-		totals: { currency: "RUB", value: "1234.5" },
+		totalsByCurrency: [{ currency: "RUB", value: "1234.5" }],
 	} satisfies Portfolio;
 
 function position(
@@ -201,6 +196,8 @@ const LoadedHarness = (
 function loadedProps(nextPortfolio: Portfolio = portfolio) {
 	return {
 		concentration: null,
+		currency: null,
+		onCurrencyChange: vi.fn(),
 		onSliceChange: vi.fn(),
 		portfolio: nextPortfolio,
 		positionSections: toAccountPagePositionSections(nextPortfolio),
@@ -234,37 +231,6 @@ describe("AccountPage states", () => {
 			.toHaveAccessibleDescription(/Акция: 100 ₽, 100 %/);
 	});
 
-	it("shows server source time and attempt for an empty account", async () => {
-		server.use(
-			http.get("*/api/v1/brokerage-accounts/:accountId/portfolio", () =>
-				HttpResponse.json(resource(
-					{
-						...portfolio,
-						cash: { currency: "RUB", value: "0" },
-						isStale: false,
-						positions: [],
-						totals: { currency: "RUB", value: "0" },
-					},
-					{
-						lastAttempt: {
-							finishedAt: "2026-08-14T01:00:00Z",
-							problems: [],
-							startedAt: "2026-08-14T00:59:00Z",
-							state: "failed",
-						},
-						lastSuccessfulAt: "2026-08-13T12:00:00Z",
-					},
-				)),
-			),
-		);
-		renderAccountRoute(createTestQueryClient());
-		expect(await screen.findByText(/^Данные на /)).toHaveTextContent(
-			formatSnapshotTime("2026-08-13T12:00:00Z"),
-		);
-		expect(screen.getByText("Обновление не удалось")).toBeInTheDocument();
-		expect(screen.queryByRole("button", { name: "Повторить" })).not.toBeInTheDocument();
-	});
-
 	it("expands and resets other when switching slice", () => {
 		const positions = [400, 250, 150, 100, 50, 30, 20].map(
 			(value, index) => position({
@@ -276,7 +242,7 @@ describe("AccountPage states", () => {
 		const data = { ...portfolio, positions };
 
 		const model = toConcentration(
-			data, "stocks", concentrationLabels(),
+			data, "stocks", "RUB", concentrationLabels(),
 		);
 
 		const props = loadedProps(data);
@@ -285,6 +251,7 @@ describe("AccountPage states", () => {
 				{...props}
 				accountId="a"
 				concentration={model}
+				currency="RUB"
 				tab="concentration"
 			/>,
 		);
@@ -323,8 +290,10 @@ describe("AccountPage states", () => {
 				concentration={toConcentration(
 					{ ...portfolio, positions },
 					"stocks",
+					"RUB",
 					concentrationLabels(),
 				)}
+				currency="RUB"
 				tab="concentration"
 			/>,
 		);
@@ -349,8 +318,9 @@ describe("AccountPage states", () => {
 				{...loadedProps(data)}
 				accountId="a"
 				concentration={toConcentration(
-					data, "stocks", concentrationLabels(),
+					data, "stocks", "RUB", concentrationLabels(),
 				)}
+				currency="RUB"
 				tab="concentration"
 			/>,
 		);
@@ -364,8 +334,9 @@ describe("AccountPage states", () => {
 				{...loadedProps(data)}
 				accountId="a"
 				concentration={toConcentration(
-					data, "issuers", concentrationLabels(),
+					data, "issuers", "RUB", concentrationLabels(),
 				)}
+				currency="RUB"
 				slice="issuers"
 				tab="concentration"
 			/>,
@@ -385,8 +356,9 @@ describe("AccountPage states", () => {
 				{...loadedProps(data)}
 				accountId="a"
 				concentration={toConcentration(
-					data, "stocks", concentrationLabels(),
+					data, "stocks", "RUB", concentrationLabels(),
 				)}
+				currency="RUB"
 				tab="concentration"
 			/>,
 		);
@@ -416,8 +388,9 @@ describe("AccountPage states", () => {
 				{...loadedProps(data)}
 				accountId="a"
 				concentration={toConcentration(
-					data, "sectors", concentrationLabels(),
+					data, "sectors", "RUB", concentrationLabels(),
 				)}
+				currency="RUB"
 				slice="sectors"
 				tab="concentration"
 			/>,
@@ -448,8 +421,9 @@ describe("AccountPage states", () => {
 				{...loadedProps(data)}
 				accountId="a"
 				concentration={toConcentration(
-					data, "stocks", concentrationLabels(),
+					data, "stocks", "RUB", concentrationLabels(),
 				)}
+				currency="RUB"
 				tab="concentration"
 			/>,
 		);
@@ -474,8 +448,9 @@ describe("AccountPage states", () => {
 				{...loadedProps(data)}
 				accountId="a"
 				concentration={toConcentration(
-					data, "stocks", concentrationLabels(),
+					data, "stocks", "RUB", concentrationLabels(),
 				)}
+				currency="RUB"
 				partial
 				tab="concentration"
 			/>,
@@ -485,14 +460,16 @@ describe("AccountPage states", () => {
 			.toHaveLength(1);
 	});
 
-	it("keeps the slice while switching page tabs and resets on account change", async () => {
+	it("keeps slice and currency while switching page tabs and resets on account change", async () => {
 		const multiCurrency = { ...portfolio, positions:
+			["RUB", "USD"].flatMap(currency =>
 				[400, 250, 150, 100, 50, 30, 20].map((value, index) =>
 					position({
-					currentValue: { currency: "RUB", value: String(value) },
+						currentValue: { currency, value: String(value) },
-					displayName: `Акция ${index + 1}`,
+						displayName: `${currency} акция ${index + 1}`,
 						sector: "energy", type: "STOCK",
 					}),
+				),
 			) };
 
 		server.use(
@@ -507,27 +484,37 @@ describe("AccountPage states", () => {
 		fireEvent.click(screen.getByRole("button", { name: /Прочее/ }));
 		expect(screen.getByRole("button", { name: /Прочее/ }))
 			.toHaveAttribute("aria-expanded", "true");
+		fireEvent.click(screen.getByRole("combobox", { name: "Валюта концентрации" }));
+		fireEvent.click(screen.getByRole("option", { name: "USD" }));
+		expect(screen.getByRole("button", { name: /Прочее/ }))
+			.toHaveAttribute("aria-expanded", "false");
 		fireEvent.click(screen.getByRole("button", { name: /Прочее/ }));
 		fireEvent.click(screen.getByRole("radio", { name: "Секторы" }));
 		fireEvent.click(screen.getByRole("radio", { name: "Акции" }));
 		expect(screen.getByRole("button", { name: /Прочее/ }))
 			.toHaveAttribute("aria-expanded", "false");
 		fireEvent.click(screen.getByRole("radio", { name: "Секторы" }));
+		expect(screen.getByRole("combobox", { name: "Валюта концентрации" }))
+			.toHaveValue("USD");
 
 		fireEvent.click(screen.getByRole("tab", { name: "Позиции" }));
 		fireEvent.click(screen.getByRole("tab", { name: "Концентрация" }));
 
 		expect(screen.getByRole("radio", { name: "Секторы" }))
 			.toBeChecked();
+		expect(screen.getByRole("combobox", { name: "Валюта концентрации" }))
+			.toHaveValue("USD");
 		fireEvent.click(screen.getByRole("button", { name: "Другой счёт" }));
 		fireEvent.click(await screen.findByRole("tab", { name: "Концентрация" }));
 		expect(screen.getByRole("radio", { name: "Акции" })).toBeChecked();
+		expect(screen.getByRole("combobox", { name: "Валюта концентрации" }))
+			.toHaveValue("RUB");
 	});
 
-	it("includes all ruble positions in concentration", () => {
+	it("falls back to the first currency when the selected one disappears", () => {
 		const data = { ...portfolio, positions: [
 			position({
-				currentValue: { currency: "RUB", value: "200" },
+				currentValue: { currency: "USD", value: "200" },
 			}),
 			position({
 				currentValue: { currency: "RUB", value: "100" },
@@ -535,11 +522,12 @@ describe("AccountPage states", () => {
 		] };
 
 		const model = toConcentration(
-			data, "stocks", concentrationLabels(),
+			data, "stocks", "EUR", concentrationLabels(),
 		);
 
-		expect(model.total).toBe("300");
+		expect(model.currencies).toEqual(["RUB", "USD"]);
-		expect(model.items.map(item => item.amount)).toEqual(["200", "100"]);
+		expect(model.total).toBe("100");
+		expect(model.items.map(item => item.amount)).toEqual(["100"]);
 	});
 	it("shows the loaded portfolio source sync status", async () => {
 		server.use(
@@ -655,7 +643,7 @@ describe("AccountPage states", () => {
 		).toHaveTextContent("Данные о структуре портфеля пока недоступны.");
 		expect(
 			screen.getAllByRole("definition").map(node => node.textContent),
-		).toEqual(["1 234,50 ₽"]);
+		).toEqual(["1 234,5 ₽"]);
 	});
 	it("keeps initial placeholders decorative without amounts or focus targets", () => {
 		const { container } = renderPage(<AccountPageLoading />);
@@ -698,7 +686,11 @@ describe("AccountPage states", () => {
 			<LoadedHarness
 				{...loadedProps({
 					...portfolio,
-					cash: { currency: "RUB", value: "234.500000000000000001" },
+					cashBalances: [
+						{ currency: "RUB", value: "234.500000000000000001" },
+						{ currency: "USD", value: "-0.5" },
+						{ currency: "XYZ", value: "3.00" },
+					],
 					positions: [
 						...portfolio.positions,
 						{
@@ -709,7 +701,7 @@ describe("AccountPage states", () => {
 							type: "CURRENCY",
 						},
 					],
-					structure: { categories: [], hasNegativeValues: false, totalValue: "0", unvaluedCategories: [] },
+					structure: { currencies: [], unvaluedCategories: [] },
 				})}
 			/>,
 		);
@@ -722,12 +714,14 @@ describe("AccountPage states", () => {
 
 		expect(
 			balances.getAllByRole("definition").map(node => node.textContent),
-		).toEqual(["234,50 ₽"]);
+		).toEqual(["234,500000000000000001 ₽", "-0,5 $", "3,00 XYZ"]);
 		expect(
 			screen.getAllByRole("definition").map(node => node.textContent),
 		).toEqual([
-			"1 234,50 ₽",
+			"1 234,5 ₽",
-			"234,50 ₽",
+			"234,500000000000000001 ₽",
+			"-0,5 $",
+			"3,00 XYZ",
 		]);
 		expect(screen.queryByText("Торгуемая валюта")).not.toBeInTheDocument();
 		expect(
@@ -744,7 +738,7 @@ describe("AccountPage states", () => {
 						resource({
 							...portfolio,
 							positions: hasPositions ? portfolio.positions : [],
-							totals: { currency: "RUB", value: "0" },
+							totalsByCurrency: [],
 						}),
 					),
 				),
@@ -752,20 +746,20 @@ describe("AccountPage states", () => {
 			renderAccountRoute(createTestQueryClient());
 			await screen.findByRole("heading", { level: 1, name: "Портфель" });
 			fireEvent.click(screen.getByRole("tab", { name: "Деньги" }));
-			expect(screen.getByText("0,50 ₽")).toBeInTheDocument();
+			expect(screen.getByRole("definition")).toHaveTextContent("0,5 $");
 			expect(screen.queryByText("Портфель пока пуст")).not.toBeInTheDocument();
 		},
 	);
 
 	it.each([
-		{ empty: true, totals: { currency: "RUB", value: "0" } },
+		{ totalsByCurrency: [] },
-		{ empty: false, totals: { currency: "RUB", value: "100" } },
+		{ totalsByCurrency: [{ currency: "RUB", value: "100" }] },
 	])(
-		"hides the empty other section without emptying a currency-only portfolio (totals: $totals.value)",
+		"hides the empty other section without emptying a currency-only portfolio (totals: $totalsByCurrency)",
-		async ({ empty, totals }) => {
+		async ({ totalsByCurrency }) => {
 			const snapshot: Portfolio = {
 				...portfolio,
-				cash: { currency: "RUB", value: "0" },
+				cashBalances: [],
 				positions: [
 					{
 						...portfolio.positions[0],
@@ -774,8 +768,8 @@ describe("AccountPage states", () => {
 						type: "CURRENCY",
 					},
 				],
-				structure: { categories: [], hasNegativeValues: false, totalValue: "0", unvaluedCategories: [] },
+				structure: { currencies: [], unvaluedCategories: [] },
-				totals,
+				totalsByCurrency,
 			};
 
 			server.use(
@@ -796,11 +790,11 @@ describe("AccountPage states", () => {
 			expect(
 				within(
 					screen.getByRole("tabpanel", { name: "Деньги" }),
-				).getByRole("definition"),
+				).queryByRole("definition"),
-			).toHaveTextContent("0,00 ₽");
+			).not.toBeInTheDocument();
 			expect(
 				screen.queryAllByRole("definition").map(node => node.textContent),
-			).toEqual([empty ? "0,00 ₽" : "100,00 ₽", "0,00 ₽"]);
+			).toEqual(totalsByCurrency.length > 0 ? ["100 ₽"] : []);
 			expect(
 				queryClient.getQueryData(portfolioQueryOptions("account-1").queryKey),
 			).toEqual(resource(snapshot));
@@ -820,9 +814,9 @@ describe("AccountPage states", () => {
 		expect(
 			screen.getByRole("heading", { name: "Портфель пока пуст" }),
 		).toBeInTheDocument();
-		expect(screen.getByRole("link", { name: "Открыть историю операций" }))
+		expect(screen.getByRole("link", { name: "Открыть журнал" }))
 			.toBeInTheDocument();
-		expect(screen.getByRole("link", { name: "Открыть предстоящие события" }))
+		expect(screen.getByRole("link", { name: "Открыть будущие события" }))
 			.toBeInTheDocument();
 		expect(screen.getByRole("link", { name: "Открыть пассивный доход" }))
 			.toBeInTheDocument();
@@ -863,10 +857,10 @@ describe("AccountPage states", () => {
 			}),
 		).toBeVisible();
 		expect(
-			screen.getByRole("status", { name: "Загрузка предстоящих событий" }),
+			screen.getByRole("status", { name: "Загрузка будущих событий" }),
 		).toBeVisible();
 		expect(
-			screen.queryByText("На ближайшие 30 дней предстоящих событий не найдено."),
+			screen.queryByText("На ближайшие 30 дней событий не найдено."),
 		).not.toBeInTheDocument();
 		expect(screen.getByText("Загрузка дохода текущего месяца")).toBeVisible();
 		expect(screen.queryByText("Нет текущих сумм")).not.toBeInTheDocument();
@@ -880,6 +874,7 @@ describe("AccountPage states", () => {
 		).toBeInTheDocument();
 		expect(screen.queryByText(/T-Bank временно недоступен/))
 			.not.toBeInTheDocument();
+		expect(screen.queryByText(/Данные получены/)).not.toBeInTheDocument();
 		expect(screen.getByRole("radio", { name: "Акции" })).toBeInTheDocument();
 		expect(
 			screen.getByRole("radio", { name: "Облигации" }),
@@ -1046,7 +1041,7 @@ describe("AccountPage states", () => {
 			/>,
 		);
 
-		fireEvent.click(screen.getByRole("tab", { name: "История операций" }));
+		fireEvent.click(screen.getByRole("tab", { name: "Операции" }));
 		expect(
 			screen.getByText("Пока недоступно"),
 		).toBeInTheDocument();
@@ -1085,7 +1080,7 @@ describe("AccountPage states", () => {
 			/>,
 		);
 
-		fireEvent.click(screen.getByRole("tab", { name: "История операций" }));
+		fireEvent.click(screen.getByRole("tab", { name: "Операции" }));
 		expect(screen.getByText("Сделка")).toBeInTheDocument();
 		expect(screen.getByText("−12 ₽")).toBeInTheDocument();
 	});
@@ -1117,7 +1112,7 @@ describe("AccountPage states", () => {
 							date: "2026-09-11",
 							dateKind: "registry",
 							displayName: "Акция",
-							projectedAmount: { currency: "RUB", value: "0" },
+							projectedAmount: { currency: "USD", value: "0" },
 							type: "dividend",
 						},
 						{
@@ -1139,8 +1134,8 @@ describe("AccountPage states", () => {
 			/>,
 		);
 
-		fireEvent.click(screen.getByRole("tab", { name: "Предстоящие события" }));
+		fireEvent.click(screen.getByRole("tab", { name: "События" }));
-		const section = screen.getByRole("tabpanel", { name: "Предстоящие события" });
+		const section = screen.getByRole("tabpanel", { name: "События" });
 		const content = within(section);
 		const text = section.textContent ?? "";
 
@@ -1161,7 +1156,7 @@ describe("AccountPage states", () => {
 		expect(
 			content.getByText("11.09.2026 · Дата реестра · RU000A0JX0J2"),
 		).toBeVisible();
-		for (const amount of ["850,50 ₽", "0 ₽", "1 000 ₽", "Сумма неизвестна"])
+		for (const amount of ["850,50 ₽", "0 USD", "1 000 ₽", "Сумма неизвестна"])
 			expect(content.getByText(amount)).toBeVisible();
 		expect(content.getAllByText("Прогноз")).toHaveLength(4);
 		expect(content.queryByText("Без движения денег")).not.toBeInTheDocument();
@@ -1181,15 +1176,15 @@ describe("AccountPage states", () => {
 				/>,
 			);
 
-			fireEvent.click(screen.getByRole("tab", { name: "Предстоящие события" }));
+			fireEvent.click(screen.getByRole("tab", { name: "События" }));
 
 			const content = within(
-				screen.getByRole("tabpanel", { name: "Предстоящие события" }),
+				screen.getByRole("tabpanel", { name: "События" }),
 			);
 
 			if (state === "loading") {
 				const skeleton = content.getByRole("status", {
-					name: "Загрузка предстоящих событий",
+					name: "Загрузка будущих событий",
 				});
 
 				// eslint-disable-next-line vitest/no-conditional-expect -- The fixed table case selects the expected outcome; every case asserts its own branch.
@@ -1200,7 +1195,7 @@ describe("AccountPage states", () => {
 			else {
 				// eslint-disable-next-line vitest/no-conditional-expect -- The table case deterministically selects the empty state.
 				expect(
-					content.getByText("На ближайшие 30 дней предстоящих событий не найдено."),
+					content.getByText("На ближайшие 30 дней событий не найдено."),
 				).toBeVisible();
 			}
 
@@ -1221,7 +1216,7 @@ describe("AccountPage states", () => {
 			/>,
 		);
 
-		fireEvent.click(screen.getByRole("tab", { name: "Предстоящие события" }));
+		fireEvent.click(screen.getByRole("tab", { name: "События" }));
 		expect(
 			screen.getByText("Данные появятся здесь, когда чтение восстановится."),
 		).toBeInTheDocument();
@@ -1229,110 +1224,6 @@ describe("AccountPage states", () => {
 		expect(screen.getByText("Вторая")).toBeInTheDocument();
 	});
 
-	it(
-		"keeps cached totals, then warns and retries the same portfolio GET",
-		{ timeout: TEST_MS },
-		async () => {
-			let isFailing = false;
-			let requests = 0;
-			server.use(
-				http.get("*/api/v1/brokerage-accounts/:accountId/portfolio", () => {
-					requests += 1;
-					if (isFailing)
-						return HttpResponse.json(
-							{ code: "TBANK_UNAVAILABLE" },
-							{ status: 503 },
-						);
-
-					return HttpResponse.json(resource(
-						requests === 1
-							? portfolio
-							: { ...portfolio, totals: { currency: "RUB", value: "999" } },
-						{ resourceKey: "portfolio" },
-					));
-				}),
-			);
-			const queryClient = createTestQueryClient();
-			renderAccountRoute(queryClient);
-			await screen.findByText("Вторая");
-			expect(screen.queryByRole("button", { name: "Повторить" }))
-				.not.toBeInTheDocument();
-
-			isFailing = true;
-			void queryClient.invalidateQueries({
-				queryKey: portfolioQueryOptions("account-1").queryKey,
-			});
-
-			const retry = await screen.findByRole(
-				"button",
-				{ name: "Повторить" },
-				{ timeout: RETRIES_EXHAUSTED_MS },
-			);
-
-			expect(screen.getByText("Не удалось обновить данные")).toBeInTheDocument();
-			expect(screen.getByText("Вторая")).toBeInTheDocument();
-			expect(screen.getByText("1 234,50 ₽")).toBeInTheDocument();
-			// One cached read plus the three automatic attempts.
-			expect(requests).toBe(4);
-
-			isFailing = false;
-			fireEvent.click(retry);
-
-			expect(await screen.findByText("999,00 ₽")).toBeInTheDocument();
-			expect(requests).toBe(5);
-			expect(screen.queryByText("Не удалось обновить данные"))
-				.not.toBeInTheDocument();
-			expect(screen.queryByRole("button", { name: "Повторить" }))
-				.not.toBeInTheDocument();
-		},
-	);
-
-	it(
-		"offers retry after an initial temporary failure and recovers in place",
-		{ timeout: TEST_MS },
-		async () => {
-			let isFailing = true;
-			let requests = 0;
-			server.use(
-				http.get("*/api/v1/brokerage-accounts/:accountId/portfolio", () => {
-					requests += 1;
-
-					return isFailing
-						? HttpResponse.json({ code: "TBANK_UNAVAILABLE" }, { status: 503 })
-						: HttpResponse.json(resource(portfolio, { resourceKey: "portfolio" }));
-				}),
-			);
-			renderAccountRoute(createTestQueryClient());
-
-			const retry = await screen.findByRole(
-				"button",
-				{ name: "Повторить" },
-				{ timeout: RETRIES_EXHAUSTED_MS },
-			);
-
-			expect(requests).toBe(3);
-			isFailing = false;
-			fireEvent.click(retry);
-
-			expect(await screen.findByText("Вторая")).toBeInTheDocument();
-			expect(requests).toBe(4);
-		},
-	);
-
-	it.each(["NOT_FOUND", "UNAUTHORIZED"])(
-		"does not offer a plain retry for %s after a cached portfolio",
-		async (code) => {
-			server.use(
-				http.get("*/api/v1/brokerage-accounts/:accountId/portfolio", () =>
-					HttpResponse.json({ code }, { status: code === "NOT_FOUND" ? 404 : 401 })),
-			);
-			renderAccountRoute(createTestQueryClient());
-			await waitFor(() =>
-				expect(screen.queryByRole("heading", { name: "Загрузка" })).not.toBeInTheDocument());
-			expect(screen.queryByRole("button", { name: "Повторить" })).not.toBeInTheDocument();
-		},
-	);
-
 	it.each([503])(
 		"preserves totals quietly through refresh error %i and success",
 		async (status) => {
@@ -1340,9 +1231,14 @@ describe("AccountPage states", () => {
 				= {
 					...portfolio,
 					structure: {
+						currencies: [
+							{
 								categories: [{ sharePercent: null, type: "BOND", value: "10" }],
+								currency: "RUB",
 								hasNegativeValues: false,
 								totalValue: "10",
+							},
+						],
 						unvaluedCategories: [{ count: 1, type: "STOCK" }],
 					},
 				};
@@ -1380,7 +1276,7 @@ describe("AccountPage states", () => {
 			});
 
 			expect(structure).toHaveTextContent("10 ₽");
-			expect(screen.getByText(/^Данные на /)).toBeInTheDocument();
+			expect(screen.queryByText(/Данные получены/)).not.toBeInTheDocument();
 			void queryClient.invalidateQueries({
 				queryKey: portfolioQueryOptions("account-1").queryKey,
 			});
@@ -1393,7 +1289,7 @@ describe("AccountPage states", () => {
 			expect(screen.getByText("Вторая")).toBeInTheDocument();
 			expect(
 				screen.getAllByRole("definition").map(node => node.textContent),
-			).toEqual(["1 234,50 ₽"]);
+			).toEqual(["1 234,5 ₽"]);
 			expect(screen.queryByRole("button", { name: "Повторить" }))
 				.not.toBeInTheDocument();
 			void queryClient.invalidateQueries({
@@ -1403,17 +1299,17 @@ describe("AccountPage states", () => {
 			expect(structure).toHaveTextContent("10 ₽");
 			expect(
 				screen.getAllByRole("definition").map(node => node.textContent),
-			).toEqual(["1 234,50 ₽"]);
+			).toEqual(["1 234,5 ₽"]);
 			resolveRetry?.(
 				HttpResponse.json(
 					resource(
 						{
 							...portfolio,
-							cash: { currency: "RUB", value: "2.50" },
+							cashBalances: [{ currency: "EUR", value: "2.50" }],
 							isStale: false,
 							lastSuccessfulAt: "2026-08-14T11:30:00Z",
-							structure: { categories: [], hasNegativeValues: false, totalValue: "0", unvaluedCategories: [] },
+							structure: { currencies: [], unvaluedCategories: [] },
-							totals: { currency: "RUB", value: "-0.5" },
+							totalsByCurrency: [{ currency: "USD", value: "-0.5" }],
 						},
 						{ dataRevision: "2", resourceKey: "portfolio" },
 					),
@@ -1422,9 +1318,9 @@ describe("AccountPage states", () => {
 			await waitFor(() =>
 				expect(
 					screen.getAllByRole("definition").map(node => node.textContent),
-				).toEqual(["-0,50 ₽"]),
+				).toEqual(["-0,5 $"]),
 			);
-			expect(screen.getByText(/^Данные на /)).toHaveTextContent("Данные на");
+			expect(screen.queryByText(/Данные получены/)).not.toBeInTheDocument();
 			expect(structure).not.toHaveTextContent("10 ₽");
 			expect(structure).toHaveTextContent("Нет положительной стоимости");
 			expect(
@@ -1464,8 +1360,8 @@ describe("AccountPage states", () => {
 		expect(screen.getByText("Вторая")).toBeInTheDocument();
 		expect(
 			screen.getAllByRole("definition").map(node => node.textContent),
-		).toEqual(["1 234,50 ₽"]);
+		).toEqual(["1 234,5 ₽"]);
-		expect(screen.getByText(/^Данные на /)).toBeInTheDocument();
+		expect(screen.queryByText(/Данные получены/)).not.toBeInTheDocument();
 		expect(
 			screen.queryByRole("status", { name: "Загрузка" }),
 		).not.toBeInTheDocument();
@@ -1487,8 +1383,8 @@ describe("AccountPage states", () => {
 			.toBeVisible();
 		expect(screen.queryByText("Вторая")).not.toBeInTheDocument();
 
-		fireEvent.click(screen.getByRole("tab", { name: "История операций" }));
+		fireEvent.click(screen.getByRole("tab", { name: "Операции" }));
-		expect(screen.getByText("Последних операций пока нет.")).toBeVisible();
+		expect(screen.getByText("Последних событий пока нет.")).toBeVisible();
 	});
 
 	it("links operation, event and income previews to their detail pages", () => {
@@ -1503,8 +1399,8 @@ describe("AccountPage states", () => {
 		);
 
 		for (const [tab, href] of [
-			["История операций", "/accounts/account-1/operations"],
+			["Операции", "/accounts/account-1/operations"],
-			["Предстоящие события", "/accounts/account-1/events"],
+			["События", "/accounts/account-1/events"],
 			["Доход", "/accounts/account-1/income"],
 		]) {
 			fireEvent.click(screen.getByRole("tab", { name: tab }));
@@ -1620,7 +1516,7 @@ describe("AccountPage states", () => {
 		await screen.findByRole("heading", { level: 1, name: "Все счета" });
 
 		const operationGroup = screen.getByRole("list", {
-			name: /Выплата купонов BOND, Исполнено/,
+			name: /Купон · BOND, Исполнено/,
 		});
 
 		expect(screen.getByText("+500 ₽")).toBeInTheDocument();

src/pages/account/ui/AccountPage/AccountPage.tsx

@@ -1,46 +1,45 @@
 import type { FC } from "react";
 
-import { useAccountPageVm } from "./AccountPage.vm";
+import { useAccountPageViewModel } from "./AccountPage.vm";
 import { AccountPageEmpty } from "./components/AccountPageEmpty.view";
 import { AccountPageError } from "./components/AccountPageError.view";
 import { AccountPageLoaded } from "./components/AccountPageLoaded.view";
 import { AccountPageLoading } from "./components/AccountPageLoading/AccountPageLoading.view";
 
 const AccountPage: FC = () => {
-	const vm = useAccountPageVm();
+	const viewModel = useAccountPageViewModel();
-	if (vm.state === "loading") return <AccountPageLoading />;
+	if (viewModel.state === "loading") return <AccountPageLoading />;
-	if (vm.state === "error") return <AccountPageError {...vm} />;
+	if (viewModel.state === "error") return <AccountPageError {...viewModel} />;
-	if (vm.state === "empty")
+	if (viewModel.state === "empty")
 		return (
 			<AccountPageEmpty
-				account={vm.account}
+				account={viewModel.account}
-				accountId={vm.accountId}
+				accountId={viewModel.accountId}
-				incomeSummary={vm.incomeSummary}
+				incomeSummary={viewModel.incomeSummary}
-				readRetry={vm.readRetry}
+				recentEvents={viewModel.recentEvents}
-				recentEvents={vm.recentEvents}
+				recentOperations={viewModel.recentOperations}
-				recentOperations={vm.recentOperations}
-				source={vm.source}
 			/>
 		);
 
 	return (
 		<AccountPageLoaded
-			account={vm.account}
+			account={viewModel.account}
-			accountId={vm.accountId}
+			accountId={viewModel.accountId}
-			concentration={vm.concentration}
+			concentration={viewModel.concentration}
-			incomeSummary={vm.incomeSummary}
+			currency={viewModel.currency}
-			onSliceChange={vm.onSliceChange}
+			incomeSummary={viewModel.incomeSummary}
-			onTabChange={vm.onTabChange}
+			onCurrencyChange={viewModel.onCurrencyChange}
-			partial={vm.partial}
+			onSliceChange={viewModel.onSliceChange}
-			portfolio={vm.portfolio}
+			onTabChange={viewModel.onTabChange}
-			positionSections={vm.positionSections}
+			partial={viewModel.partial}
-			readRetry={vm.readRetry}
+			portfolio={viewModel.portfolio}
-			recentEvents={vm.recentEvents}
+			positionSections={viewModel.positionSections}
-			recentOperations={vm.recentOperations}
+			recentEvents={viewModel.recentEvents}
-			slice={vm.slice}
+			recentOperations={viewModel.recentOperations}
-			source={vm.source}
+			slice={viewModel.slice}
-			tab={vm.tab}
+			source={viewModel.source}
-			unrealizedReturns={vm.unrealizedReturns}
+			tab={viewModel.tab}
+			unrealizedReturns={viewModel.unrealizedReturns}
 		/>
 	);
 };

src/pages/account/ui/AccountPage/AccountPage.vm.test.tsx

@@ -12,7 +12,7 @@ import { resource } from "@/test/resource";
 import { server } from "@/test/server";
 
 import { portfolio } from "../../model/positions.fixtures";
-import { useAccountPageVm } from "./AccountPage.vm";
+import { useAccountPageViewModel } from "./AccountPage.vm";
 
 function configureTestAuth() {
 	configureAuthClient({
@@ -102,12 +102,12 @@ function mockLoadedAccountPage() {
 	);
 }
 
-describe("useAccountPageVm", () => {
+describe("useAccountPageViewModel", () => {
 	it("prepares recent operations and events state for presentation views", async () => {
 		configureTestAuth();
 		mockLoadedAccountPage();
 
-		const { result } = renderHook(() => useAccountPageVm(), {
+		const { result } = renderHook(() => useAccountPageViewModel(), {
 			wrapper: createWrapper(),
 		});
 
@@ -154,7 +154,7 @@ describe("useAccountPageVm", () => {
 			),
 		);
 
-		const { result } = renderHook(() => useAccountPageVm(), {
+		const { result } = renderHook(() => useAccountPageViewModel(), {
 			wrapper: createWrapper(),
 		});
 
@@ -187,14 +187,14 @@ it("keeps overview sections independent when their source data is incomplete", a
 		http.get("*/api/v1/brokerage-accounts/:accountId/events", () =>
 			HttpResponse.json(
 				resource(
-					{ events: [], incomeTotal: { currency: "RUB", value: "0" } },
+					{ events: [], incomeTotalsByCurrency: [] },
 					{ completeness: "incomplete" },
 				),
 			),
 		),
 	);
 
-	const { result } = renderHook(() => useAccountPageVm(), {
+	const { result } = renderHook(() => useAccountPageViewModel(), {
 		wrapper: createWrapper(),
 	});
 
@@ -213,8 +213,8 @@ it("keeps overview sections loaded without exposing technical retry", async () =
 
 	const sections: Record<string, unknown>
 		= {
-			"events": { events: [], incomeTotal: { currency: "RUB", value: "0" } },
+			"events": { events: [], incomeTotalsByCurrency: [] },
-			"income-summary": { total: { coupon: { currency: "RUB", value: "0" }, dividend: { currency: "RUB", value: "0" }, total: { currency: "RUB", value: "0" } } },
+			"income-summary": { totalsByCurrency: [] },
 			"operations": { hasNext: false, items: [], nextCursor: null },
 			portfolio,
 		};
@@ -232,13 +232,13 @@ it("keeps overview sections loaded without exposing technical retry", async () =
 		),
 	);
 
-	const { result } = renderHook(() => useAccountPageVm(), {
+	const { result } = renderHook(() => useAccountPageViewModel(), {
 		wrapper: createWrapper(),
 	});
 
 	await waitFor(() =>
 		expect(result.current).toMatchObject({
-			incomeSummary: { state: "loaded" },
+			incomeSummary: { state: "empty" },
 			recentEvents: { state: "empty" },
 			recentOperations: { state: "empty" },
 			state: "loaded",

src/pages/account/ui/AccountPage/AccountPage.vm.ts

@@ -16,11 +16,12 @@ import {
 import { useIncomeSummary } from "@/entities/income";
 import { usePortfolio } from "@/entities/portfolio";
 import { useScreenSync } from "@/features/tbank-connection";
-import { apiErrorCode, isBrokerageAccessLoss, readRetry } from "@/shared/api";
+import { ApiErrorCode, apiErrorCode, isApiErrorCode } from "@/shared/api";
 import { useInitialAvailability } from "@/shared/lib";
 
 import {
 	type Concentration,
+	concentrationCurrencies,
 	type ConcentrationLabels,
 	type Slice,
 	toConcentration,
@@ -44,10 +45,8 @@ type AccountPageContent = {
 	accountId?: string;
 	incomeSummary: AccountPageIncomeSummary;
 	partial?: boolean;
-	readRetry: AccountPageReadRetry;
 	recentEvents: AccountPageRecentEvents;
 	recentOperations: AccountPageRecentOperations;
-	source?: InvestmentResourceMeta;
 };
 
 type AccountPageEmptyViewModel = AccountPageContent & {
@@ -56,40 +55,46 @@ type AccountPageEmptyViewModel = AccountPageContent & {
 
 type AccountPageLoadedViewModel = AccountPageContent & {
 	concentration: Concentration | null;
+	currency: null | string;
+	onCurrencyChange: (currency: null | string) => void;
 	onSliceChange: (slice: Slice) => void;
 	onTabChange: (tab: null | string) => void;
 	portfolio: Portfolio;
 	positionSections: AccountPagePositionSection[];
 	slice: Slice;
+	source?: InvestmentResourceMeta;
 	state: "loaded";
 	tab: string;
-	unrealizedReturns:
+	unrealizedReturns: Portfolio["totalsByCurrency"];
-		| null
-		| { currency: string; value: string };
 };
 
-type AccountPageReadRetry = ReturnType<typeof readRetry>;
-
 type AccountPageViewModel
 	= | AccountPageEmptyViewModel
 		| AccountPageLoadedViewModel
-		| { code?: string; readRetry: AccountPageReadRetry; state: "error" }
+		| { code?: string; state: "error" }
 		| { state: "loading" };
 
-function useAccountPageVm(): AccountPageViewModel {
+function isPortfolioAccessFailure(code?: string) {
+	return isApiErrorCode(code, ApiErrorCode.InvalidTbankToken)
+		|| isApiErrorCode(code, ApiErrorCode.NotFound)
+		|| isApiErrorCode(code, ApiErrorCode.TbankNotConnected);
+}
+
+function useAccountPageViewModel(): AccountPageViewModel {
 	const { accountId } = useParams();
 	const { t } = useTranslation();
 
 	const [selection, setSelection] = useState<{
 		accountId?: string;
+		currency: null | string;
 		slice: Slice;
 		tab: string;
-	}>({ accountId, slice: "stocks", tab: "positions" });
+	}>({ accountId, currency: null, slice: "stocks", tab: "positions" });
 
 	const current = selection.accountId === accountId
 		? selection
 		: {
-				accountId, slice: "stocks" as const, tab: "positions",
+				accountId, currency: null, slice: "stocks" as const, tab: "positions",
 			};
 
 	const updateSelection = (change: Partial<typeof selection>) =>
@@ -114,9 +119,7 @@ function useAccountPageVm(): AccountPageViewModel {
 	]);
 
 	const code = apiErrorCode(portfolio.error);
-	// The portfolio drives this screen; the retry repeats only its GET.
+	const isAccessFailure = isPortfolioAccessFailure(code);
-	const retry = readRetry([portfolio]);
-	const isAccessFailure = isBrokerageAccessLoss(code);
 
 	const availability = useInitialAvailability({
 		hasContent: !!portfolio.data,
@@ -125,13 +128,12 @@ function useAccountPageVm(): AccountPageViewModel {
 		isFetching: portfolio.isFetching,
 	});
 
-	if (isAccessFailure)
+	if (isAccessFailure) return { code, state: "error" as const };
-		return { code, readRetry: retry, state: "error" as const };
 
 	if (!portfolio.data)
-		return availability === "unavailable"
+		return {
-			? { code, readRetry: retry, state: "error" as const }
+			state: availability === "unavailable" ? "error" : "loading",
-			: { state: "loading" as const };
+		} as const;
 
 	const account = accounts.data?.find(item => item.id === accountId);
 	const recentOperations = toRecentOperations(accountId, operations);
@@ -142,20 +144,23 @@ function useAccountPageVm(): AccountPageViewModel {
 	if (
 		portfolio.meta?.availability === "available"
 		&& portfolio.data.positions.length === 0
-		&& Number(portfolio.data.cash.value) === 0
+		&& portfolio.data.cashBalances.length === 0
 	)
 		return {
 			account,
 			accountId,
 			incomeSummary,
-			readRetry: retry,
 			recentEvents,
 			recentOperations,
-			source: portfolio.meta,
 			state: "empty" as const,
 		};
 
 	const isPartial = portfolio.meta?.completeness === "incomplete";
+	const currencies = concentrationCurrencies(portfolio.data);
+
+	const currency = current.currency && currencies.includes(current.currency)
+		? current.currency
+		: currencies[0] ?? null;
 
 	const labels: ConcentrationLabels = {
 		missingIssuer: t("portfolio.concentration.missingIssuer"),
@@ -166,20 +171,21 @@ function useAccountPageVm(): AccountPageViewModel {
 
 	const concentration = accountId !== "all"
 		&& current.tab === "concentration"
-		? toConcentration(portfolio.data, current.slice, labels)
+		? toConcentration(portfolio.data, current.slice, currency, labels)
 		: null;
 
 	return {
 		account,
 		accountId,
 		concentration,
+		currency,
 		incomeSummary,
+		onCurrencyChange: value => updateSelection({ currency: value }),
 		onSliceChange: slice => updateSelection({ slice }),
 		onTabChange: tab => updateSelection({ tab: tab ?? "positions" }),
 		partial: isPartial,
 		portfolio: portfolio.data,
 		positionSections: toAccountPagePositionSections(portfolio.data),
-		readRetry: retry,
 		recentEvents,
 		recentOperations,
 		slice: current.slice,
@@ -190,4 +196,4 @@ function useAccountPageVm(): AccountPageViewModel {
 	};
 }
 
-export { useAccountPageVm };
+export { useAccountPageViewModel };

src/pages/account/ui/AccountPage/components/AccountPageEmpty.view.tsx

@@ -5,10 +5,9 @@ import { StateView } from "@wealthledger/ui";
 import { useTranslation } from "react-i18next";
 
 import type { BrokerageAccount } from "@/entities/brokerage-account";
-import type { InvestmentResourceMeta } from "@/shared/api";
 
 import { BrokerageEventsPreview } from "@/entities/brokerage-event";
-import { ReadRetry, type ReadRetryProps, SourceSyncStatus } from "@/shared/ui";
+import { PortfolioStructure } from "@/widgets/portfolio-structure";
 
 import type {
 	AccountPageIncomeSummary,
@@ -18,17 +17,14 @@ import type {
 
 import { AccountHeading } from "./AccountHeading.view";
 import { IncomeSummary } from "./IncomeSummary.view";
-import { PortfolioStructure } from "./PortfolioStructure/PortfolioStructure";
 import { RecentOperations } from "./RecentOperations.view";
 
 type AccountPageEmptyProps = {
 	account?: BrokerageAccount;
 	accountId?: string;
 	incomeSummary?: AccountPageIncomeSummary;
-	readRetry?: ReadRetryProps;
 	recentEvents: AccountPageRecentEvents;
 	recentOperations: AccountPageRecentOperations;
-	source?: InvestmentResourceMeta;
 };
 
 const AccountPageEmpty: FC<AccountPageEmptyProps> = (props) => {
@@ -44,23 +40,10 @@ const AccountPageEmpty: FC<AccountPageEmptyProps> = (props) => {
 		<Stack>
 			<AccountHeading account={props.account} accountId={props.accountId} />
 
-			<SourceSyncStatus
-				lastAttempt={props.source?.lastAttempt}
-				lastSuccessfulAt={props.source?.lastSuccessfulAt}
-				stale={props.source?.freshness === "stale"}
-			/>
-
-			{!!props.readRetry && <ReadRetry {...props.readRetry} />}
-
 			<StateView text={text} title={t("portfolio.emptyTitle")} />
 
 			<PortfolioStructure
-				structure={{
+				structure={{ currencies: [], unvaluedCategories: [] }}
-					categories: [],
-					hasNegativeValues: false,
-					totalValue: "0",
-					unvaluedCategories: [],
-				}}
 			/>
 
 			<RecentOperations

src/pages/account/ui/AccountPage/components/AccountPageError.view.tsx

@@ -6,12 +6,8 @@ import { useTranslation } from "react-i18next";
 import { Link } from "react-router";
 
 import { ApiErrorCode, isApiErrorCode } from "@/shared/api";
-import { ReadRetryButton, type ReadRetryProps } from "@/shared/ui";
 
-type AccountPageErrorProps = {
+type AccountPageErrorProps = { code?: string };
-	code?: string;
-	readRetry?: ReadRetryProps;
-};
 
 const AccountPageError: FC<AccountPageErrorProps> = (props) => {
 	const { code } = props;
@@ -47,18 +43,8 @@ const AccountPageError: FC<AccountPageErrorProps> = (props) => {
 			/>
 		);
 
-	const retry = props.readRetry?.exhausted
-		? (
-				<ReadRetryButton
-					onRetry={props.readRetry.onRetry}
-					retrying={props.readRetry.retrying}
-				/>
-			)
-		: undefined;
-
 	return (
 		<StateView
-			action={retry}
 			text={t("states.unavailableText")}
 			title={t("states.unavailableTitle")}
 		/>

src/pages/account/ui/AccountPage/components/AccountPageLoaded.view.tsx

@@ -15,7 +15,8 @@ import type { InvestmentResourceMeta } from "@/shared/api";
 
 import { BrokerageEventsPreview } from "@/entities/brokerage-event";
 import { formatMoney } from "@/shared/lib";
-import { ReadRetry, type ReadRetryProps, SourceSyncStatus } from "@/shared/ui";
+import { SourceSyncStatus } from "@/shared/ui";
+import { PortfolioStructure } from "@/widgets/portfolio-structure";
 
 import type { Concentration as ConcentrationModel, Slice } from "../../../model/concentration";
 import type { AccountPagePositionSection } from "../../../model/positions";
@@ -28,9 +29,8 @@ import type {
 import classes from "../AccountPage.module.css";
 import { AccountHeading } from "./AccountHeading.view";
 import { Concentration } from "./Concentration/Concentration.view";
+import { CurrencyCards } from "./CurrencyCards/CurrencyCards.view";
 import { IncomeSummary } from "./IncomeSummary.view";
-import { PerformanceTab } from "./Performance/PerformanceTab";
-import { PortfolioStructure } from "./PortfolioStructure/PortfolioStructure";
 import { PositionSection } from "./PositionSection.view";
 import { RecentOperations } from "./RecentOperations.view";
 
@@ -38,21 +38,20 @@ type AccountPageLoadedProps = {
 	account?: BrokerageAccount;
 	accountId?: string;
 	concentration: ConcentrationModel | null;
+	currency: null | string;
 	incomeSummary?: AccountPageIncomeSummary;
+	onCurrencyChange: (currency: null | string) => void;
 	onSliceChange: (slice: Slice) => void;
 	onTabChange: (tab: null | string) => void;
 	partial?: boolean;
 	portfolio: Portfolio;
 	positionSections: AccountPagePositionSection[];
-	readRetry?: ReadRetryProps;
 	recentEvents: AccountPageRecentEvents;
 	recentOperations: AccountPageRecentOperations;
 	slice: Slice;
 	source?: InvestmentResourceMeta;
 	tab: string;
-	unrealizedReturns:
+	unrealizedReturns: Portfolio["totalsByCurrency"];
-		| null
-		| { currency: string; value: string };
 };
 
 const AccountPageLoaded: FC<AccountPageLoadedProps> = (props) => {
@@ -87,29 +86,13 @@ const AccountPageLoaded: FC<AccountPageLoadedProps> = (props) => {
 				stale={props.source?.freshness === "stale"}
 			/>
 
-			{!!props.readRetry && <ReadRetry {...props.readRetry} />}
-
 			{props.partial
 				? tab !== "concentration" && (
 					<Alert role="status">{t("investment.partial")}</Alert>
 				)
-				: (
+				: <CurrencyCards amounts={props.portfolio.totalsByCurrency} />}
-						<Stack component="dl" gap={4} m={0}>
-							<dt>
-								<Text fw={600}>{t("portfolio.total")}</Text>
-							</dt>
 
-							<dd style={{ margin: 0 }}>
+			{!props.partial && props.unrealizedReturns.length > 0 && (
-								<Text className={classes.totalAmount}>
-									{formatMoney(props.portfolio.totals, {
-										withRoundedCents: true,
-									})}
-								</Text>
-							</dd>
-						</Stack>
-					)}
-
-			{!props.partial && props.unrealizedReturns && (
 				<Stack
 					aria-label={t("portfolio.unrealizedResult")}
 					component="section"
@@ -118,7 +101,9 @@ const AccountPageLoaded: FC<AccountPageLoadedProps> = (props) => {
 					<Text fw={600}>{t("portfolio.unrealizedResult")}</Text>
 
 					<Group gap="md">
-						<Text>{formatMoney(props.unrealizedReturns)}</Text>
+						{props.unrealizedReturns.map(total => (
+							<Text key={total.currency}>{formatMoney(total)}</Text>
+						))}
 					</Group>
 
 					<Text c="dimmed" size="xs">
@@ -160,8 +145,6 @@ const AccountPageLoaded: FC<AccountPageLoadedProps> = (props) => {
 					<Tabs.Tab value="events">{t("portfolio.tabs.events")}</Tabs.Tab>
 
 					<Tabs.Tab value="income">{t("portfolio.tabs.income")}</Tabs.Tab>
-
-					<Tabs.Tab value="performance">{t("portfolio.tabs.performance")}</Tabs.Tab>
 				</Tabs.List>
 
 				<Tabs.Panel value="positions">
@@ -185,8 +168,10 @@ const AccountPageLoaded: FC<AccountPageLoadedProps> = (props) => {
 					<Tabs.Panel value="concentration">
 						{props.concentration && (
 							<Concentration
-								key={props.slice}
+								currency={props.currency}
+								key={`${props.slice}-${props.currency}`}
 								model={props.concentration}
+								onCurrencyChange={props.onCurrencyChange}
 								onSliceChange={props.onSliceChange}
 								partial={!!props.partial}
 								slice={props.slice}
@@ -196,17 +181,7 @@ const AccountPageLoaded: FC<AccountPageLoadedProps> = (props) => {
 				)}
 
 				<Tabs.Panel value="cash">
-					<Stack component="dl" gap={4} m={0}>
+					<CurrencyCards amounts={props.portfolio.cashBalances} />
-						<dt>
-							<Text fw={600}>{t("portfolio.cashTitle")}</Text>
-						</dt>
-
-						<dd style={{ margin: 0 }}>
-							<Text>
-								{formatMoney(props.portfolio.cash, { withRoundedCents: true })}
-							</Text>
-						</dd>
-					</Stack>
 				</Tabs.Panel>
 
 				<Tabs.Panel value="operations">
@@ -233,10 +208,6 @@ const AccountPageLoaded: FC<AccountPageLoadedProps> = (props) => {
 						/>
 					)}
 				</Tabs.Panel>
-
-				<Tabs.Panel value="performance">
-					{props.accountId && <PerformanceTab accountId={props.accountId} />}
-				</Tabs.Panel>
 			</Tabs>
 		</Stack>
 	);

src/pages/account/ui/AccountPage/components/Concentration/Concentration.view.tsx

@@ -1,6 +1,6 @@
 import { DonutChart } from "@mantine/charts";
 import {
-	Alert, Box, Group, Paper, SegmentedControl, Stack,
+	Alert, Box, Group, Paper, SegmentedControl, Select, Stack,
 	Text, Title,
 } from "@mantine/core";
 import { type FC, useId, useState } from "react";
@@ -18,7 +18,9 @@ import { PositionLogo } from "../PositionLogo.view";
 import classes from "./Concentration.module.css";
 
 type Props = {
+	currency: null | string;
 	model: ConcentrationModel;
+	onCurrencyChange: (currency: null | string) => void;
 	onSliceChange: (slice: Slice) => void;
 	partial: boolean;
 	slice: Slice;
@@ -33,6 +35,7 @@ const sliceLabels = {
 
 type RowProps = {
 	color: string;
+	currency: string;
 	index: number;
 	item: ConcentrationItem;
 	logo?: ConcentrationItem["logo"];
@@ -47,8 +50,8 @@ const colors = [
 const PERCENT = 100;
 const OTHER_START = 6;
 
-function amountFor(item: ConcentrationItem): string {
+function amountFor(item: ConcentrationItem, currency: string): string {
-	return formatMoney({ currency: "RUB", value: item.amount });
+	return formatMoney({ currency, value: item.amount });
 }
 
 const ConcentrationRow: FC<RowProps> = props => (
@@ -80,7 +83,7 @@ const ConcentrationRow: FC<RowProps> = props => (
 		</span>
 
 		<span className={classes.value}>
-			<strong>{amountFor(props.item)}</strong>
+			<strong>{amountFor(props.item, props.currency)}</strong>
 
 			<Text c="dimmed" size="sm">{props.item.share}</Text>
 		</span>
@@ -128,6 +131,7 @@ const Concentration: FC<Props> = (props) => {
 	const [expanded, setExpanded] = useState(false);
 	const otherId = useId();
 	const chartId = useId();
+	const currency = props.currency ?? "";
 
 	const rows = props.model.other
 		? [...props.model.items, props.model.other]
@@ -143,8 +147,10 @@ const Concentration: FC<Props> = (props) => {
 		props.model.top5Share && t("portfolio.concentration.top5", {
 			share: props.model.top5Share,
 		}),
-		props.model.total && formatMoney({ currency: "RUB", value: props.model.total }),
+		props.model.total && formatMoney({
-		...rows.map(item => `${item.label}: ${amountFor(item)}, ${item.share}`),
+			currency, value: props.model.total,
+		}),
+		...rows.map(item => `${item.label}: ${amountFor(item, currency)}, ${item.share}`),
 	].filter(Boolean).join("; ");
 
 	const slices = [
@@ -164,7 +170,7 @@ const Concentration: FC<Props> = (props) => {
 	const pieProps = { isAnimationActive: false, label: rankLabel };
 
 	const tooltipRows = rows.map(item => ({
-		amount: amountFor(item),
+		amount: amountFor(item, currency),
 		label: item.label,
 		share: item.share,
 	}));
@@ -172,7 +178,7 @@ const Concentration: FC<Props> = (props) => {
 	const tooltipProps = { content: <ChartTooltip rows={tooltipRows} /> };
 
 	const totalText = props.model.total
-		? formatMoney({ currency: "RUB", value: props.model.total })
+		? formatMoney({ currency, value: props.model.total })
 		: "";
 
 	return (
@@ -186,6 +192,16 @@ const Concentration: FC<Props> = (props) => {
 					value={props.slice}
 				/>
 
+				{props.model.currencies.length > 1 && (
+					<Select
+						allowDeselect={false}
+						aria-label={t("portfolio.concentration.currency")}
+						data={props.model.currencies}
+						onChange={props.onCurrencyChange}
+						value={props.currency}
+						w={130}
+					/>
+				)}
 			</Group>
 
 			{props.partial && (
@@ -195,7 +211,9 @@ const Concentration: FC<Props> = (props) => {
 			{props.model.empty
 				? (
 						<Stack gap="xs">
-							<Text fw={600}>{t(sliceLabels[props.slice])}</Text>
+							<Text fw={600}>{t(sliceLabels[props.slice])}
+								{props.currency && ` · ${props.currency}`}
+							</Text>
 
 							<Text>{t("portfolio.concentration.empty")}</Text>
 						</Stack>
@@ -242,6 +260,7 @@ const Concentration: FC<Props> = (props) => {
 									{props.model.items.map((item, index) => (
 										<ConcentrationRow
 											color={colors[index % colors.length] ?? "blue"}
+											currency={currency}
 											index={index + 1}
 											item={item}
 											key={item.key}
@@ -266,7 +285,7 @@ const Concentration: FC<Props> = (props) => {
 											)}
 											</span>
 
-											<span>{amountFor(props.model.other)} · {
+											<span>{amountFor(props.model.other, currency)} · {
 												props.model.other.share
 											}
 											</span>
@@ -282,6 +301,7 @@ const Concentration: FC<Props> = (props) => {
 												<ConcentrationRow
 													color={colors[(index + OTHER_START) % colors.length]
 														?? "blue"}
+													currency={currency}
 													index={index + OTHER_START}
 													item={item}
 													key={item.key}

src/pages/account/ui/AccountPage/components/CurrencyCards/CurrencyCards.test.tsx

@@ -0,0 +1,77 @@
+import { MantineProvider } from "@mantine/core";
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+
+import { CurrencyCards } from "./CurrencyCards.view";
+
+describe("CurrencyCards currency presentation", () => {
+	it.each([0, 5])(
+		"renders only the %i supplied totals in upstream order",
+		(count) => {
+			const totals = [
+				{ currency: "EUR", value: "3.00" },
+				{ currency: "USD", value: "2.00" },
+				{ currency: "RUB", value: "1.00" },
+				{ currency: "CAD", value: "4.00" },
+				{ currency: "XYZ", value: "5.00" },
+			].slice(0, count);
+
+			const { container } = render(
+				<MantineProvider>
+					<CurrencyCards amounts={totals} />
+				</MantineProvider>,
+			);
+
+			expect(
+				screen.queryAllByRole("definition").map(node => node.textContent),
+			).toEqual(
+				["3,00 €", "2,00 $", "1,00 ₽", "4,00 CAD", "5,00 XYZ"].slice(0, count),
+			);
+			// eslint-disable-next-line testing-library/no-container, testing-library/no-node-access -- This assertion checks DOM structure, decoration or focus behavior that semantic queries cannot establish.
+			expect(container.querySelectorAll("dl")).toHaveLength(count);
+			expect(
+				// eslint-disable-next-line testing-library/no-container, testing-library/no-node-access -- This assertion checks DOM structure, decoration or focus behavior that semantic queries cannot establish.
+				container.querySelector("[tabindex], button, a, input"),
+			).toBeNull();
+		},
+	);
+
+	it.each([
+		["RUB", "125000.50", "125 000,50 ₽", "Российский рубль", "₽"],
+		["USD", "320.00", "320,00 $", "Доллар США", "$"],
+		["EUR", "9876.54321", "9 876,54321 €", "Евро", "€"],
+		[
+			"RUB",
+			"123456789012.345678901",
+			"123 456 789 012,345678901 ₽",
+			"Российский рубль",
+			"₽",
+		],
+		["USD", "-1234567.890123", "-1 234 567,890123 $", "Доллар США", "$"],
+		["EUR", "987654321.000001", "987 654 321,000001 €", "Евро", "€"],
+		["USD", "-0.5", "-0,5 $", "Доллар США", "$"],
+		["CAD", "20.00", "20,00 CAD", "CAD", "CAD"],
+		["XYZ", "1.000", "1,000 XYZ", "XYZ", "XYZ"],
+	])(
+		"preserves %s %s and its currency identity",
+		(currency, value, expected, name, symbol) => {
+			render(
+				<MantineProvider>
+					<CurrencyCards amounts={[{ currency, value }]} />
+				</MantineProvider>,
+			);
+			const term = screen.getByRole("term");
+			expect(term).toHaveTextContent(name);
+			// eslint-disable-next-line testing-library/no-node-access -- This assertion checks DOM structure, decoration or focus behavior that semantic queries cannot establish.
+			expect(term.querySelector("[aria-hidden=\"true\"]")).toHaveTextContent(
+				symbol,
+			);
+			expect(screen.getByRole("definition")).toHaveTextContent(expected);
+			// eslint-disable-next-line testing-library/no-node-access -- This assertion checks DOM structure, decoration or focus behavior that semantic queries cannot establish.
+			expect(term.parentElement).toBe(
+				// eslint-disable-next-line testing-library/no-node-access -- This assertion checks DOM structure, decoration or focus behavior that semantic queries cannot establish.
+				screen.getByRole("definition").parentElement,
+			);
+		},
+	);
+});

src/pages/account/ui/AccountPage/components/CurrencyCards/CurrencyCards.view.tsx

@@ -0,0 +1,74 @@
+import type { FC } from "react";
+
+import { Paper, SimpleGrid, Text, VisuallyHidden } from "@mantine/core";
+import { useTranslation } from "react-i18next";
+
+import type { Portfolio } from "@/entities/portfolio";
+
+import { formatDecimal } from "@/shared/lib";
+
+import classes from "../../AccountPage.module.css";
+
+const SIGN_PREFIX_LENGTH = 2;
+
+type CurrencyCardsProps = {
+	amounts: Portfolio["totalsByCurrency"];
+};
+
+const CurrencyCards: FC<CurrencyCardsProps> = (props) => {
+	const { t } = useTranslation();
+	const { amounts } = props;
+
+	const currencies: Record<string, { name: string; symbol: string }> = {
+		EUR: { name: t("portfolio.currencies.EUR"), symbol: "€" },
+		RUB: { name: t("portfolio.currencies.RUB"), symbol: "₽" },
+		USD: { name: t("portfolio.currencies.USD"), symbol: "$" },
+	};
+
+	return (
+		<SimpleGrid cols={{ base: 1, md: 3, sm: 2 }} spacing={10}>
+			{amounts.map((money) => {
+				const amount = formatDecimal(money.value);
+
+				return (
+					<Paper
+						className={classes.total}
+						component="dl"
+						key={money.currency}
+						m={0}
+						withBorder
+					>
+						<Text className={classes.totalBadge} component="dt">
+							<span aria-hidden="true">
+								{currencies[money.currency]?.symbol ?? money.currency}
+							</span>
+
+							<VisuallyHidden>
+								{currencies[money.currency]?.name ?? money.currency}
+							</VisuallyHidden>
+						</Text>
+
+						<Text className={classes.totalAmount} component="dd" m={0}>
+							{amount.startsWith("-")
+								? (
+										<>
+											<span className={classes.totalLeadingDigits}>
+												{amount.slice(0, SIGN_PREFIX_LENGTH)}
+											</span>
+
+											{amount.slice(SIGN_PREFIX_LENGTH)}
+										</>
+									)
+								: (
+										amount
+									)}{" "}
+							{currencies[money.currency]?.symbol ?? money.currency}
+						</Text>
+					</Paper>
+				);
+			})}
+		</SimpleGrid>
+	);
+};
+
+export { CurrencyCards };

src/pages/account/ui/AccountPage/components/IncomeSummary.view.tsx

@@ -64,14 +64,16 @@ const IncomeSummary: FC<IncomeSummaryProps> = (props) => {
 
 	return (
 		<Stack gap="xs">
-			<Paper p="sm" withBorder>
+			{props.summary.totalsByCurrency.map(total => (
-				<Text fw={700}>{formatMoney(props.summary.total.total)}</Text>
+				<Paper key={total.currency} p="sm" withBorder>
+					<Text fw={700}>{formatMoney(total.total)}</Text>
 
 					<Text c="dimmed" size="sm">
-					{t("income.coupon")}: {formatMoney(props.summary.total.coupon)} ·{" "}
+						{t("income.coupon")}: {formatMoney(total.coupon)} ·{" "}
-					{t("income.dividend")}: {formatMoney(props.summary.total.dividend)}
+						{t("income.dividend")}: {formatMoney(total.dividend)}
 					</Text>
 				</Paper>
+			))}
 
 			<Button component={Link} to={props.to} variant="subtle">
 				{props.moreLabel ?? t("income.open")}

src/pages/account/ui/AccountPage/components/Performance/Performance.module.css

@@ -1,3 +0,0 @@
-.positive { color: var(--wl-color-positive); }
-.negative { color: var(--wl-color-negative); }
-.neutral { color: var(--mantine-color-dark-7); }

src/pages/account/ui/AccountPage/components/Performance/Performance.stories.tsx

@@ -1,106 +0,0 @@
-import type { Meta, StoryObj } from "@storybook/react-vite";
-
-import type { Performance } from "@/entities/performance";
-
-import { PerformanceView } from "./Performance.view";
-
-const rub = (value: string) => ({ currency: "RUB", value });
-
-const series = Array.from({ length: 24 }, (_, month) => {
-	const date = new Date(Date.UTC(2024, month, 1)).toISOString().slice(0, 10);
-	const invested = 300_000 + Math.floor(month / 6) * 150_000;
-
-	return {
-		benchmarkValue: String(Math.round(invested * (1 + month * 0.009))),
-		date,
-		netInvested: String(invested),
-		referenceValue: String(Math.round(invested * (1 + month * 0.004))),
-	};
-});
-
-const data: Performance = {
-	accountId: "account-1",
-	benchmark: {
-		asOf: "2025-12-01",
-		code: "MCFTRR",
-		return: { basis: "annual", unavailableReason: null, value: "0.108" },
-		unavailableReason: null,
-		value: rub("1387973"),
-	},
-	calculatedAt: "2025-12-01T00:00:00Z",
-	completeness: "complete",
-	currentValue: rub("1536400"),
-	excludedAccounts: [],
-	netInvested: rub("1060000"),
-	outperformance: { money: rub("148427"), percentagePoints: "0.043" },
-	period: { days: 700, from: "2024-01-01", to: "2025-12-01" },
-	profit: rub("476400"),
-	reference: {
-		asOf: "2025-12-01",
-		code: "IMOEX",
-		return: { basis: "annual", unavailableReason: null, value: "0.047" },
-		unavailableReason: null,
-		value: rub("1150000"),
-	},
-	return: { basis: "annual", unavailableReason: null, value: "0.151" },
-	series,
-};
-
-const meta = {
-	args: { data },
-	component: PerformanceView,
-	parameters: {
-		docs: {
-			description: {
-				component:
-					"Вкладка «Результат»: доходность, прибыль, те же деньги в индексе Мосбиржи и опережение. Синтетический серверный ответ без расчётов на клиенте.",
-			},
-		},
-	},
-	tags: ["autodocs"],
-	title: "Product/Performance",
-} satisfies Meta<typeof PerformanceView>;
-
-export default meta;
-
-type Story = StoryObj<typeof meta>;
-
-export const Ahead: Story = {};
-
-export const Behind: Story = {
-	args: {
-		data: {
-			...data,
-			currentValue: rub("1172400"),
-			outperformance: { money: rub("-215573"), percentagePoints: "-0.068" },
-			profit: rub("112400"),
-			return: { basis: "annual", unavailableReason: null, value: "0.04" },
-		},
-	},
-};
-
-export const ShortHistory: Story = {
-	args: {
-		data: {
-			...data,
-			benchmark: {
-				...data.benchmark,
-				return: { basis: "period", unavailableReason: null, value: "0.112" },
-			},
-			period: { days: 277, from: "2025-02-27", to: "2025-12-01" },
-			return: { basis: "period", unavailableReason: null, value: "0.074" },
-		},
-	},
-};
-
-export const Incomplete: Story = {
-	args: {
-		data: {
-			...data,
-			completeness: "incomplete",
-			excludedAccounts: [
-				{ accountId: "usd", name: "Валютный", reason: "PORTFOLIO_VALUATION_INCOMPLETE" },
-			],
-		},
-	},
-};

src/pages/account/ui/AccountPage/components/Performance/Performance.view.tsx

@@ -1,185 +0,0 @@
-import { LineChart } from "@mantine/charts";
-import {
-	Accordion,
-	ActionIcon,
-	Alert,
-	Group,
-	Paper,
-	SimpleGrid,
-	Stack,
-	Text,
-	Title,
-	Tooltip,
-} from "@mantine/core";
-import { useTranslation } from "react-i18next";
-
-import type { Performance } from "@/entities/performance";
-
-import { formatChartValue, formatDate } from "@/shared/lib";
-
-import { performanceVm } from "../../../../model/performance";
-import classes from "./Performance.module.css";
-
-const formatRub = (value: number) => `${formatChartValue(Math.round(value))} ₽`;
-
-function PerformanceView({ data }: Readonly<{ data: Performance }>) {
-	const { t } = useTranslation();
-	const vm = performanceVm(data);
-
-	const basis = vm.basis === "annual"
-		? t("portfolio.performance.yearly")
-		: t("portfolio.performance.periodLabel", { days: vm.days });
-
-	const comparisonTone = vm.comparison?.points.tone ?? "neutral";
-	let comparisonTitle = t("portfolio.performance.marketEqual");
-	if (comparisonTone === "positive") comparisonTitle = t("portfolio.performance.marketAhead");
-	else if (comparisonTone === "negative") comparisonTitle = t("portfolio.performance.marketBehind");
-	const percentText = vm.returnValue.value;
-	const indexText = vm.indexReturn.value;
-
-	const currentLines = vm.currentPoint
-		? [{ color: "blue.6", label: t("portfolio.performance.current"), x: vm.currentPoint.date }]
-		: [];
-
-	const profitCaption = t("portfolio.performance.profitCaption", { current: vm.current, invested: vm.invested });
-
-	const chartLabel = [
-		`${t("portfolio.performance.invested")}: ${vm.invested}`,
-		`${t("portfolio.performance.benchmark")}: ${vm.indexValue}`,
-		`${t("portfolio.performance.current")}: ${vm.current}`,
-		`${t("portfolio.performance.returnLabel")}: ${percentText}`,
-	].join("; ");
-
-	return (
-		<Stack gap="md">
-			{vm.excluded.length > 0 && (
-				<Alert role="status" title={t("portfolio.performance.incomplete")}>
-					{vm.excluded.map(item => (
-						<Text key={item.id} size="sm">
-							{t("portfolio.performance.unavailableReason", item)}
-						</Text>
-					))}
-				</Alert>
-			)}
-
-			{vm.basis === "period" && (
-				<Alert role="status">
-					{t("portfolio.performance.periodNote", { days: vm.days })}
-				</Alert>
-			)}
-
-			<SimpleGrid cols={{ base: 1, lg: 4, sm: 2 }}>
-				<Paper component="dl" m={0} p="md" withBorder>
-					<Text component="dt" size="sm">{t("portfolio.performance.returnLabel")}</Text>
-
-					<Text className={classes[vm.returnValue.tone]} component="dd" fw={700} m={0} size="xl">
-						{percentText}
-					</Text>
-
-					<Text c="dimmed" size="xs">{vm.returnReason ?? basis}</Text>
-				</Paper>
-
-				<Paper component="dl" m={0} p="md" withBorder>
-					<Text component="dt" size="sm">{t("portfolio.performance.profit")}</Text>
-
-					<Text className={classes[vm.profit.tone]} component="dd" fw={700} m={0} size="xl">
-						{vm.profit.value}
-					</Text>
-
-					<Text c="dimmed" size="xs">{profitCaption}</Text>
-				</Paper>
-
-				<Paper component="dl" m={0} p="md" withBorder>
-					<Group gap="xs">
-						<Text component="dt" size="sm">{t("portfolio.performance.benchmark")}</Text>
-
-						<Tooltip
-							events={{ focus: true, hover: true, touch: true }}
-							label={t("portfolio.performance.benchmarkHint")}
-							multiline
-							w={280}
-						>
-							<ActionIcon
-								aria-label={t("portfolio.performance.benchmarkHint")}
-								size="xs"
-								variant="subtle"
-							>?
-							</ActionIcon>
-						</Tooltip>
-					</Group>
-
-					<Text component="dd" fw={700} m={0} size="xl">{indexText}</Text>
-
-					<Text c="dimmed" size="xs">
-						{vm.indexReason ?? `${basis} · ${vm.indexValue}`}
-					</Text>
-				</Paper>
-
-				<Paper component="dl" m={0} p="md" withBorder>
-					<Text component="dt" size="sm">
-						{comparisonTitle}
-					</Text>
-
-					<Text
-						className={classes[vm.comparison?.points.tone ?? "neutral"]}
-						component="dd"
-						fw={700}
-						m={0}
-						size="xl"
-					>
-						{vm.comparison?.points.value ?? "—"}
-					</Text>
-
-					<Text c="dimmed" size="xs">{vm.comparison?.money.value ?? vm.indexReason ?? vm.returnReason}</Text>
-				</Paper>
-			</SimpleGrid>
-
-			<Paper component="section" p="md" withBorder>
-				<Title mb="sm" order={2} size="h4">{t("portfolio.performance.chartTitle")}</Title>
-
-				{vm.series.length > 0
-					? (
-							<LineChart
-								aria-label={chartLabel}
-								curveType="linear"
-								data={vm.series}
-								dataKey="label"
-								gridAxis="y"
-								h={{ base: 220, sm: 300 }}
-								lineProps={{ isAnimationActive: false }}
-								referenceLines={currentLines}
-								series={[
-									{ color: "dark.4", label: t("portfolio.performance.invested"), name: "netInvested" },
-									{ color: "orange.6", label: t("portfolio.performance.benchmark"), name: "benchmarkValue" },
-									{ color: "gray.5", label: t("portfolio.performance.reference"), name: "referenceValue", strokeDasharray: "4 3" },
-								]}
-								tooltipAnimationDuration={0}
-								valueFormatter={formatRub}
-								yAxisProps={{ domain: [0, "auto"], width: 70 }}
-							/>
-						)
-					: <Text c="dimmed">{t("portfolio.performance.benchmarkUnavailable")}</Text>}
-
-				<Text c="dimmed" mt="sm" size="sm">
-					{t("portfolio.performance.missingHistory")}
-				</Text>
-			</Paper>
-
-			<Accordion variant="contained">
-				<Accordion.Item value="method">
-					<Accordion.Control>{t("portfolio.performance.calculation")}</Accordion.Control>
-
-					<Accordion.Panel>
-						<Text size="sm">
-							{t("portfolio.performance.datePeriod", { from: formatDate(`${vm.from}T00:00:00Z`), to: formatDate(`${vm.to}T00:00:00Z`) })}
-						</Text>
-
-						<Text mt="sm" size="sm">{t("portfolio.performance.method")}</Text>
-					</Accordion.Panel>
-				</Accordion.Item>
-			</Accordion>
-		</Stack>
-	);
-}
-
-export { PerformanceView };

src/pages/account/ui/AccountPage/components/Performance/PerformanceTab.test.tsx

@@ -1,193 +0,0 @@
-import { MantineProvider } from "@mantine/core";
-import { QueryClientProvider } from "@tanstack/react-query";
-import { fireEvent, render, screen } from "@testing-library/react";
-import { http, HttpResponse, type JsonBodyType } from "msw";
-import { describe, expect, it, vi } from "vitest";
-
-import type { Performance } from "@/entities/performance";
-
-import { configureAuthClient } from "@/shared/api";
-import { createTestQueryClient } from "@/test/query";
-import { server } from "@/test/server";
-
-import { PerformanceTab } from "./PerformanceTab";
-
-const url = "*/api/v1/brokerage-accounts/:accountId/performance";
-
-const rub = (value: string) => ({ currency: "RUB", value });
-
-function performance(overrides: Partial<Performance> = {}): Performance {
-	return {
-		accountId: "account-1",
-		benchmark: {
-			asOf: "2025-12-31",
-			code: "MCFTRR",
-			return: { basis: "annual", unavailableReason: null, value: "0.048809" },
-			unavailableReason: null,
-			value: rub("110000"),
-		},
-		calculatedAt: "2026-01-01T00:00:00Z",
-		completeness: "complete",
-		currentValue: rub("121000"),
-		excludedAccounts: [],
-		netInvested: rub("100000"),
-		outperformance: { money: rub("11000"), percentagePoints: "0.051191" },
-		period: { days: 730, from: "2024-01-01", to: "2025-12-31" },
-		profit: rub("21000"),
-		reference: {
-			asOf: "2025-12-31",
-			code: "IMOEX",
-			return: { basis: "annual", unavailableReason: null, value: "0.02" },
-			unavailableReason: null,
-			value: rub("105000"),
-		},
-		return: { basis: "annual", unavailableReason: null, value: "0.1" },
-		series: [
-			{ benchmarkValue: "100000", date: "2024-01-01", netInvested: "100000", referenceValue: "100000" },
-			{ benchmarkValue: "110000", date: "2025-12-31", netInvested: "100000", referenceValue: "105000" },
-		],
-		...overrides,
-	};
-}
-
-function renderTab(body: JsonBodyType, status = 200) {
-	configureAuthClient({
-		accessToken: () => "test-token",
-		clear: vi.fn(),
-		refresh: () => Promise.resolve(true),
-	});
-	server.use(http.get(url, () => HttpResponse.json(body, { status })));
-
-	return render(
-		<QueryClientProvider client={createTestQueryClient()}>
-			<MantineProvider>
-				<PerformanceTab accountId="account-1" />
-			</MantineProvider>
-		</QueryClientProvider>,
-	);
-}
-
-const meta = { dependencies: [], unavailable: [] };
-
-describe("PerformanceTab", () => {
-	it("shows return, profit, the same money in the index and outperformance with signs", async () => {
-		renderTab({ data: performance(), meta });
-
-		expect(await screen.findByText("+10,0 %")).toBeInTheDocument();
-		expect(screen.getByText("+21 000 ₽")).toBeInTheDocument();
-		expect(screen.getByText("+4,9 %")).toBeInTheDocument();
-		expect(screen.getByText("Опережение рынка")).toBeInTheDocument();
-		expect(screen.getByText("+5,1 п.п.")).toBeInTheDocument();
-		expect(screen.getByText("+11 000 ₽")).toBeInTheDocument();
-		// Index codes are allowed only inside "Как считали", not as captions.
-		expect(screen.getByText("Те же деньги в индексе Мосбиржи")).toBeInTheDocument();
-		expect(screen.queryByText("MCFTRR")).not.toBeInTheDocument();
-	});
-
-	it("labels lagging the market without colour-only meaning", async () => {
-		renderTab({
-			data: performance({
-				outperformance: { money: rub("-5000"), percentagePoints: "-0.02" },
-			}),
-			meta,
-		});
-
-		expect(await screen.findByText("Отставание от рынка")).toBeInTheDocument();
-		expect(screen.getByText("−2,0 п.п.")).toBeInTheDocument();
-	});
-
-	it("never says annual when history is shorter than a year", async () => {
-		renderTab({
-			data: performance({
-				benchmark: { ...performance().benchmark, return: { basis: "period", unavailableReason: null, value: "0.05" } },
-				period: { days: 200, from: "2025-06-14", to: "2025-12-31" },
-				return: { basis: "period", unavailableReason: null, value: "0.07" },
-			}),
-			meta,
-		});
-
-		expect(await screen.findByText(/проценты показаны за 200 дн\./)).toBeInTheDocument();
-		expect(screen.queryByText(/годовых/)).not.toBeInTheDocument();
-	});
-
-	it("lists excluded accounts when the all-accounts result is incomplete", async () => {
-		renderTab({
-			data: performance({
-				completeness: "incomplete",
-				excludedAccounts: [{ accountId: "usd", name: "Валютный", reason: "PORTFOLIO_VALUATION_INCOMPLETE" }],
-			}),
-			meta,
-		});
-
-		expect(await screen.findByText("Результат неполный")).toBeInTheDocument();
-		expect(screen.getByText("Валютный: Нет полной оценки портфеля")).toBeInTheDocument();
-	});
-
-	it("explains unavailability instead of showing zeros, including unknown reasons", async () => {
-		renderTab({
-			data: null,
-			meta: {
-				dependencies: [],
-				unavailable: [
-					{ accountId: "iis", name: "ИИС", reason: "HISTORY_START_UNKNOWN" },
-					{ accountId: "x", name: "Новый", reason: "SOMETHING_NEW" },
-				],
-			},
-		});
-
-		expect(await screen.findByText("Доходность недоступна")).toBeInTheDocument();
-		expect(screen.getByText("ИИС: Начало истории счёта неизвестно")).toBeInTheDocument();
-		expect(screen.getByText("Новый: Причину недоступности не удалось определить")).toBeInTheDocument();
-		expect(screen.queryByText(/0,0 %/)).not.toBeInTheDocument();
-	});
-
-	it("keeps profit and hides the comparison when the index is unavailable", async () => {
-		renderTab({
-			data: performance({
-				benchmark: {
-					asOf: null,
-					code: "MCFTRR",
-					return: { basis: "annual", unavailableReason: "INDEX_HISTORY_UNAVAILABLE", value: null },
-					unavailableReason: "INDEX_HISTORY_UNAVAILABLE",
-					value: null,
-				},
-				outperformance: null,
-				series: [],
-			}),
-			meta,
-		});
-
-		expect(await screen.findByText("+21 000 ₽")).toBeInTheDocument();
-		expect(screen.getByText("Сравнение с индексом сейчас недоступно")).toBeInTheDocument();
-	});
-
-	it("does not colour or call a rounded-to-zero difference outperformance", async () => {
-		renderTab({
-			data: performance({
-				outperformance: { money: rub("0"), percentagePoints: "-0.0004" },
-			}),
-			meta,
-		});
-
-		expect(await screen.findByText("Сравнение с рынком")).toBeInTheDocument();
-		expect(screen.getByText("0,0 п.п.")).toBeInTheDocument();
-	});
-
-	it("explains a pending sync when no account reasons are available", async () => {
-		renderTab({ data: null, meta });
-
-		expect(await screen.findByText(/ещё синхронизируются/)).toBeInTheDocument();
-	});
-
-	it("shows a local error with retry", async () => {
-		renderTab({ code: "INTERNAL_SERVER_ERROR", status: 500 }, 500);
-
-		expect(await screen.findByText("Не удалось загрузить результат инвестирования", {}, { timeout: 8000 })).toBeInTheDocument();
-		server.use(http.get(
-			url,
-			() => HttpResponse.json({ data: performance(), meta }),
-		));
-		fireEvent.click(screen.getByRole("button", { name: "Повторить" }));
-		expect(await screen.findByText("+10,0 %")).toBeInTheDocument();
-	}, 10_000);
-});

src/pages/account/ui/AccountPage/components/Performance/PerformanceTab.tsx

@@ -1,66 +0,0 @@
-import { Button, Paper, SimpleGrid, Skeleton, Stack, Text, Title } from "@mantine/core";
-import { useTranslation } from "react-i18next";
-
-import { usePerformance } from "@/entities/performance";
-
-import { reasonText } from "../../../../model/performance";
-import { PerformanceView } from "./Performance.view";
-
-function PerformanceTab({ accountId }: Readonly<{ accountId: string }>) {
-	const { t } = useTranslation();
-	const query = usePerformance(accountId);
-
-	if (query.isPending) return (
-		<Stack aria-label={t("portfolio.performance.returnLabel")} gap="md">
-			<SimpleGrid cols={{ base: 1, lg: 4, sm: 2 }}>
-				{["rate", "profit", "benchmark", "difference"].map(key => (
-					<Paper key={key} p="md" withBorder>
-						<Skeleton h={14} mb="sm" w="60%" />
-
-						<Skeleton h={28} w="80%" />
-					</Paper>
-				))}
-			</SimpleGrid>
-
-			<Skeleton h={220} />
-		</Stack>
-	);
-
-	const onRetry = () => {
-		void query.refetch();
-	};
-
-	if (query.isError) return (
-		<Paper p="lg" withBorder>
-			<Stack align="flex-start" gap="sm">
-				<Text>{t("portfolio.performance.error")}</Text>
-
-				<Button onClick={onRetry} variant="light">
-					{t("portfolio.performance.retry")}
-				</Button>
-			</Stack>
-		</Paper>
-	);
-	if (!query.data.data) return (
-		<Paper p="xl" withBorder>
-			<Title order={2} size="h4">{t("portfolio.performance.unavailable")}</Title>
-
-			{query.data.meta.unavailable.length === 0 && (
-				<Text c="dimmed" mt="sm">{t("portfolio.performance.syncing")}</Text>
-			)}
-
-			{query.data.meta.unavailable.map(item => (
-				<Text c="dimmed" key={item.accountId} mt="sm">
-					{t("portfolio.performance.unavailableReason", {
-						name: item.name,
-						reason: reasonText(item.reason),
-					})}
-				</Text>
-			))}
-		</Paper>
-	);
-
-	return <PerformanceView data={query.data.data} />;
-}
-
-export { PerformanceTab };

src/pages/accounts/ui/AccountsPage/AccountsPage.test.tsx

@@ -1,6 +1,6 @@
 import { MantineProvider } from "@mantine/core";
 import { type QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { render, screen, waitFor } from "@testing-library/react";
 import { http, HttpResponse } from "msw";
 import { MemoryRouter } from "react-router";
 import { describe, expect, it, vi } from "vitest";
@@ -31,26 +31,16 @@ function configureTestAuth() {
 	});
 }
 
-function portfolioSummary(totals: { currency: string; value: string }) {
+function portfolioSummary(totals: { currency: string; value: string }[]) {
 	return {
 		bondPositionCount: 1,
-		cash: { currency: "RUB", value: "0" },
+		cashBalances: [],
 		fundPositionCount: 0,
 		stockPositionCount: 0,
-		structure: {
+		structure: { currencies: [], unvaluedCategories: [] },
-			categories: [],
-			hasNegativeValues: false,
-			totalValue: "0",
-			unvaluedCategories: [],
-		},
 		totalPositionCount: 1,
-		totals,
+		totalsByCurrency: totals,
-		unrealizedReturn: {
+		unrealizedReturnByCurrency: [],
-			absolute: "0",
-			costBasis: "0",
-			partial: false,
-			percent: null,
-		},
 	};
 }
 
@@ -69,18 +59,23 @@ function renderPage(queryClient: QueryClient) {
 }
 
 describe("AccountsPage", () => {
-	it("summarizes account totals and reports excluded accounts", async () => {
+	it("summarizes currencies separately and reports excluded accounts", async () => {
 		server.use(http.get("*/api/v1/brokerage-accounts", () =>
 			HttpResponse.json(resource([
 				{
 					...account,
-					portfolioSummary: portfolioSummary({ currency: "RUB", value: "100.10" }),
+					portfolioSummary: portfolioSummary([
+						{ currency: "RUB", value: "100.10" },
+						{ currency: "USD", value: "20" },
+					]),
 				},
 				{
 					...account,
 					id: "account-2",
 					name: "Второй",
-					portfolioSummary: portfolioSummary({ currency: "RUB", value: "50.20" }),
+					portfolioSummary: portfolioSummary([
+						{ currency: "RUB", value: "50.20" },
+					]),
 				},
 				{
 					...account,
@@ -93,9 +88,9 @@ describe("AccountsPage", () => {
 					id: "account-4",
 					name: "Только деньги",
 					portfolioSummary: {
-						...portfolioSummary({ currency: "RUB", value: "25" }),
+						...portfolioSummary([{ currency: "RUB", value: "25" }]),
 						bondPositionCount: 0,
-						cash: { currency: "RUB", value: "25" },
+						cashBalances: [{ currency: "RUB", value: "25" }],
 						totalPositionCount: 0,
 					},
 				},
@@ -104,7 +99,7 @@ describe("AccountsPage", () => {
 					id: "account-5",
 					name: "Без сумм",
 					portfolioSummary: {
-						...portfolioSummary({ currency: "RUB", value: "0" }),
+						...portfolioSummary([]),
 						totalPositionCount: 0,
 					},
 				},
@@ -115,8 +110,7 @@ describe("AccountsPage", () => {
 		renderPage(client);
 
 		expect(await screen.findByText("175,30 ₽")).toBeInTheDocument();
-		expect(screen.queryByText("Ваши инвестиции по счетам"))
+		expect(screen.getAllByText("20,00 USD")).not.toHaveLength(0);
-			.not.toBeInTheDocument();
 		expect(screen.getByText("5 счетов")).toBeInTheDocument();
 		expect(screen.getByText("Нет текущих сумм")).toBeInTheDocument();
 		expect(screen.getByText(
@@ -267,101 +261,6 @@ describe("AccountsPage", () => {
 	});
 });
 
-// Automatic read retries wait 1s + 2s before the failure is final.
-const RETRIES_EXHAUSTED_MS = 6000;
-const TEST_MS = 10_000;
-
-describe("exhausted read retries", () => {
-	it(
-		"keeps the cached list, warns and retries the same accounts GET",
-		{ timeout: TEST_MS },
-		async () => {
-			let isFailing = false;
-			let requests = 0;
-			server.use(
-				http.get("*/api/v1/brokerage-accounts", () => {
-					requests += 1;
-					if (isFailing)
-						return HttpResponse.json(
-							{ code: "TBANK_UNAVAILABLE" },
-							{ status: 503 },
-						);
-
-					return HttpResponse.json(resource([account]));
-				}),
-			);
-			const queryClient = createTestQueryClient();
-			renderPage(queryClient);
-			await screen.findByText("Основной");
-			expect(screen.queryByRole("button", { name: "Повторить" }))
-				.not.toBeInTheDocument();
-
-			isFailing = true;
-			void queryClient.invalidateQueries({
-				queryKey: brokerageAccountsQueryKey,
-			});
-
-			const retry = await screen.findByRole(
-				"button",
-				{ name: "Повторить" },
-				{ timeout: RETRIES_EXHAUSTED_MS },
-			);
-
-			expect(screen.getByText("Не удалось обновить данные")).toBeInTheDocument();
-			expect(screen.getByText("Основной")).toBeInTheDocument();
-			expect(requests).toBe(4);
-
-			isFailing = false;
-			fireEvent.click(retry);
-
-			await waitFor(() =>
-				expect(screen.queryByText("Не удалось обновить данные"))
-					.not.toBeInTheDocument());
-			expect(requests).toBe(5);
-			expect(screen.getByText("Основной")).toBeInTheDocument();
-		},
-	);
-
-	it(
-		"offers retry on the unavailable state after an initial failure",
-		{ timeout: TEST_MS },
-		async () => {
-			let isFailing = true;
-			server.use(
-				http.get("*/api/v1/brokerage-accounts", () =>
-					isFailing
-						? HttpResponse.json({ code: "TBANK_UNAVAILABLE" }, { status: 503 })
-						: HttpResponse.json(resource([account]))),
-			);
-			renderPage(createTestQueryClient());
-
-			const retry = await screen.findByRole(
-				"button",
-				{ name: "Повторить" },
-				{ timeout: RETRIES_EXHAUSTED_MS },
-			);
-
-			isFailing = false;
-			fireEvent.click(retry);
-
-			expect(await screen.findByText("Основной")).toBeInTheDocument();
-		},
-	);
-
-	it("does not offer a plain retry when the connection is lost", async () => {
-		server.use(
-			http.get("*/api/v1/brokerage-accounts", () =>
-				HttpResponse.json({ code: "TBANK_NOT_CONNECTED" }, { status: 409 })),
-		);
-		renderPage(createTestQueryClient());
-
-		expect(await screen.findByRole("link", { name: "Открыть настройки T-Bank" }))
-			.toBeInTheDocument();
-		expect(screen.queryByRole("button", { name: "Повторить" }))
-			.not.toBeInTheDocument();
-	});
-});
-
 it.each(["none", "failed"] as const)(
 	"keeps incomplete empty membership distinct from no accounts (attempt=%s)",
 	async (state) => {

src/pages/accounts/ui/AccountsPage/AccountsPage.tsx

@@ -1,22 +1,21 @@
 import type { FC } from "react";
 
-import { useAccountsPageVm } from "./AccountsPage.vm";
+import { useAccountsPageViewModel } from "./AccountsPage.vm";
 import { AccountsPageEmpty } from "./components/AccountsPageEmpty.view";
 import { AccountsPageError } from "./components/AccountsPageError.view";
 import { AccountsPageLoaded } from "./components/AccountsPageLoaded.view";
 import { AccountsPageLoading } from "./components/AccountsPageLoading.view";
 
 const AccountsPage: FC = () => {
-	const vm = useAccountsPageVm();
+	const viewModel = useAccountsPageViewModel();
-	if (vm.state === "loading") return <AccountsPageLoading />;
+	if (viewModel.state === "loading") return <AccountsPageLoading />;
-	if (vm.state === "error") return <AccountsPageError {...vm} />;
+	if (viewModel.state === "error") return <AccountsPageError {...viewModel} />;
-	if (vm.state === "empty") return <AccountsPageEmpty />;
+	if (viewModel.state === "empty") return <AccountsPageEmpty />;
 
 	return (
 		<AccountsPageLoaded
-			accounts={vm.accounts}
+			accounts={viewModel.accounts}
-			meta={vm.meta}
+			meta={viewModel.meta}
-			readRetry={vm.readRetry}
 		/>
 	);
 };

src/pages/accounts/ui/AccountsPage/AccountsPage.vm.ts

@@ -4,24 +4,12 @@ import {
 	useBrokerageAccounts,
 } from "@/entities/brokerage-account";
 import { useScreenSync } from "@/features/tbank-connection";
-import {
+import { ApiErrorCode, apiErrorCode, isApiErrorCode } from "@/shared/api";
-	ApiErrorCode,
-	apiErrorCode,
-	isApiErrorCode,
-	readRetry,
-} from "@/shared/api";
 import { useInitialAvailability } from "@/shared/lib";
 
-type AccountsPageReadRetry = ReturnType<typeof readRetry>;
-
 type AccountsPageViewModel
-	= | {
+	= | { accounts: BrokerageAccountCard[]; meta: NonNullable<ReturnType<typeof useBrokerageAccounts>["meta"]>; state: "loaded" }
-		accounts: BrokerageAccountCard[];
+		| { code?: string; state: "error" }
-		meta: NonNullable<ReturnType<typeof useBrokerageAccounts>["meta"]>;
-		readRetry: AccountsPageReadRetry;
-		state: "loaded";
-	}
-	| { code?: string; readRetry: AccountsPageReadRetry; state: "error" }
 		| { state: "empty" }
 		| { state: "loading" };
 
@@ -30,12 +18,11 @@ function isAccountsAccessFailure(code?: string) {
 		|| isApiErrorCode(code, ApiErrorCode.TbankNotConnected);
 }
 
-function useAccountsPageVm(): AccountsPageViewModel {
+function useAccountsPageViewModel(): AccountsPageViewModel {
 	const accounts = useBrokerageAccounts();
 	useScreenSync({ screen: "accounts" }, [accounts]);
 
 	const code = apiErrorCode(accounts.error);
-	const retry = readRetry([accounts]);
 	const isAccessFailure = isAccountsAccessFailure(code);
 
 	const hasResult = !!accounts.data
@@ -49,13 +36,12 @@ function useAccountsPageVm(): AccountsPageViewModel {
 		isFetching: accounts.isFetching,
 	});
 
-	if (isAccessFailure)
+	if (isAccessFailure) return { code, state: "error" as const };
-		return { code, readRetry: retry, state: "error" as const };
 
 	if (!hasResult || !accounts.data)
-		return availability === "unavailable"
+		return {
-			? { code, readRetry: retry, state: "error" as const }
+			state: availability === "unavailable" ? "error" : "loading",
-			: { state: "loading" as const };
+		} as const;
 
 	if (accounts.data.length === 0)
 		return {
@@ -68,9 +54,8 @@ function useAccountsPageVm(): AccountsPageViewModel {
 	return {
 		accounts: brokerageAccountCards(accounts.data, meta.dependencies),
 		meta,
-		readRetry: retry,
 		state: "loaded" as const,
 	};
 }
 
-export { useAccountsPageVm };
+export { useAccountsPageViewModel };

src/pages/accounts/ui/AccountsPage/components/AccountsPageError.view.tsx

@@ -6,12 +6,8 @@ import { useTranslation } from "react-i18next";
 import { Link } from "react-router";
 
 import { ApiErrorCode, isApiErrorCode } from "@/shared/api";
-import { ReadRetryButton, type ReadRetryProps } from "@/shared/ui";
 
-type AccountsPageErrorProps = {
+type AccountsPageErrorProps = { code?: string };
-	code?: string;
-	readRetry?: ReadRetryProps;
-};
 
 const AccountsPageError: FC<AccountsPageErrorProps> = (props) => {
 	const { code } = props;
@@ -42,18 +38,8 @@ const AccountsPageError: FC<AccountsPageErrorProps> = (props) => {
 			/>
 		);
 
-	const retry = props.readRetry?.exhausted
-		? (
-				<ReadRetryButton
-					onRetry={props.readRetry.onRetry}
-					retrying={props.readRetry.retrying}
-				/>
-			)
-		: undefined;
-
 	return (
 		<StateView
-			action={retry}
 			text={t("states.unavailableText")}
 			title={t("states.unavailableTitle")}
 		/>

src/pages/accounts/ui/AccountsPage/components/AccountsPageLoaded.module.css

@@ -1,21 +0,0 @@
-.summary {
-	min-width: 0;
-	padding-bottom: var(--mantine-spacing-lg);
-	border-bottom: 1px solid var(--wl-color-border);
-}
-
-.primaryTotal {
-	font-size: clamp(1.75rem, 4vw, 2.25rem);
-	font-variant-numeric: tabular-nums;
-	line-height: 1.2;
-	overflow-wrap: anywhere;
-}
-
-.otherTotal {
-	font-variant-numeric: tabular-nums;
-	overflow-wrap: anywhere;
-}
-
-.meta {
-	padding-top: var(--mantine-spacing-xs);
-}

src/pages/accounts/ui/AccountsPage/components/AccountsPageLoaded.view.tsx

@@ -1,6 +1,6 @@
 import type { FC } from "react";
 
-import { Button, Group, Stack, Text, Title } from "@mantine/core";
+import { Button, SimpleGrid, Stack, Text, Title } from "@mantine/core";
 import { useTranslation } from "react-i18next";
 import { Link } from "react-router";
 
@@ -11,9 +11,7 @@ import {
 	BrokerageAccountList,
 } from "@/entities/brokerage-account";
 import { formatMoney } from "@/shared/lib";
-import { ReadRetry, type ReadRetryProps, SourceSyncStatus } from "@/shared/ui";
+import { SourceSyncStatus } from "@/shared/ui";
-
-import classes from "./AccountsPageLoaded.module.css";
 
 const DECIMAL_BASE = 10n;
 const DECIMAL_PART_COUNT = 2;
@@ -22,19 +20,36 @@ const ZERO = 0n;
 type AccountsPageLoadedProps = {
 	accounts: BrokerageAccountCard[];
 	meta: InvestmentResourceMeta;
-	readRetry?: ReadRetryProps;
 };
 
-function accountTotals(accounts: BrokerageAccountCard[]): null | string {
+type Money = { currency: string; value: string };
-	const values: string[] = [];
+
+function accountTotals(accounts: BrokerageAccountCard[]) {
+	const values = new Map<string, string[]>();
+	let excludedCount = 0;
 
 	for (const { summary } of accounts) {
-		if (summary.state !== "available") continue;
+		if (summary.state === "empty") continue;
 
-		values.push(summary.portfolio.totals.value);
+		if (summary.state === "unavailable") {
+			excludedCount += 1;
+			continue;
 		}
 
-	return values.length > 0 ? sumDecimals(values) : null;
+		for (const total of summary.portfolio.totalsByCurrency) {
+			values.set(total.currency, [
+				...values.get(total.currency) ?? [],
+				total.value,
+			]);
+		}
+	}
+
+	const totals: Money[] = Array.from(values, ([currency, amounts]) => ({
+		currency,
+		value: sumDecimals(amounts),
+	}));
+
+	return { excludedCount, totals };
 }
 
 function sumDecimals(values: string[]) {
@@ -70,50 +85,53 @@ function sumDecimals(values: string[]) {
 
 const AccountsPageLoaded: FC<AccountsPageLoadedProps> = (props) => {
 	const { t } = useTranslation();
-	const total = accountTotals(props.accounts);
+	const { excludedCount, totals } = accountTotals(props.accounts);
-
-	const excludedCount = props.accounts.filter(
-		account => account.summary.state === "unavailable",
-	).length;
 
 	return (
 		<Stack gap="lg">
+			<Stack gap={4}>
 				<Title order={1}>{t("accounts.title")}</Title>
 
-			<Stack className={classes.summary} gap="xs">
+				<Text c="dimmed" size="sm">
+					{t("accounts.subtitle")}
+				</Text>
+			</Stack>
+
+			<Stack gap="xs">
+				<SimpleGrid cols={{ base: 1, xs: 2 }} spacing="xs">
+					<Stack gap={4}>
 						<Text c="dimmed" size="sm">
 							{t("accounts.currentValue")}
 						</Text>
 
-				{total === null
+						{totals.length > 0
-					? (
+							? totals.map(total => (
-							<Text c="dimmed">{t("accounts.summaryNoTotals")}</Text>
+									<Text fw={700} key={total.currency} size="lg">
-						)
+										{formatMoney(total, { withRoundedCents: true })}
-					: (
-							<Text className={classes.primaryTotal} fw={700}>
-								{formatMoney({ currency: "RUB", value: total }, { withRoundedCents: true })}
 									</Text>
-						)}
+								))
+							: <Text c="dimmed">{t("accounts.summaryNoTotals")}</Text>}
+					</Stack>
 
-				<Group className={classes.meta} gap="xs" wrap="wrap">
+					<Stack gap={4}>
-					<Text c="dimmed" size="xs">
+						<Text fw={600}>{t("accounts.count", {
-						{t("accounts.count", { count: props.accounts.length })}
+							count: props.accounts.length,
+						})}
 						</Text>
 
-					<SourceSyncStatus
-						lastAttempt={props.meta.lastAttempt}
-						lastSuccessfulAt={props.meta.lastSuccessfulAt}
-						stale={props.meta.freshness === "stale"}
-					/>
-				</Group>
-
 						{excludedCount > 0 && (
 							<Text c="dimmed" size="sm">
 								{t("accounts.summaryExcluded", { count: excludedCount })}
 							</Text>
 						)}
+					</Stack>
+				</SimpleGrid>
 
-				{!!props.readRetry && <ReadRetry {...props.readRetry} />}
+				<SourceSyncStatus
+					lastAttempt={props.meta.lastAttempt}
+					lastSuccessfulAt={props.meta.lastSuccessfulAt}
+					stale={props.meta.freshness === "stale"}
+				/>
 			</Stack>
 
 			<Button

src/pages/bond/ui/BondPage/BondPage.test.tsx

@@ -347,29 +347,14 @@ describe("bond page", () => {
 	it("keeps market content and sold-position history when coupons fail", async () => {
 		setup({ failCoupons: true, noPosition: true });
 		await screen.findByText("98,125 %");
+		expect(screen.queryByRole("button", { name: "Повторить" })).not.toBeInTheDocument();
 		expect(
 			screen.queryByRole("heading", { name: "Моя позиция" }),
 		).not.toBeInTheDocument();
 		expect(
-			screen.getByRole("heading", { name: "История операций" }),
+			screen.getByRole("heading", { name: "Моя история событий" }),
 		).toBeVisible();
 	});
-	it(
-		"offers a local retry for the failed coupons section only",
-		{ timeout: 10_000 },
-		async () => {
-			setup({ failCoupons: true });
-			await screen.findByText("98,125 %");
-			// Automatic read retries wait 1s + 2s before the failure is final.
-			await screen.findByRole(
-				"button",
-				{ name: "Повторить" },
-				{ timeout: 6000 },
-			);
-			expect(screen.getAllByRole("button", { name: "Повторить" })).toHaveLength(1);
-			expect(screen.getByText("98,125 %")).toBeVisible();
-		},
-	);
 	it("preserves cached quote without manual refresh", async () => {
 		const controls = setup({ path: `/bonds/${uid}?period=year&events=trades` });
 		await screen.findByText("98,125 %");

src/pages/card/ui/OperationForm/OperationForm.vm.ts

@@ -120,52 +120,11 @@ const useOperationFormVm = (props: OperationFormProps) => {
 					body: { ...body, version },
 					id: props.operation.id,
 				});
-			else {
+			else
-				const base = {
+				await operationCreation.mutateAsync({
-					amount: body.amount,
-					cardId: values.cardId,
-					date: values.date,
-					description: values.description,
 					id: intent,
-				};
+					...body,
-
-				switch (values.kind) {
-					case "expense": {
-						await operationCreation.mutateAsync({
-							...base,
-							categoryId: values.categoryId || defaultCategoryId,
-							kind: values.kind,
 				});
-						break;
-					}
-
-					case "refund": {
-						await operationCreation.mutateAsync({
-							...base,
-							kind: values.kind,
-							originalExpenseId: values.originalExpenseId,
-						});
-						break;
-					}
-
-					case "topup": {
-						await operationCreation.mutateAsync({
-							...base,
-							kind: values.kind,
-						});
-						break;
-					}
-
-					case "transfer": {
-						await operationCreation.mutateAsync({
-							...base,
-							kind: values.kind,
-							targetCardId: values.targetCardId,
-						});
-						break;
-					}
-				}
-			}
 
 			notifications.show({
 				id: "bank-operation-saved-" + actionId,

src/pages/login/ui/LoginPage.tsx

@@ -1,13 +1,13 @@
 import type { FC } from "react";
 
+import { useDocumentTitle } from "@mantine/hooks";
 import { useTranslation } from "react-i18next";
 
 import { AuthPageLayout, LoginForm } from "@/features/auth";
-import { useAppDocumentTitle } from "@/shared/ui";
 
 const LoginPage: FC = () => {
 	const { t } = useTranslation();
-	useAppDocumentTitle(t("auth.login"));
+	useDocumentTitle(`${t("auth.login")} — ${t("appName")}`);
 
 	return (
 		<AuthPageLayout title={t("auth.login")}>

src/pages/not-found/ui/NotFoundPage.tsx

@@ -1,15 +1,14 @@
 import type { FC } from "react";
 
 import { Button, Stack, Title } from "@mantine/core";
+import { useDocumentTitle } from "@mantine/hooks";
 import { StateView } from "@wealthledger/ui";
 import { useTranslation } from "react-i18next";
 import { Link } from "react-router";
 
-import { useAppDocumentTitle } from "@/shared/ui";
-
 const NotFoundPage: FC = () => {
 	const { t } = useTranslation();
-	useAppDocumentTitle(t("notFound.title"));
+	useDocumentTitle(`${t("notFound.title")} — ${t("appName")}`);
 
 	return (
 		<Stack>

src/pages/register/ui/RegisterPage.tsx

@@ -1,13 +1,13 @@
 import type { FC } from "react";
 
+import { useDocumentTitle } from "@mantine/hooks";
 import { useTranslation } from "react-i18next";
 
 import { AuthPageLayout, RegisterForm } from "@/features/auth";
-import { useAppDocumentTitle } from "@/shared/ui";
 
 const RegisterPage: FC = () => {
 	const { t } = useTranslation();
-	useAppDocumentTitle(t("auth.register"));
+	useDocumentTitle(`${t("auth.register")} — ${t("appName")}`);
 
 	return (
 		<AuthPageLayout title={t("auth.register")}>

src/pages/settings/ui/SettingsPage/SettingsPage.tsx

@@ -1,24 +1,13 @@
 import type { FC } from "react";
 
 import { Button, Stack, Title } from "@mantine/core";
-import { useTranslation } from "react-i18next";
 
-import { useAuth } from "@/features/auth";
 import { TbankConnectionSection } from "@/features/tbank-connection";
 
-const SettingsPage: FC = () => {
+import { useSettingsPageVm } from "./SettingsPage.vm";
-	const { t } = useTranslation();
-	const { logout } = useAuth();
 
-	// eslint-disable-next-line frontend/readability -- the page VM was removed as degenerate (frontend#143); a one-off error-swallowing logout is not a ViewModel.
+const SettingsPage: FC = () => {
-	const onLogout = async () => {
+	const { onLogout, t } = useSettingsPageVm();
-		try {
-			await logout();
-		}
-		catch {
-			// The session is already cleared; the route guard owns navigation.
-		}
-	};
 
 	return (
 		<Stack>

src/pages/settings/ui/SettingsPage/SettingsPage.vm.ts

@@ -0,0 +1,21 @@
+import { useTranslation } from "react-i18next";
+
+import { useAuth } from "@/features/auth";
+
+function useSettingsPageVm() {
+	const { t } = useTranslation();
+	const { logout } = useAuth();
+
+	const onLogout = async () => {
+		try {
+			await logout();
+		}
+		catch {
+			// The session is already cleared; the route guard owns navigation.
+		}
+	};
+
+	return { onLogout, t };
+}
+
+export { useSettingsPageVm };

src/pages/stock/ui/StockPage/StockPage.test.tsx

@@ -81,7 +81,6 @@ function setup(
 		candles?: NonNullable<StockPageVm["candles"]>["candles"];
 		cursorError?: string;
 		failCompany?: boolean;
-		failCompanyAfter?: { value: boolean };
 		failStock?: boolean;
 		metrics?: NonNullable<StockPageVm["company"]>["metrics"];
 		noPosition?: boolean;
@@ -134,7 +133,7 @@ function setup(
 					),
 				);
 			if (params.section === "company")
-				return (options.failCompanyAfter?.value ?? options.failCompany)
+				return options.failCompany
 					? HttpResponse.json({ code: "TBANK_UNAVAILABLE" }, { status: 503 })
 					: HttpResponse.json(
 
@@ -258,10 +257,17 @@ function setup(
 }
 
 describe("stock page", () => {
-	it("formats RUB money, ratio and percent metrics", async () => {
+	it("preserves unknown and unambiguous currencies with compact, ratio and percent formatting", async () => {
 		setup(
 			{
 				metrics: [
+					{
+						currency: null,
+						key: "marketCapitalization",
+						period: null,
+						unit: "money",
+						value: 1_234_567.89,
+					},
 					{
 						currency: "RUB",
 						key: "revenueTtm",
@@ -269,6 +275,20 @@ describe("stock page", () => {
 						unit: "money",
 						value: 1_234_567.89,
 					},
+					{
+						currency: "USD",
+						key: "ebitdaTtm",
+						period: "TTM",
+						unit: "money",
+						value: 1_234_567.89,
+					},
+					{
+						currency: "CAD",
+						key: "netIncomeTtm",
+						period: "TTM",
+						unit: "money",
+						value: 1_234_567.89,
+					},
 					{
 						currency: null,
 						key: "peRatioTtm",
@@ -286,8 +306,14 @@ describe("stock page", () => {
 				],
 			},
 		);
-		expect(await screen.findByText("1,23 млн ₽")).toBeVisible();
+		expect(await screen.findByText("1,23 млн валюта неизвестна")).toBeVisible();
-		for (const value of ["5,68 ×", "12,35 %"])
+		for (const value of [
+			"1,23 млн ₽",
+			"1,23 млн USD",
+			"1,23 млн CAD",
+			"5,68 ×",
+			"12,35 %",
+		])
 			expect(screen.getByText(value)).toBeVisible();
 	});
 	it("opens a direct ticker URL and uses its resolved UID for market and personal requests", async () => {
@@ -370,6 +396,7 @@ describe("stock page", () => {
 			screen.queryByRole("heading", { name: "Моя позиция" }),
 		).not.toBeInTheDocument();
 		expect(screen.getByRole("heading", { name: "График цены" })).toBeVisible();
+		expect(screen.queryByRole("button", { name: "Повторить" })).not.toBeInTheDocument();
 	});
 	it("keeps successful sections visible when company data is initially missing", async () => {
 		const { requests } = setup({ failCompany: true });
@@ -377,39 +404,8 @@ describe("stock page", () => {
 		const previousRequests = requests.length;
 		expect(screen.getByText("Зачисление дивидендов")).toBeVisible();
 		expect(requests).toHaveLength(previousRequests);
+		expect(screen.queryByRole("button", { name: "Повторить" })).not.toBeInTheDocument();
 	});
-	it(
-		"retries only the failed company section and recovers it in place",
-		{ timeout: 10_000 },
-		async () => {
-			const failing = { value: true };
-			const { requests } = setup({ failCompanyAfter: failing });
-			await screen.findByText("Зачисление дивидендов");
-
-			// Automatic read retries wait 1s + 2s before the failure is final.
-			const retry = await screen.findByRole(
-				"button",
-				{ name: "Повторить" },
-				{ timeout: 6000 },
-			);
-
-			expect(screen.getByRole("heading", { name: "График цены" })).toBeVisible();
-			expect(screen.getAllByRole("button", { name: "Повторить" })).toHaveLength(1);
-			const before = requests.length;
-			const companyBefore = requests.filter(url => url.pathname.endsWith("/company")).length;
-
-			failing.value = false;
-			fireEvent.click(retry);
-
-			await waitFor(() =>
-				expect(screen.queryByRole("button", { name: "Повторить" }))
-					.not.toBeInTheDocument());
-			expect(requests.filter(url => url.pathname.endsWith("/company")))
-				.toHaveLength(companyBefore + 1);
-			expect(requests.length - before).toBe(1);
-			expect(screen.getByText("Описание компании")).toBeVisible();
-		},
-	);
 	it("sends instrument-filtered continuation, restores it on returning to the filter and changes chart period", async () => {
 		const { requests } = setup();
 		await screen.findByText("Зачисление дивидендов");
@@ -463,7 +459,7 @@ describe("stock page", () => {
 			fireEvent.click(screen.getByRole("button", { name: "Далее" }));
 			controls.recoverOperations();
 			expect(screen.queryByRole("button", { name: "Повторить" })).not.toBeInTheDocument();
-			expect(screen.getByRole("heading", { name: "История операций" })).toBeVisible();
+			expect(screen.getByRole("heading", { name: "Моя история событий" })).toBeVisible();
 		},
 	);
 	it("keeps the last quote without manual refresh", async () => {

src/pages/stock/ui/StockPage/components/StockCompany.view.tsx

@@ -37,7 +37,7 @@ const StockCompany: FC<StockCompanyProps> = (props) => {
 					{props.company.metrics.map((metric) => {
 						const label = [t(`stock.metrics.${metric.key}`), metric.period].filter(Boolean).join(" · ");
 						const formatter = metric.unit === "money" ? compactMetricFormatter : metricFormatter;
-						const value = `${formatter.format(metric.value)} ${metricUnit(metric)}`;
+						const value = `${formatter.format(metric.value)} ${metricUnit(metric, t("stock.currencyUnknown"))}`;
 
 						return (
 							<InstrumentMetric key={metric.key} label={label} value={value} />
@@ -89,9 +89,14 @@ const StockCompany: FC<StockCompanyProps> = (props) => {
 	);
 };
 
-function metricUnit(metric: NonNullable<StockPageVm["company"]>["metrics"][number]) {
+function metricUnit(
+	metric: NonNullable<StockPageVm["company"]>["metrics"][number],
+	unknownCurrency: string,
+) {
 	if (metric.unit === "money")
-		return "₽";
+		return metric.currency === "RUB"
+			? "₽"
+			: (metric.currency ?? unknownCurrency);
 
 	return metric.unit === "percent" ? "%" : "×";
 }

src/pages/stocks/ui/StocksPage/StocksPage.view.tsx

@@ -69,6 +69,7 @@ const criteriaFields: CriteriaField[] = [
 			"SHARE_TYPE_PREFERRED",
 		],
 	},
+	{ label: "currency", options: ["RUB", "USD", "EUR", "CNY", "HKD", "TRY"] },
 	{
 		label: "realExchange",
 		options: [
@@ -183,6 +184,10 @@ const StockCard: FC<StockCardProps> = (props) => {
 					<Group gap="xs">
 						{exchange && <Badge color="gray" variant="light">{exchange}</Badge>}
 
+						{item.currency && (
+							<Badge color="gray" variant="light">{item.currency}</Badge>
+						)}
+
 						{lot && <Text c="dimmed" size="xs">{lot}</Text>}
 					</Group>
 

src/pages/stocks/ui/StocksPage/StocksPage.vm.ts

@@ -4,6 +4,7 @@ import { apiClient } from "@/shared/api";
 
 type Criteria = {
 	countryOfRisk: string;
+	currency: string;
 	maxLot: string;
 	query: string;
 	realExchange: string;
@@ -17,6 +18,7 @@ type StocksPageVm = ReturnType<typeof useStocksPageVm>;
 
 const emptyCriteria: Criteria = {
 	countryOfRisk: "",
+	currency: "",
 	maxLot: "",
 	query: "",
 	realExchange: "",
@@ -28,6 +30,7 @@ async function createSearch(criteria: Criteria) {
 	const { data } = await apiClient.POST("/api/v1/stocks/screener/search", {
 		body: {
 			...(criteria.countryOfRisk && { countryOfRisk: criteria.countryOfRisk }),
+			...(criteria.currency && { currency: criteria.currency }),
 			...(criteria.maxLot && { maxLot: Number(criteria.maxLot) }),
 			...(criteria.query && { query: criteria.query }),
 			...(criteria.realExchange && { realExchange: criteria.realExchange }),

src/shared/api/authenticated-query.test.tsx

@@ -6,7 +6,10 @@ import { createQueryWrapper } from "@/test/query";
 import { resource } from "@/test/resource";
 import { server } from "@/test/server";
 
-import { useAuthenticatedQuery } from "./authenticated-query";
+import {
+	useAuthenticatedQueries,
+	useAuthenticatedQuery,
+} from "./authenticated-query";
 import { apiQueryClient, configureAuthClient } from "./client";
 
 const useSingleQuery = () =>
@@ -14,8 +17,15 @@ const useSingleQuery = () =>
 		apiQueryClient.queryOptions("get", "/api/v1/brokerage-accounts"),
 	);
 
+const useMultipleQueries = () =>
+	useAuthenticatedQueries([
+		apiQueryClient.queryOptions("get", "/api/v1/brokerage-accounts"),
+	])[0];
+
 describe("useAuthenticatedQuery", () => {
-	it("keeps protected queries idle without a session and loads after session configuration", async () => {
+	it.each(["single", "multiple"])(
+		"keeps %s protected queries idle without a session and loads after session configuration",
+		async (mode) => {
 			const requests = vi.fn();
 			server.use(
 				http.get("*/api/v1/brokerage-accounts", () => {
@@ -34,9 +44,10 @@ describe("useAuthenticatedQuery", () => {
 				}),
 			);
 
-		const { result } = renderHook(useSingleQuery, {
+			const { result } = renderHook(
-			wrapper: createQueryWrapper().wrapper,
+				mode === "single" ? useSingleQuery : useMultipleQueries,
-		});
+				{ wrapper: createQueryWrapper().wrapper },
+			);
 
 			await new Promise(resolve => setTimeout(resolve, 0));
 			expect(requests).not.toHaveBeenCalled();
@@ -58,5 +69,6 @@ describe("useAuthenticatedQuery", () => {
 					type: "BROKERAGE",
 				},
 			]);
-	});
+		},
+	);
 });