prisma/migrations/20261108000000_rub_only_value_points/migration.sql

@@ -0,0 +1,32 @@
+-- RedefineTables
+PRAGMA defer_foreign_keys=ON;
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_TbankPortfolioValuePoint" (
+    "userId" TEXT NOT NULL,
+    "accountId" TEXT NOT NULL,
+    "attemptId" TEXT NOT NULL,
+    "value" TEXT NOT NULL,
+    "capturedAt" DATETIME NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    PRIMARY KEY ("userId", "accountId", "attemptId"),
+    CONSTRAINT "TbankPortfolioValuePoint_userId_accountId_fkey" FOREIGN KEY ("userId", "accountId") REFERENCES "TbankPortfolioValueHistory" ("userId", "accountId") ON DELETE CASCADE ON UPDATE RESTRICT
+);
+-- RUB-only: keep the RUB row per key; non-RUB rows are dropped.
+INSERT INTO "new_TbankPortfolioValuePoint" ("accountId", "attemptId", "capturedAt", "createdAt", "userId", "value")
+SELECT "accountId", "attemptId", "capturedAt", "createdAt", "userId", "value"
+FROM "TbankPortfolioValuePoint"
+WHERE "currency" = 'RUB';
+DROP TABLE "TbankPortfolioValuePoint";
+ALTER TABLE "new_TbankPortfolioValuePoint" RENAME TO "TbankPortfolioValuePoint";
+CREATE INDEX "TbankPortfolioValuePoint_userId_accountId_capturedAt_idx" ON "TbankPortfolioValuePoint"("userId", "accountId", "capturedAt");
+
+-- RUB-only: persisted JSON payloads written in the old multi-currency shape
+-- are stale. A missing snapshot/forecast is the app's normal "not synced yet"
+-- state: reads report availability 'missing' and the hourly walk rebuilds them
+-- on the next pass. Delete the stale rows instead of failing reads with 500.
+DELETE FROM "TbankPortfolio";
+DELETE FROM "TbankForecast";
+
+PRAGMA foreign_keys=ON;
+PRAGMA defer_foreign_keys=OFF;

prisma/migrations/20261108000001_rub_only_resync_now/migration.sql

@@ -0,0 +1,3 @@
+-- RUB-only: snapshots were dropped by the previous migration; clearing the hourly
+-- schedule makes the next scheduler tick rebuild them instead of waiting for the term.
+DELETE FROM "TbankSyncWork" WHERE "scopeKey" = 'hourly';

prisma/schema.prisma

@@ -101,18 +101,17 @@ model TbankPortfolioValueHistory {
   @@id([userId, accountId])
 }
 
-// One row per currency of a fully valued successful portfolio attempt.
+// One row per fully valued successful portfolio attempt (RUB only).
 model TbankPortfolioValuePoint {
   userId String
   accountId String
   attemptId String
-  currency String
   value String
   capturedAt DateTime
   createdAt DateTime @default(now())
   history TbankPortfolioValueHistory @relation(fields: [userId, accountId], references: [userId, accountId], onDelete: Cascade, onUpdate: Restrict)
 
-  @@id([userId, accountId, attemptId, currency])
+  @@id([userId, accountId, attemptId])
   @@index([userId, accountId, capturedAt])
 }
 

src/integrations/moex/moex.client.spec.ts

@@ -340,4 +340,59 @@ describe('MoexClient', () => {
       expect(starts).toEqual(['0', '1']);
     },
   );
+
+  it('filters non-RUB coupons and maturity out of bond events', async () => {
+    const pages: Record<string, unknown> = {
+      coupons: Response.json({
+        'coupons': {
+          columns: ['coupondate', 'value', 'faceunit'],
+          data: [
+            ['2099-02-01', '2', 'SUR'],
+            ['2099-02-02', '3', 'USD'],
+          ],
+        },
+        'coupons.cursor': {
+          columns: ['INDEX', 'TOTAL', 'PAGESIZE'],
+          data: [[0, 2, 100]],
+        },
+      }),
+      offers: Response.json({
+        'offers': {
+          columns: ['offerdate'],
+          data: [['2099-02-28']],
+        },
+        'offers.cursor': {
+          columns: ['INDEX', 'TOTAL', 'PAGESIZE'],
+          data: [[0, 1, 100]],
+        },
+      }),
+      description: Response.json({
+        description: {
+          columns: ['name', 'value'],
+          data: [
+            ['MATDATE', '2099-02-28'],
+            ['FACEVALUE', '500'],
+            ['FACEUNIT', 'USD'],
+          ],
+        },
+      }),
+    };
+    const fetchMock = jest
+      .spyOn(global, 'fetch')
+      .mockImplementation((input) => {
+        const url = new URL(input instanceof Request ? input.url : String(input));
+        const block = url.searchParams.get('iss.only')?.split(',')[0] ?? 'description';
+        // eslint-disable-next-line security/detect-object-injection -- Keys are fixed MOEX block names of this test's page map.
+        const page = pages[block] ?? pages.description;
+        return Promise.resolve(page as Response);
+      });
+    try {
+      await expect(new MoexClient().bondEvents('BOND')).resolves.toEqual([
+        { type: 'coupon', date: '2099-02-01', value: '2', currency: 'RUB' },
+        { type: 'offer', date: '2099-02-28' },
+      ]);
+    } finally {
+      fetchMock.mockRestore();
+    }
+  });
 });

src/integrations/moex/moex.client.ts

@@ -157,9 +157,9 @@ export class MoexClient {
     for (const row of coupons) {
       const date = text(row.coupondate);
       const value = numberText(row.value);
-      const currency = currencyText(row.faceunit);
+      // RUB-only: coupons in other currencies are filtered out at this ingest boundary.
-      if (date && value && currency) {
+      if (date && value && currencyText(row.faceunit) === 'RUB') {
-        events.push({ type: 'coupon', date, value, currency });
+        events.push({ type: 'coupon', date, value, currency: 'RUB' });
       }
     }
     for (const row of offers) {
@@ -171,9 +171,8 @@ export class MoexClient {
     );
     const date = values.get('MATDATE');
     const value = numberText(values.get('FACEVALUE'));
-    const currency = currencyText(values.get('FACEUNIT'));
+    if (date && value && currencyText(values.get('FACEUNIT')) === 'RUB') {
-    if (date && value && currency) {
+      events.push({ type: 'maturity', date, value, currency: 'RUB' });
-      events.push({ type: 'maturity', date, value, currency });
     }
     return events;
   }

src/integrations/tbank/decimal.ts

@@ -1,4 +1,6 @@
-import { Decimal } from '../../common/decimal';
+import type { Money } from '../../common/money.types';
+
+import { Decimal, formatDecimal } from '../../common/decimal';
 
 const MISSING_PROTO_COMPONENT = 0;
 
@@ -6,6 +8,12 @@ const NANO = 1_000_000_000n;
 
 export type ProtoDecimal = { nano?: number | string; units?: number | string };
 
+export function rubMoney(value?: ProtoDecimal & { currency?: string }): Money | null {
+  return value?.currency?.trim().toUpperCase() === 'RUB'
+    ? { currency: 'RUB', value: formatDecimal(decimal(value)) }
+    : null;
+}
+
 export function decimal(value: ProtoDecimal): Decimal {
   return {
     value: BigInt(value.units ?? MISSING_PROTO_COMPONENT) * NANO + BigInt(value.nano ?? MISSING_PROTO_COMPONENT),

src/modules/investments/brokerage-accounts/brokerage-account.dto.ts

@@ -7,9 +7,6 @@ import { PortfolioStructureDto } from '../portfolio/portfolio.api';
 import { HourlySyncStatusDto } from '../tbank-sync/tbank-sync.dto';
 
 export class UnrealizedReturnDto {
-  @ApiProperty()
-  declare currency: string;
-
   @ApiProperty({ example: '12.345678901' })
   declare absolute: string;
 
@@ -24,17 +21,17 @@ export class UnrealizedReturnDto {
 }
 
 export class PortfolioSummaryDto {
-  @ApiProperty({ type: MoneyDto, isArray: true })
+  @ApiProperty({ type: MoneyDto })
-  declare totalsByCurrency: MoneyDto[];
+  declare totals: MoneyDto;
 
-  @ApiProperty({ type: MoneyDto, isArray: true })
+  @ApiProperty({ type: MoneyDto })
-  declare cashBalances: MoneyDto[];
+  declare cash: MoneyDto;
 
   @ApiProperty({ type: PortfolioStructureDto })
   declare structure: PortfolioStructureDto;
 
-  @ApiProperty({ type: UnrealizedReturnDto, isArray: true })
+  @ApiProperty({ type: UnrealizedReturnDto })
-  declare unrealizedReturnByCurrency: UnrealizedReturnDto[];
+  declare unrealizedReturn: UnrealizedReturnDto;
 
   @ApiProperty({
     type: 'integer',

src/modules/investments/brokerage-accounts/brokerage-accounts.service.spec.ts

@@ -33,7 +33,7 @@ describe('saved brokerage account projection', () => {
   });
 
   it('keeps exact saved totals and independent missing summaries', async () => {
-    const structure = { currencies: [], unvaluedCategories: [] };
+    const structure = { totalValue: '0', hasNegativeValues: false, categories: [], unvaluedCategories: [] };
     portfolio.saved.mockResolvedValue({
       membership: meta,
       accounts: [
@@ -44,11 +44,9 @@ describe('saved brokerage account projection', () => {
           openedOn: null,
           meta,
           snapshot: {
-            cashBalances: [{ currency: 'RUB', value: '10.000000001' }],
+            cash: { currency: 'RUB', value: '10.000000001' },
             structure,
-            totalsByCurrency: [
+            totals: { currency: 'RUB', value: '100000000.000000001' },
-              { currency: 'RUB', value: '100000000.000000001' },
-            ],
             positions: [{ type: 'STOCK', quantity: '1' }, { type: 'BOND', quantity: '2' }],
           },
         },
@@ -64,14 +62,14 @@ describe('saved brokerage account projection', () => {
     });
     const response = await service.list('owner');
     expect(response.data?.[0].portfolioSummary).toEqual({
-      cashBalances: [{ currency: 'RUB', value: '10.000000001' }],
+      cash: { currency: 'RUB', value: '10.000000001' },
       structure,
-      totalsByCurrency: [{ currency: 'RUB', value: '100000000.000000001' }],
+      totals: { currency: 'RUB', value: '100000000.000000001' },
       stockPositionCount: 1,
       bondPositionCount: 1,
       fundPositionCount: 0,
       totalPositionCount: 2,
-      unrealizedReturnByCurrency: [],
+      unrealizedReturn: { absolute: '0', costBasis: '0', percent: null, partial: false },
     });
     expect(response.data?.[1].portfolioSummary).toBeNull();
     expect(response.meta.availability).toBe('available');
@@ -79,74 +77,65 @@ describe('saved brokerage account projection', () => {
   });
 
   it('returns an empty summary from an empty saved portfolio', async () => {
-    const structure = { currencies: [], unvaluedPositions: [], unknownValues: [] };
+    const structure = { totalValue: '0', hasNegativeValues: false, categories: [], unvaluedCategories: [] };
     portfolio.saved.mockResolvedValueOnce({
       membership: meta,
       accounts: [{
         id: 'empty', name: 'Empty', type: 'BROKERAGE', openedOn: null, meta,
-        snapshot: { cashBalances: [], structure, totalsByCurrency: [], positions: [] },
+        snapshot: { cash: { currency: 'RUB', value: '0' }, structure, totals: { currency: 'RUB', value: '0' }, positions: [] },
       }],
     });
 
     expect((await service.list('owner')).data?.[0].portfolioSummary).toEqual({
-      cashBalances: [], structure, totalsByCurrency: [],
+      cash: { currency: 'RUB', value: '0' }, structure, totals: { currency: 'RUB', value: '0' },
       stockPositionCount: 0, bondPositionCount: 0,
       fundPositionCount: 0, totalPositionCount: 0,
-      unrealizedReturnByCurrency: [],
+      unrealizedReturn: { absolute: '0', costBasis: '0', percent: null, partial: false },
     });
   });
 
-  it('calculates exact returns by currency, partial data, and zero cost basis', async () => {
+  it('calculates exact returns, partial data, and zero cost basis', async () => {
     portfolio.saved.mockResolvedValueOnce({
       membership: meta,
       accounts: [{
         id: 'a', name: 'A', type: 'BROKERAGE', openedOn: null, meta,
         snapshot: {
-          cashBalances: [], structure: {}, totalsByCurrency: [
+          cash: { currency: 'RUB', value: '0' }, structure: {}, totals: { currency: 'RUB', value: '100' },
-            { currency: 'RUB', value: '100' }, { currency: 'USD', value: '20' },
-          ],
           positions: [
             { type: 'STOCK', quantity: '2', averagePurchasePrice: { currency: 'RUB', value: '10.000000001' }, absoluteReturn: { currency: 'RUB', value: '0.000000003' } },
             { type: 'BOND', quantity: '0.5', averagePurchasePrice: { currency: 'RUB', value: '20' }, absoluteReturn: { currency: 'RUB', value: '1.25' } },
-            { type: 'FUND', quantity: '3', averagePurchasePrice: { currency: 'USD', value: '2.5' }, absoluteReturn: null },
+            { type: 'FUND', quantity: '3', averagePurchasePrice: { currency: 'RUB', value: '2.5' }, absoluteReturn: null },
-            { type: 'STOCK', quantity: '4', averagePurchasePrice: { currency: 'USD', value: '0' }, absoluteReturn: { currency: 'USD', value: '2.5' } },
+            { type: 'BOND', quantity: '1', currentValue: { currency: 'RUB', value: '7' }, averagePurchasePrice: null, absoluteReturn: null },
-            { type: 'CURRENCY', quantity: '100', averagePurchasePrice: { currency: 'EUR', value: '1' }, absoluteReturn: { currency: 'EUR', value: '5' } },
-            { type: 'BOND', quantity: '1', currentValue: { currency: 'CNY', value: '7' }, averagePurchasePrice: null, absoluteReturn: null },
           ],
         },
       }],
     });
 
     expect((await service.list('owner')).data?.[0].portfolioSummary).toMatchObject({
-      stockPositionCount: 2, bondPositionCount: 2,
+      stockPositionCount: 1, bondPositionCount: 2,
-      fundPositionCount: 1, totalPositionCount: 6,
+      fundPositionCount: 1, totalPositionCount: 4,
-      unrealizedReturnByCurrency: [
+      unrealizedReturn: { absolute: '1.250000003', costBasis: '30.000000002', percent: '4.17', partial: true },
-        { currency: 'CNY', absolute: '0', costBasis: '0', percent: null, partial: true },
-        { currency: 'RUB', absolute: '1.250000003', costBasis: '30.000000002', percent: '4.17', partial: false },
-        { currency: 'USD', absolute: '2.5', costBasis: '0', percent: null, partial: true },
-      ],
     });
   });
 
-  it('omits return percent for a currency with short positions', async () => {
+  it('omits return percent for short positions', async () => {
     portfolio.saved.mockResolvedValueOnce({
       membership: meta,
       accounts: [{
         id: 'a', name: 'A', type: 'BROKERAGE', openedOn: null, meta,
         snapshot: {
-          cashBalances: [], structure: {}, totalsByCurrency: [],
+          cash: { currency: 'RUB', value: '0' }, structure: {}, totals: { currency: 'RUB', value: '0' },
           positions: [
             { type: 'STOCK', quantity: '-2', averagePurchasePrice: { currency: 'RUB', value: '100' }, absoluteReturn: { currency: 'RUB', value: '-20' } },
-            { type: 'STOCK', quantity: '1', averagePurchasePrice: { currency: 'USD', value: '10' }, absoluteReturn: { currency: 'USD', value: '1' } },
+            { type: 'STOCK', quantity: '1', averagePurchasePrice: { currency: 'RUB', value: '10' }, absoluteReturn: { currency: 'RUB', value: '1' } },
           ],
         },
       }],
     });
 
-    expect((await service.list('owner')).data?.[0]?.portfolioSummary?.unrealizedReturnByCurrency).toEqual([
+    expect((await service.list('owner')).data?.[0]?.portfolioSummary?.unrealizedReturn).toEqual(
-      { currency: 'RUB', absolute: '-20', costBasis: '-200', percent: null, partial: false },
+      { absolute: '-19', costBasis: '-190', percent: null, partial: false },
-      { currency: 'USD', absolute: '1', costBasis: '10', percent: '10', partial: false },
+    );
-    ]);
   });
 
   it('observes the latest hourly walk without starting another one', async () => {

src/modules/investments/brokerage-accounts/brokerage-accounts.service.ts

@@ -2,6 +2,7 @@ import { Injectable } from '@nestjs/common';
 import { createHash } from 'node:crypto';
 
 import {
+  add,
   decimalFromString,
   divide,
   formatDecimal,
@@ -10,7 +11,6 @@ import {
 } from '#src/common/decimal';
 
 import { investmentResourceMeta } from '../investment-resource.mapper';
-import { sumMoneyByCurrency } from '../portfolio/domain/portfolio-totals';
 import { PortfolioPositionDto, PortfolioService } from '../portfolio/portfolio.api';
 import { hourlyAttempt, TbankSyncRepository } from '../tbank-sync/tbank-sync.api';
 import {
@@ -22,61 +22,42 @@ import {
 const PERCENT_DECIMAL_PLACES = 2;
 const ZERO_QUANTITY = 0n;
 
-function unrealizedReturns(positions: PortfolioPositionDto[]): UnrealizedReturnDto[] {
+function unrealizedReturn(positions: PortfolioPositionDto[]): UnrealizedReturnDto {
-  // Cash-like CURRENCY positions must not duplicate the separately returned cash balances.
+  const absoluteReturn = positions.reduce(
-  const investments = positions.filter((position) => position.type !== 'CURRENCY');
+    (sum, position) => position.absoluteReturn
-  const absolute = sumMoneyByCurrency(
+      ? add(sum, decimalFromString(position.absoluteReturn.value))
-    investments.flatMap((position) => position.absoluteReturn ? [position.absoluteReturn] : []),
+      : sum,
+    decimalFromString('0'),
   );
-  const costs = sumMoneyByCurrency(
+  const costBasis = positions
-    investments.flatMap((position) =>
+    .filter((position) => position.absoluteReturn && position.averagePurchasePrice)
-      position.absoluteReturn && position.averagePurchasePrice
+    .reduce(
-        ? [{
+      (sum, position) =>
-            currency: position.absoluteReturn.currency,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Guarded by the filter above.
-            value: formatDecimal(multiply(
+        add(sum, multiply(decimalFromString(position.averagePurchasePrice!.value), decimalFromString(position.quantity))),
-              decimalFromString(position.averagePurchasePrice.value),
+      decimalFromString('0'),
-              decimalFromString(position.quantity),
+    );
-            )),
+  const partial = positions.some(
-          }]
+    (position) => !position.absoluteReturn && (position.averagePurchasePrice || position.currentValue),
-        : [],
-    ),
-  );
-  const partial = new Set(
-    investments.flatMap((position) => {
-      const money = position.absoluteReturn
-        ? null
-        : position.averagePurchasePrice ?? position.currentValue;
-      return money ? [money.currency] : [];
-    }),
   );
   // A short position has negative cost basis, so a percent would flip sign or net out.
-  const withShorts = new Set(
+  const withShorts = positions.some(
-    investments.flatMap((position) => {
+    (position) =>
-      const money = position.absoluteReturn ?? position.averagePurchasePrice ?? position.currentValue;
+      (position.absoluteReturn ?? position.averagePurchasePrice ?? position.currentValue) &&
-      return money && decimalFromString(position.quantity).value < ZERO_QUANTITY ? [money.currency] : [];
+      decimalFromString(position.quantity).value < ZERO_QUANTITY,
-    }),
   );
-  const currencies = new Set([...absolute, ...costs].map((money) => money.currency));
+  return {
-  return [...new Set([...currencies, ...partial])]
+    absolute: formatDecimal(absoluteReturn),
-    .sort((left, right) => left.localeCompare(right))
+    costBasis: formatDecimal(costBasis),
-    .map((currency) => {
+    percent: isZero(costBasis) || withShorts
-      const absoluteReturn = absolute.find((money) => money.currency === currency)?.value ?? '0';
+      ? null
-      const costBasis = costs.find((money) => money.currency === currency)?.value ?? '0';
+      : formatDecimal(divide(
-      const cost = decimalFromString(costBasis);
+          multiply(absoluteReturn, decimalFromString('100')),
-      return {
+          costBasis,
-        currency,
+          PERCENT_DECIMAL_PLACES,
-        absolute: absoluteReturn,
+        )),
-        costBasis,
+    partial,
-        percent: isZero(cost) || withShorts.has(currency)
+  };
-          ? null
-          : formatDecimal(divide(
-              multiply(decimalFromString(absoluteReturn), decimalFromString('100')),
-              cost,
-              PERCENT_DECIMAL_PLACES,
-            )),
-        partial: partial.has(currency),
-      };
-    });
 }
 
 @Injectable()
@@ -98,10 +79,10 @@ export class BrokerageAccountsService {
             openedOn: account.openedOn,
             portfolioSummary: account.snapshot
               ? {
-                  totalsByCurrency: account.snapshot.totalsByCurrency,
+                  totals: account.snapshot.totals,
-                  cashBalances: account.snapshot.cashBalances,
+                  cash: account.snapshot.cash,
                   structure: account.snapshot.structure,
-                  unrealizedReturnByCurrency: unrealizedReturns(account.snapshot.positions),
+                  unrealizedReturn: unrealizedReturn(account.snapshot.positions),
                   stockPositionCount: account.snapshot.positions.filter(
                     (position) => position.type === 'STOCK',
                   ).length,

src/modules/investments/income/income-analytics.dto.ts

@@ -39,10 +39,7 @@ export class IncomePeriodDto {
   declare to: string;
 }
 
-export class IncomeCurrencySummaryDto {
+export class IncomeTotalDto {
-  @ApiProperty()
-  declare currency: string;
-
   @ApiProperty({ type: MoneyDto })
   declare coupon: MoneyDto;
 
@@ -60,8 +57,8 @@ export class IncomeSummaryDto {
   @ApiProperty({ type: IncomePeriodDto })
   declare period: IncomePeriodDto;
 
-  @ApiProperty({ type: IncomeCurrencySummaryDto, isArray: true })
+  @ApiProperty({ type: IncomeTotalDto })
-  declare totalsByCurrency: IncomeCurrencySummaryDto[];
+  declare total: IncomeTotalDto;
 
   @ApiProperty({ format: 'date-time' })
   declare calculatedAt: string;
@@ -71,8 +68,8 @@ export class IncomeBucketDto {
   @ApiProperty({ type: IncomePeriodDto })
   declare period: IncomePeriodDto;
 
-  @ApiProperty({ type: IncomeCurrencySummaryDto, isArray: true })
+  @ApiProperty({ type: IncomeTotalDto })
-  declare totalsByCurrency: IncomeCurrencySummaryDto[];
+  declare total: IncomeTotalDto;
 }
 
 export class IncomeInstrumentDto {

src/modules/investments/income/income-analytics.service.spec.ts

@@ -57,22 +57,22 @@ describe('IncomeAnalyticsService', () => {
         ticker: 'T',
         instrumentType: 'bond',
       },
-      key: 'uid:UID:RUB',
+      key: 'uid:UID',
     },
     {
       identity: { figi: 'FIGI', ticker: 'T', instrumentType: 'bond' },
-      key: 'figi:FIGI:RUB',
+      key: 'figi:FIGI',
     },
     {
       identity: { ticker: 'T', instrumentType: 'bond' },
-      key: 'ticker:T:bond:RUB',
+      key: 'ticker:T:bond',
     },
-    { identity: { ticker: 'T' }, key: 'ticker:T::RUB' },
+    { identity: { ticker: 'T' }, key: 'ticker:T:' },
     {
       identity: { ticker: null, instrumentType: 'bond' },
-      key: 'ticker::bond:RUB',
+      key: 'ticker::bond',
     },
-    { identity: { ticker: null }, key: 'operation:receipt:RUB' },
+    { identity: { ticker: null }, key: 'operation:receipt' },
   ])(
     'uses one membership for entry and aggregate: $key',
     async ({ identity, key }) => {
@@ -102,7 +102,7 @@ describe('IncomeAnalyticsService', () => {
     },
   );
 
-  it('preserves entry order, repeated IDs, currency groups and signed exact totals', async () => {
+  it('preserves entry order, repeated IDs and signed exact totals', async () => {
     const selected = [
       {
         ...entry('same-id', 'OPERATION_TYPE_COUPON', '10.25', 'RUB'),
@@ -112,10 +112,6 @@ describe('IncomeAnalyticsService', () => {
         ...entry('same-id', 'OPERATION_TYPE_DIVIDEND', '-0.25', 'RUB'),
         instrumentUid: 'UID',
       },
-      {
-        ...entry('usd', 'OPERATION_TYPE_COUPON', '20', 'USD'),
-        instrumentUid: 'UID',
-      },
     ];
     seed(selected);
 
@@ -131,7 +127,7 @@ describe('IncomeAnalyticsService', () => {
     expect(result.entries).toEqual(
       selected.map((item) => ({
         ...item,
-        instrumentKey: `uid:UID:${item.payment?.currency}`,
+        instrumentKey: 'uid:UID',
       })),
     );
     expect(
@@ -146,14 +142,7 @@ describe('IncomeAnalyticsService', () => {
       ),
     ).toEqual([
       {
-        key: 'uid:UID:USD',
+        key: 'uid:UID',
-        receiptCount: 1,
-        coupon: { currency: 'USD', value: '20' },
-        dividend: { currency: 'USD', value: '0' },
-        total: { currency: 'USD', value: '20' },
-      },
-      {
-        key: 'uid:UID:RUB',
         receiptCount: 2,
         coupon: { currency: 'RUB', value: '10.25' },
         dividend: { currency: 'RUB', value: '-0.25' },
@@ -162,7 +151,7 @@ describe('IncomeAnalyticsService', () => {
     ]);
     expect(
       result.entries
-        .filter((item) => item.instrumentKey === 'uid:UID:RUB')
+        .filter((item) => item.instrumentKey === 'uid:UID')
         .map((item) => item.payment?.value),
     ).toEqual(['10.25', '-0.25']);
   });
@@ -191,26 +180,32 @@ describe('IncomeAnalyticsService', () => {
     expect(response.data?.buckets).toEqual([
       {
         period: { from: '2026-01-14', to: '2026-01-14' },
-        totalsByCurrency: [expect.objectContaining({
+        total: {
+          coupon: { currency: 'RUB', value: '0.1' },
+          dividend: { currency: 'RUB', value: '0' },
           total: { currency: 'RUB', value: '0.1' },
-        })],
+        },
       },
       {
         period: { from: '2026-01-15', to: '2026-01-15' },
-        totalsByCurrency: [expect.objectContaining({
+        total: {
           coupon: { currency: 'RUB', value: '0.2' },
           dividend: { currency: 'RUB', value: '-0.1' },
           total: { currency: 'RUB', value: '0.1' },
-        })],
+        },
       },
       {
         period: { from: '2026-01-16', to: '2026-01-16' },
-        totalsByCurrency: [],
+        total: {
+          coupon: { currency: 'RUB', value: '0' },
+          dividend: { currency: 'RUB', value: '0' },
+          total: { currency: 'RUB', value: '0' },
+        },
       },
     ]);
   });
 
-  it('aggregates only exact coupon and dividend payments by source currency', async () => {
+  it('aggregates only exact coupon and dividend payments', async () => {
     operations.collectRanges.mockImplementation(
       (
         _user: string,
@@ -223,7 +218,6 @@ describe('IncomeAnalyticsService', () => {
             entry('coupon', 'OPERATION_TYPE_COUPON', '10.25', 'RUB'),
             entry('dividend', 'OPERATION_TYPE_DIVIDEND', '-2.5', 'RUB'),
             entry('transfer', 'OPERATION_TYPE_DIVIDEND_TRANSFER', '99', 'RUB'),
-            entry('usd', 'OPERATION_TYPE_COUPON', '1', 'USD'),
           ],
         ].map((items, index) => ({ items, meta: completeMeta(index) }));
       },
@@ -238,22 +232,14 @@ describe('IncomeAnalyticsService', () => {
 
     const result = response.data;
     assert(result);
-    expect(result.totalsByCurrency).toEqual([
+    expect(result.total).toEqual({
-      expect.objectContaining({
+      coupon: { currency: 'RUB', value: '10.25' },
-        currency: 'RUB',
+      dividend: { currency: 'RUB', value: '-2.5' },
-        coupon: { currency: 'RUB', value: '10.25' },
+      total: { currency: 'RUB', value: '7.75' },
-        dividend: { currency: 'RUB', value: '-2.5' },
+    });
-        total: { currency: 'RUB', value: '7.75' },
-      }),
-      expect.objectContaining({
-        currency: 'USD',
-        total: { currency: 'USD', value: '1' },
-      }),
-    ]);
     expect(result.entries.map((entry) => entry.id)).toEqual([
       'coupon',
       'dividend',
-      'usd',
     ]);
     expect(result.buckets).toHaveLength(31);
   });

src/modules/investments/income/income-analytics.service.ts

@@ -18,11 +18,11 @@ import {
 import {
   IncomeAnalyticsEntryDto,
   IncomeAnalyticsResourceDto,
-  IncomeCurrencySummaryDto,
   IncomeDependencyDto,
   IncomeInstrumentDto,
   IncomeSummaryDto,
   IncomeSummaryResourceDto,
+  IncomeTotalDto,
 } from './income-analytics.dto';
 import {
   IncomeBucketGranularity,
@@ -105,7 +105,7 @@ export class IncomeAnalyticsService {
     assert(current.meta.lastSuccessfulAt);
     const selected = qualifying(current.items).map((entry) => ({
       ...entry,
-      instrumentKey: `${instrumentKey(entry)}:${entry.payment?.currency ?? ''}`,
+      instrumentKey: instrumentKey(entry),
     }));
     return {
       data: {
@@ -139,23 +139,19 @@ function summaryResponse(
   entries: BrokerageOperationDto[],
   calculatedAt: string,
 ): IncomeSummaryDto {
-  return { accountId, period, totalsByCurrency: totals(entries), calculatedAt };
+  return { accountId, period, total: totals(entries), calculatedAt };
 }
 
-function totals(entries: BrokerageOperationDto[]): IncomeCurrencySummaryDto[] {
+function totals(entries: BrokerageOperationDto[]): IncomeTotalDto {
-  const values = new Map<string, Total>();
+  const total = zeroTotal();
   for (const entry of entries) {
     if (!entry.payment) continue;
-    const total = values.get(entry.payment.currency) ?? zeroTotal();
     const value = decimalFromString(entry.payment.value);
     if (isTbankProtocolValue(entry.type, TbankOperationType.Coupon)) {
       total.coupon = add(total.coupon, value);
     } else total.dividend = add(total.dividend, value);
-    values.set(entry.payment.currency, total);
   }
-  return [...values]
+  return presentTotal(total);
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([currency, total]) => presentTotal(currency, total));
 }
 
 function buckets(
@@ -169,7 +165,7 @@ function buckets(
   }));
   return rangeBuckets(range, granularity).map((period) => ({
     period,
-    totalsByCurrency: totals(
+    total: totals(
       datedEntries
         .filter(({ date }) => date >= period.from && date <= period.to)
         .map(({ entry }) => entry),
@@ -189,7 +185,7 @@ function instruments(
   return [...groups]
     .map(([key, group]) => {
       const first = group[0];
-      const [total] = totals(group);
+      const total = totals(group);
       return {
         key,
         figi: first.figi,
@@ -225,15 +221,10 @@ function zeroTotal(): Total {
   return { coupon: { value: 0n, scale: 0 }, dividend: { value: 0n, scale: 0 } };
 }
 
-function presentTotal(
+function presentTotal(value: Total): IncomeTotalDto {
-  currency: string,
-  value: Total,
-): IncomeCurrencySummaryDto {
-  const total = add(value.coupon, value.dividend);
   return {
-    currency,
+    coupon: { currency: 'RUB', value: formatDecimal(value.coupon) },
-    coupon: { currency, value: formatDecimal(value.coupon) },
+    dividend: { currency: 'RUB', value: formatDecimal(value.dividend) },
-    dividend: { currency, value: formatDecimal(value.dividend) },
+    total: { currency: 'RUB', value: formatDecimal(add(value.coupon, value.dividend)) },
-    total: { currency, value: formatDecimal(total) },
   };
 }

src/modules/investments/instruments/application/catalog-discovery.service.spec.ts

@@ -0,0 +1,20 @@
+import { CatalogDiscoveryService } from './catalog-discovery.service';
+
+jest.mock('#src/prisma/prisma.service', () => ({ PrismaService: class {} }));
+
+describe('catalog discovery currency filtering', () => {
+  it('uses details to filter InstrumentShort results before resolving ticker ambiguity', async () => {
+    const short = (uid: string) => ({ uid, ticker: 'SBER', instrumentKind: 'INSTRUMENT_TYPE_SHARE' });
+    const client = {
+      findShares: jest.fn().mockResolvedValue([short('a'), short('b')]),
+      getShare: jest.fn().mockImplementation((_token: string, uid: string) =>
+        Promise.resolve({ uid, ticker: 'SBER', currency: uid === 'a' ? 'USD' : 'RUB' })),
+      getLastPrices: jest.fn().mockResolvedValue([]),
+    };
+    const access = { online: jest.fn().mockImplementation((_user: string, run: (connection: { token: string }) => unknown) => run({ token: 'fixture' })) };
+    const service = new CatalogDiscoveryService(access as never, client as never);
+    const search = await service.search('user', { instrumentType: 'share', query: 'SBER' });
+    expect(search.data.map((item) => item.uid)).toEqual(['b']);
+    expect((await service.byTicker('user', 'share', 'SBER')).data?.uid).toBe('b');
+  });
+});

src/modules/investments/instruments/application/catalog-discovery.service.ts

@@ -49,7 +49,8 @@ export class CatalogDiscoveryService {
         ? this.tbank.getShare(token, uid)
         : this.tbank.getBond(token, uid),
     );
-    if (!instrument) throw new NotFoundException();
+    // RUB-only: a non-RUB instrument line (e.g. USD line of an SPB-traded stock) is not available.
+    if (!instrument || instrument.currency?.toUpperCase() !== 'RUB') throw new NotFoundException();
     return {
       data: { ...publicInstrument({ ...instrument, uid }), uid, slug: instrument.ticker?.toUpperCase() ?? uid },
       meta: investmentResourceMeta({
@@ -74,10 +75,18 @@ export class CatalogDiscoveryService {
         ? this.tbank.findShares(token, query)
         : this.tbank.findBonds(token, query),
     );
-    const matches = selectCatalogInstruments(
+    const candidates = selectCatalogInstruments(
       found.filter((item) => item.ticker?.trim().toUpperCase() === query),
       query,
       instrumentType,
+    );
+    const details = await this.access.online(userId, ({ token }) => Promise.all(
+      candidates.map((item) => instrumentType === 'share'
+        ? this.tbank.getShare(token, item.uid)
+        : this.tbank.getBond(token, item.uid)),
+    ));
+    const matches = candidates.filter((_item, index) =>
+      details.at(index)?.currency?.trim().toUpperCase() === 'RUB',
     ).slice(FIRST_RESULT_OFFSET, tickerAmbiguityLimit);
     if (!matches.length) throw new NotFoundException();
     if (matches.length > UNAMBIGUOUS_MATCH_COUNT) {
@@ -104,7 +113,7 @@ export class CatalogDiscoveryService {
           : found,
         input.query,
         input.instrumentType,
-      ).slice(FIRST_RESULT_OFFSET, input.exactTicker ? tickerAmbiguityLimit : catalogSearchLimit);
+      );
       const [details, prices] = await Promise.all([
         Promise.all(
           instruments.map((item) =>
@@ -122,12 +131,13 @@ export class CatalogDiscoveryService {
     const fetchedAt = new Date();
     const data = instruments.flatMap((item, index) => {
       const detail = details.at(index);
+      if (detail?.currency?.trim().toUpperCase() !== 'RUB') return [];
       return [{
         ...item,
         detail: detail ? publicInstrument({ ...detail, uid: item.uid }) : null,
         price: prices.find((price) => price.instrumentUid === item.uid) ?? null,
       }];
-    });
+    }).slice(FIRST_RESULT_OFFSET, input.exactTicker ? tickerAmbiguityLimit : catalogSearchLimit);
     return {
       data,
       meta: investmentResourceMeta({

src/modules/investments/instruments/application/instrument-position.spec.ts

@@ -27,11 +27,11 @@ const row = (
 });
 const portfolio = (positions: PortfolioPositionDto[]): PortfolioDto => ({
   positions,
-  cashBalances: [],
+  cash: { currency: 'RUB', value: '0' },
-  totalsByCurrency: [],
+  totals: { currency: 'RUB', value: '0' },
   isStale: false,
   lastSuccessfulAt: '2026-09-10T00:00:00Z',
-  structure: { currencies: [], unvaluedCategories: [] },
+  structure: { totalValue: '0', hasNegativeValues: false, categories: [], unvaluedCategories: [] },
 });
 
 describe('stock position', () => {
@@ -64,10 +64,10 @@ describe('stock position', () => {
       expect(result.averagePurchasePrice?.value).toBe('0.1');
     },
   );
-  it('does not sum currencies or treat unknown values as zero', () => {
+  it('does not treat unknown values as zero', () => {
     const second = {
       ...row(),
-      currentValue: money('2', 'USD'),
+      currentValue: null,
       averagePurchasePrice: null,
       absoluteReturn: null,
     };

src/modules/investments/instruments/application/instrument-position.ts

@@ -46,7 +46,7 @@ export function instrumentPosition(
     averagePurchasePrice:
       positive && totalCost
         ? {
-            currency: totalCost.currency,
+            currency: 'RUB',
             value: formatDecimal(
               divide(
                 decimalFromString(totalCost.value),
@@ -83,17 +83,12 @@ function cost(position: PortfolioPositionDto): MoneyDto | null {
     : null;
 }
 function sumComplete(values: (MoneyDto | null)[]): MoneyDto | null {
-  const currency = values[0]?.currency;
+  if (!values.length || !values.every((value): value is MoneyDto => value !== null)) return null;
-  if (
+  const present = values;
-    !currency ||
-    !values.every((v): v is MoneyDto => v !== null && v.currency === currency)
-  ) {
-    return null;
-  }
   return {
-    currency,
+    currency: 'RUB',
     value: formatDecimal(
-      values.reduce(
+      present.reduce(
         (sum, value) => add(sum, decimalFromString(value.value)),
         decimalFromString('0'),
       ),
@@ -107,7 +102,6 @@ function percent(
   if (
     !base ||
     !result ||
-    base.currency !== result.currency ||
     decimalFromString(base.value).value <= ZERO_AMOUNT
   ) {
     return null;

src/modules/investments/instruments/bonds/application/bond-income.service.ts

@@ -178,7 +178,7 @@ export function bondCoupons(
           recordDate &&
           recordDate >= today
             ? {
-                currency: perBond.currency,
+                currency: 'RUB',
                 value: formatDecimal(
                   multiply(quantity, decimalFromString(perBond.value)),
                 ),
@@ -227,7 +227,6 @@ export function bondMetrics(
     coupon &&
     couponPeriodDays &&
     clean &&
-    coupon.currency === clean.currency &&
     decimalFromString(coupon.value).value >= ZERO_AMOUNT &&
     decimalFromString(clean.value).value > ZERO_AMOUNT
       ? formatDecimal(

src/modules/investments/instruments/bonds/application/bond-market.service.ts

@@ -82,7 +82,7 @@ export function bondQuote(
     nominal &&
     decimalFromString(nominal.value).value > ZERO_AMOUNT
       ? {
-          currency: nominal.currency,
+          currency: 'RUB',
           value: formatDecimal(
             divide(
               multiply(
@@ -96,9 +96,9 @@ export function bondQuote(
         }
       : null;
   const dirtyPrice =
-    cleanPrice && aci && aci.currency === cleanPrice.currency
+    cleanPrice && aci
       ? {
-          currency: cleanPrice.currency,
+          currency: 'RUB',
           value: formatDecimal(
             add(
               decimalFromString(cleanPrice.value),

src/modules/investments/instruments/bonds/infrastructure/bond-money.mapper.ts

@@ -1,10 +1 @@
-import { formatDecimal } from '#src/common/decimal';
+export { rubMoney as money } from '#src/integrations/tbank/decimal';
-import { decimal } from '#src/integrations/tbank/decimal';
-import { type TbankMoney } from '#src/integrations/tbank/tbank.api';
-
-export function money(value?: TbankMoney) {
-  const currency = value?.currency?.toUpperCase();
-  return value && currency
-    ? { currency, value: formatDecimal(decimal(value)) }
-    : null;
-}

src/modules/investments/instruments/stocks/application/get-stock-company.use-case.ts

@@ -70,16 +70,17 @@ export function metrics(
     // eslint-disable-next-line security/detect-object-injection -- Keys come from the fixed metric selection declared above.
     const value = values[key];
     const currency = values.currency?.toUpperCase() || null;
+    const rub = currency === 'RUB';
     return typeof value === 'number' &&
       Number.isFinite(value) &&
-      (unit !== 'money' || currency)
+      (unit !== 'money' || rub)
       ? [
           {
             key,
             value,
             unit,
             period,
-            currency: unit === 'money' ? currency : null,
+            currency: unit === 'money' ? 'RUB' : null,
           },
         ]
       : [];

src/modules/investments/instruments/stocks/application/stock-catalog.service.ts

@@ -45,7 +45,7 @@ export class StockCatalogService {
             price:
               last?.price && detail.currency
                 ? {
-                    currency: detail.currency,
+                    currency: 'RUB',
                     value: formatDecimal(decimal(last.price)),
                   }
                 : null,

src/modules/investments/instruments/stocks/application/stock-income.service.ts

@@ -6,7 +6,7 @@ import {
   multiply,
 } from '#src/common/decimal';
 import { ISO_DATE_LENGTH, ISO_DATE_START } from '#src/common/time';
-import { decimal } from '#src/integrations/tbank/decimal';
+import { rubMoney } from '#src/integrations/tbank/decimal';
 import {
   TbankAccessService,
   type TbankDividend,
@@ -131,11 +131,7 @@ export function stockDividends(
       const recordDate = timestamp(event.recordDate)?.slice(ISO_DATE_START, ISO_DATE_LENGTH) ?? null;
       const paymentDate = timestamp(event.paymentDate)?.slice(ISO_DATE_START, ISO_DATE_LENGTH) ?? null;
       const lastBuyDate = timestamp(event.lastBuyDate)?.slice(ISO_DATE_START, ISO_DATE_LENGTH) ?? null;
-      const currency = event.dividendNet?.currency?.toUpperCase();
+      const perShare = rubMoney(event.dividendNet);
-      const perShare =
-        currency && event.dividendNet
-          ? { currency, value: formatDecimal(decimal(event.dividendNet)) }
-          : null;
       // A future payment can have an already-fixed register: keep the event, but do not estimate entitlement from today's holding.
       const eventDate = paymentDate ?? recordDate;
       const timing: StockDividendDto['timing'] = eventDate
@@ -150,7 +146,7 @@ export function stockDividends(
         recordDate >= today &&
         timing === 'upcoming'
           ? {
-              currency: perShare.currency,
+              currency: 'RUB',
               value: formatDecimal(
                 multiply(quantity, decimalFromString(perShare.value)),
               ),

src/modules/investments/instruments/stocks/application/stock-market.service.ts

@@ -8,7 +8,7 @@ import {
   subtract,
 } from '#src/common/decimal';
 import { ISO_DATE_LENGTH, ISO_DATE_START } from '#src/common/time';
-import { decimal } from '#src/integrations/tbank/decimal';
+import { rubMoney } from '#src/integrations/tbank/decimal';
 
 import { CandleService } from '../../application/candle.service';
 import {
@@ -70,15 +70,8 @@ export function stockQuote(
   const { price: last, candle: previous, tradingStatus = null } = values;
   const share = values.instrument;
   const priceAt = timestamp(last?.time);
-  const currency = share?.currency?.toUpperCase();
+  const price = last?.price ? rubMoney({ ...last.price, currency: share?.currency }) : null;
-  const price =
+  const previousPrice = previous?.close ? rubMoney({ ...previous.close, currency: share?.currency }) : null;
-    last?.price && currency
-      ? { currency, value: formatDecimal(decimal(last.price)) }
-      : null;
-  const previousPrice =
-    previous?.close && currency
-      ? { currency, value: formatDecimal(decimal(previous.close)) }
-      : null;
   const difference =
     price && previousPrice
       ? subtract(
@@ -93,8 +86,8 @@ export function stockQuote(
     previousCloseDate: timestamp(previous?.time)?.slice(ISO_DATE_START, ISO_DATE_LENGTH) ?? null,
     previousClose: previousPrice,
     change:
-      difference && currency
+      difference
-        ? { currency, value: formatDecimal(difference) }
+        ? { currency: 'RUB', value: formatDecimal(difference) }
         : null,
     changePercent:
       difference &&

src/modules/investments/instruments/stocks/application/stock-screener.service.spec.ts

@@ -87,7 +87,6 @@ describe('StockScreenerService', () => {
     client.getAllShares.mockResolvedValueOnce([
       share(1, {
         countryOfRisk: undefined,
-        currency: undefined,
         isin: undefined,
         realExchange: undefined,
         sector: undefined,
@@ -96,7 +95,7 @@ describe('StockScreenerService', () => {
       }),
     ]);
     const result = await service.search('user-1', {});
-    expect(result.items[0]).toEqual(expect.objectContaining({ countryOfRisk: null, currency: null, isin: null, logoName: null, ticker: null }));
+    expect(result.items[0]).toEqual(expect.objectContaining({ countryOfRisk: null, currency: 'RUB', isin: null, logoName: null, ticker: null }));
 
     client.getAllShares.mockResolvedValueOnce([share(2, { name: ' ' })]);
     await expect(service.search('user-1', {})).rejects.toBeInstanceOf(ServiceUnavailableException);

src/modules/investments/instruments/stocks/domain/stock-screener-selection.rules.spec.ts

@@ -29,16 +29,23 @@ describe('selectStockScreenerInstruments', () => {
           share({ isin: 'D', sector: 'finance', uid: 'uid-4' }),
         ],
       },
-      { currency: 'RUB', query: 'star', sector: 'energy' },
+      { query: 'star', sector: 'energy' },
     );
 
     expect(result).toEqual({ asOf, instruments: [share({ isin: 'A', sector: 'energy' })] });
   });
 
+  it('filters out non-RUB instruments', () => {
+    const result = selectStockScreenerInstruments(
+      { asOf, instruments: [share({ currency: 'USD' }), share({ currency: undefined })] },
+      {},
+    );
+    expect(result.instruments).toEqual([]);
+  });
+
   it.each([
     ['sector', { sector: 'energy' }, share({ sector: undefined })],
     ['share type', { shareType: 'common' }, share({ shareType: 'preferred' })],
-    ['currency', { currency: 'USD' }, share({ currency: undefined })],
     ['exchange', { realExchange: 'MOEX' }, share({ realExchange: undefined })],
     ['country of risk', { countryOfRisk: 'RU' }, share({ countryOfRisk: 'US' })],
     ['query', { query: 'star' }, share({ name: undefined, ticker: undefined })],

src/modules/investments/instruments/stocks/domain/stock-screener-selection.rules.ts

@@ -7,7 +7,6 @@ export type StockScreenerCatalog = {
 
 export type StockScreenerConditions = {
   countryOfRisk?: string;
-  currency?: string;
   maxLot?: number;
   query?: string;
   realExchange?: string;
@@ -76,12 +75,7 @@ function matches(
   ) {
     return false;
   }
-  if (
+  if (instrument.currency?.toUpperCase() !== 'RUB') return false;
-    conditions.currency !== undefined &&
-    instrument.currency !== conditions.currency
-  ) {
-    return false;
-  }
   if (
     conditions.realExchange !== undefined &&
     instrument.realExchange !== conditions.realExchange

src/modules/investments/instruments/stocks/presentation/stock.controller.ts

@@ -89,7 +89,7 @@ export class StockController {
     criteria: StockScreenerCriteriaDto,
   ) {
     // The global whitelist pipe strips unknown keys before this param pipe runs, so only the raw body can reject them.
-    const allowed = new Set(['countryOfRisk', 'currency', 'maxLot', 'query', 'realExchange', 'sector', 'shareType']);
+    const allowed = new Set(['countryOfRisk', 'maxLot', 'query', 'realExchange', 'sector', 'shareType']);
     if (Object.keys(request.body as object).some((key) => !allowed.has(key))) {
       throw new BadRequestException();
     }

src/modules/investments/instruments/stocks/presentation/stock.dto.ts

@@ -52,7 +52,6 @@ export class StockScreenerCriteriaDto {
   @IsOptional()
   @IsString()
   @MinLength(MIN_TICKER_LENGTH)
-  currency?: string;
 
   @ApiPropertyOptional({ minLength: MIN_TICKER_LENGTH })
   @IsOptional()

src/modules/investments/operations/infrastructure/brokerage-operation.mapper.spec.ts

@@ -56,6 +56,24 @@ describe('mapBrokerageOperation', () => {
       payment: null,
     });
   });
+
+  it('filters non-RUB money out of every money field at ingest', () => {
+    expect(
+      mapBrokerageOperation({
+        id: 'usd',
+        date: { seconds: '1' },
+        type: 'OPERATION_TYPE_DIVIDEND',
+        payment: { currency: 'usd', units: '21' },
+        price: { currency: 'USD', units: '10' },
+        commission: { currency: 'EUR', units: '1' },
+      }),
+    ).toMatchObject({
+      id: 'usd',
+      payment: null,
+      price: null,
+      commission: null,
+    });
+  });
 });
 
 describe('executed trade quantity', () => {

src/modules/investments/operations/infrastructure/brokerage-operation.mapper.ts

@@ -1,8 +1,7 @@
-import { formatDecimal } from '#src/common/decimal';
 import { MILLISECONDS_PER_SECOND } from '#src/common/time';
-import { decimal } from '#src/integrations/tbank/decimal';
+import { rubMoney } from '#src/integrations/tbank/decimal';
 import { TbankOperationType } from '#src/integrations/tbank/tbank-protocol';
-import { TbankMoney, TbankOperationItem } from '#src/integrations/tbank/tbank.api';
+import { TbankOperationItem } from '#src/integrations/tbank/tbank.api';
 
 import { type OperationCategory } from '../../operation-category';
 import { BrokerageOperationDto } from '../presentation/brokerage-operation.dto';
@@ -56,7 +55,7 @@ export function mapBrokerageOperation(
     ticker: text(operation.ticker),
     instrumentType: text(operation.instrumentType),
     logoName: null,
-    payment: money(operation.payment),
+    payment: rubMoney(operation.payment),
     quantity:
       (operationCategory(operation.type) === 'trade'
         ? operation.quantityDone
@@ -67,9 +66,9 @@ export function mapBrokerageOperation(
               ? operation.quantityDone
               : operation.quantity,
           ),
-    price: money(operation.price),
+    price: rubMoney(operation.price),
-    accruedInterest: money(operation.accruedInt),
+    accruedInterest: rubMoney(operation.accruedInt),
-    commission: money(operation.commission),
+    commission: rubMoney(operation.commission),
   };
 }
 
@@ -77,13 +76,6 @@ function text(value: string | undefined): null | string {
   return value?.trim() || null;
 }
 
-function money(value: TbankMoney | undefined) {
-  const currency = value?.currency?.trim().toUpperCase();
-  return currency && value
-    ? { currency, value: formatDecimal(decimal(value)) }
-    : null;
-}
-
 export function operationTimestamp(
   value: undefined | { nanos?: number; seconds?: number | string },
 ) {

src/modules/investments/performance/domain/performance-availability.ts

@@ -8,7 +8,6 @@ export enum PerformanceUnavailableReason {
   AmbiguousReturn = 'AMBIGUOUS_RETURN',
   HistoryStartUnknown = 'HISTORY_START_UNKNOWN',
   IndexHistoryUnavailable = 'INDEX_HISTORY_UNAVAILABLE',
-  NonRubActivity = 'NON_RUB_ACTIVITY',
   NoSolution = 'NO_SOLUTION',
   OperationsHistoryIncomplete = 'OPERATIONS_HISTORY_INCOMPLETE',
   PortfolioValuationIncomplete = 'PORTFOLIO_VALUATION_INCOMPLETE',

src/modules/investments/performance/domain/performance-flows.spec.ts

@@ -30,12 +30,20 @@ describe('performance cash flows', () => {
     expect(result.flows).toHaveLength(2);
   });
 
-  it('detects non-RUB operations and unvalued securities transfers', () => {
+  it('detects unvalued securities transfers', () => {
     const result = readPerformanceOperations([
-      op('A', 'OPERATION_TYPE_INPUT', '2025-01-01T15:00:00Z', '10', 'usd'),
       op('B', 'OPERATION_TYPE_INPUT_SECURITIES', '2025-01-01T15:00:00Z', '0'),
     ]);
-    expect([...result.nonRubAccounts]).toEqual(['A']);
     expect([...result.unvaluedAccounts]).toEqual(['B']);
   });
+
+  it('skips non-RUB cash movements read back from persisted payloads', () => {
+    const result = readPerformanceOperations([
+      op('A', 'OPERATION_TYPE_INPUT', '2025-01-01T15:00:00Z', '100'),
+      op('A', 'OPERATION_TYPE_INPUT', '2025-02-01T15:00:00Z', '21', 'usd'),
+    ]);
+    expect(result.flows).toHaveLength(1);
+    expect(formatDecimal(sumFlows(result.flows))).toBe('100');
+    expect([...result.missingAmountAccounts]).toEqual([]);
+  });
 });

src/modules/investments/performance/domain/performance-flows.ts

@@ -68,6 +68,7 @@ function appendCashFlow(
     missingAmountAccounts.add(operation.accountId);
     return;
   }
+  // RUB-only: non-RUB cash movements have no rate to RUB and are left out of XIRR.
   if (value.currency !== 'RUB') return;
   const amount = magnitude(value.value);
   flows.push({
@@ -79,7 +80,6 @@ function appendCashFlow(
 
 export function readPerformanceOperations(operations: Operation[]) {
   const flows: PerformanceFlow[] = [];
-  const nonRubAccounts = new Set<string>();
   const unvaluedAccounts = new Set<string>();
   const missingAmountAccounts = new Set<string>();
   for (const operation of operations) {
@@ -87,14 +87,13 @@ export function readPerformanceOperations(operations: Operation[]) {
     if (typeof payload.type !== 'string') continue;
     const value = money(payload.payment);
     if (deposits.has(payload.type) || withdrawals.has(payload.type)) {
-      if (value && value.currency !== 'RUB') nonRubAccounts.add(operation.accountId);
       appendCashFlow(operation, payload, value, flows, missingAmountAccounts);
     } else if (securities.has(payload.type)) {
       // Securities moved in or out carry no money amount for the flow.
       unvaluedAccounts.add(operation.accountId);
     }
   }
-  return { flows, missingAmountAccounts, nonRubAccounts, unvaluedAccounts };
+  return { flows, missingAmountAccounts, unvaluedAccounts };
 }
 
 export function candidateTransfers(input: ReturnType<typeof readPerformanceOperations>): Candidate[] {

src/modules/investments/performance/performance.service.spec.ts

@@ -16,7 +16,7 @@ function account(accountId: string, amount = '121000') {
   return {
     accountId, name: accountId, historyFrom: first, historyBoundary: 'known',
     portfolio: { fetchedAt: end, payload: {
-      positions: [], totalsByCurrency: [{ currency: 'RUB', value: amount }],
+      positions: [], totals: { currency: 'RUB', value: amount },
     } },
     coverage: [{ from: first, to: coverageEnd, asOf: coverageEnd }],
     operations: [operation(accountId, 'OPERATION_TYPE_INPUT', '100000')],

src/modules/investments/performance/performance.service.ts

@@ -17,14 +17,13 @@ import {
   PerformanceReturnDto, PerformanceSeriesPointDto,
 } from './presentation/performance.dto';
 
-const RUB = 'RUB';
 const DAY_MS = 86_400_000;
 const DAYS_IN_YEAR = 365;
 const RATE_SCALE = 6;
 const MONEY_SCALE = 2;
+const RUB = 'RUB';
 const ZERO = 0;
 const ONE = 1;
-const ZERO_UNITS = 0n;
 const ZERO_DECIMAL = decimalFromString('0');
 const LAST_FLOW = -1;
 const ONE_DECIMAL = decimalFromString('1');
@@ -164,7 +163,7 @@ export class PerformanceService {
     const portfolio = account.portfolio;
     if (!portfolio) return fail(PerformanceUnavailableReason.PortfolioValuationIncomplete);
     const snapshot = portfolio.payload as { positions: { currentValue: unknown }[];
-      totalsByCurrency: { currency: string; value: string }[]; };
+      totals: { value: string }; };
     if (!isCompleteValuation(snapshot)) return fail(PerformanceUnavailableReason.PortfolioValuationIncomplete);
     if (!hasPerformanceCoverage(account.accountId, account.historyFrom, portfolio.fetchedAt, account.coverage)) {
       return fail(PerformanceUnavailableReason.OperationsHistoryIncomplete);
@@ -172,16 +171,10 @@ export class PerformanceService {
     const operations = account.operations.filter((op) => op.occurredAt <= portfolio.fetchedAt)
       .map((op) => ({ ...op, accountId: account.accountId }));
     const parsed = readPerformanceOperations(operations);
-    if (parsed.nonRubAccounts.size || snapshot.totalsByCurrency.some((row) =>
-      row.currency !== RUB && decimalFromString(row.value).value !== ZERO_UNITS)) {
-      return fail(PerformanceUnavailableReason.NonRubActivity);
-    }
     if (parsed.missingAmountAccounts.size) return fail(PerformanceUnavailableReason.OperationsHistoryIncomplete);
     if (parsed.unvaluedAccounts.size) return fail(PerformanceUnavailableReason.UnvaluedSecuritiesTransfer);
-    const value = snapshot.totalsByCurrency.find((row) => row.currency === RUB);
-    if (!value) return fail(PerformanceUnavailableReason.PortfolioValuationIncomplete);
     return {
-      included: { account, flows: parsed.flows, value: decimalFromString(value.value),
+      included: { account, flows: parsed.flows, value: decimalFromString(snapshot.totals.value),
         to: moscowDate(portfolio.fetchedAt) },
       reason: null,
     };

src/modules/investments/portfolio/application/forecast.service.ts

@@ -103,24 +103,21 @@ function filterEvents<T extends object>(payload: T, scopeKey: string, savedScope
     const [, from, to] = JSON.parse(scopeKey.slice('events/'.length)) as [string, string, string];
     const value = payload as T & {
       events?: { date: string; projectedAmount?: { currency: string; value: string }; type: string }[];
-      incomeTotalsByCurrency?: { currency: string; value: string }[];
+      incomeTotal?: { currency: string; value: string };
     };
-    if (!value.events || !value.incomeTotalsByCurrency) return payload;
+    if (!value.events || !value.incomeTotal) return payload;
     const events = value.events.filter((event) => event.date >= from && event.date <= to);
-    const totals = new Map<string, ReturnType<typeof decimalFromString>>();
+    let total = { value: 0n, scale: 0 };
     for (const event of events) {
       if (!['coupon', 'dividend'].includes(event.type) || !event.projectedAmount) continue;
-      const current = totals.get(event.projectedAmount.currency) ?? { value: 0n, scale: 0 };
+      total = add(total, decimalFromString(event.projectedAmount.value));
-      totals.set(event.projectedAmount.currency, add(current, decimalFromString(event.projectedAmount.value)));
     }
     const [, savedFrom, savedTo] = JSON.parse(savedScopeKey.slice('events/'.length)) as [string, string, string];
     return {
       ...value,
       window: { from: savedFrom, to: savedTo },
       events,
-      incomeTotalsByCurrency: [...totals]
+      incomeTotal: { currency: 'RUB', value: formatDecimal(total) },
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([currency, amount]) => ({ currency, value: formatDecimal(amount) })),
     };
   } catch {
     return payload;

src/modules/investments/portfolio/application/portfolio.service.spec.ts

@@ -145,19 +145,15 @@ describe('persistent portfolio projection', () => {
       ]),
     ).toEqual([
       ['Known', 'STOCK', '2'],
-      ['B', 'OTHER', '-0.5'],
     ]);
     expect(snapshot.positions[0].absoluteReturn).toEqual({
       currency: 'RUB',
       value: '2.000000002',
     });
-    expect(snapshot.totalsByCurrency).toEqual([
+    expect(snapshot.totals).toEqual({ currency: 'RUB', value: '7.000000002' });
-      { currency: 'RUB', value: '7.000000002' },
+    expect(snapshot.cash).toEqual({ currency: 'RUB', value: '1' });
-      { currency: 'USD', value: '-2' },
-    ]);
-    expect(snapshot.cashBalances).toEqual([{ currency: 'RUB', value: '1' }]);
   });
-  it('keeps net-zero cash groups, missing valuations and incompatible currencies distinct', async () => {
+  it('filters non-RUB cash and positions out of the RUB-only snapshot', async () => {
     repository.reserve.mockResolvedValueOnce({
       launch: true,
       work: { id: 'work', attemptId: 'attempt' },
@@ -180,17 +176,10 @@ describe('persistent portfolio projection', () => {
     assert(handle);
     await handle.done;
     const snapshot = (repository.publish.mock.calls as [unknown, string, PortfolioDto][])[0][2];
-    expect(snapshot.cashBalances).toEqual([
+    expect(snapshot.cash).toEqual({ currency: 'RUB', value: '0' });
-      { currency: 'RUB', value: '0' },
+    expect(snapshot.totals).toEqual({ currency: 'RUB', value: '0' });
-      { currency: 'EUR', value: '1' },
-    ]);
-    expect(snapshot.totalsByCurrency).toEqual([
-      { currency: 'EUR', value: '1' },
-      { currency: 'USD', value: '3' },
-    ]);
     expect(snapshot.positions[0].currentValue).toBeNull();
-    expect(snapshot.positions[1].absoluteReturn).toBeNull();
+    expect(snapshot.positions).toHaveLength(1);
-    expect(snapshot.positions[1].averagePurchasePrice).toEqual({ currency: 'RUB', value: '2' });
   });
 
   it('counts cash once when T-Bank also returns it as a CURRENCY position', async () => {
@@ -213,9 +202,9 @@ describe('persistent portfolio projection', () => {
     assert(handle);
     await handle.done;
     const snapshot = (repository.publish.mock.calls as [unknown, string, PortfolioDto][])[0][2];
-    expect(snapshot.totalsByCurrency).toEqual([{ currency: 'RUB', value: '121.49' }]);
+    expect(snapshot.totals).toEqual({ currency: 'RUB', value: '121.49' });
-    expect(snapshot.positions.map((position) => position.type)).toEqual(['FUND', 'CURRENCY']);
+    expect(snapshot.positions.map((position) => position.type)).toEqual(['FUND']);
-    expect(snapshot.structure.currencies[0].totalValue).toBe('121.49');
+    expect(snapshot.structure.totalValue).toBe('121.49');
   });
 
   // Test intent: a corrupted Json payload must fail loudly instead of being spread into the API response.
@@ -235,9 +224,9 @@ describe('persistent portfolio projection', () => {
       lastSuccessfulAt: membershipAt.toISOString(),
       isStale: false,
       positions: [],
-      cashBalances: [],
+      cash: { currency: 'RUB', value: '0' },
-      structure: { currencies: [], unvaluedCategories: [] },
+      structure: { totalValue: '1.000000001', hasNegativeValues: false, categories: [], unvaluedCategories: [] },
-      totalsByCurrency: [{ currency: 'RUB', value: '1.000000001' }],
+      totals: { currency: 'RUB', value: '1.000000001' },
     };
     const account = {
       accountId: 'a',
@@ -261,8 +250,8 @@ describe('persistent portfolio projection', () => {
     expect(partial.meta.availability).toBe('temporarily-unavailable');
     expect(partial.meta.completeness).toBe('incomplete');
     const saved = await service.saved('user', 'all');
-    expect(saved.accounts[0].snapshot?.totalsByCurrency).toEqual(
+    expect(saved.accounts[0].snapshot?.totals).toEqual(
-      snapshot.totalsByCurrency,
+      snapshot.totals,
     );
     expect(saved.accounts[1].snapshot).toBeNull();
     repository.read.mockResolvedValue({
@@ -279,9 +268,9 @@ describe('persistent portfolio projection', () => {
       work: [],
     });
     const complete = await service.read('user', 'all');
-    expect(complete.data?.totalsByCurrency).toEqual([
+    expect(complete.data?.totals).toEqual({
-      { currency: 'RUB', value: '2.000000002' },
+      currency: 'RUB', value: '2.000000002',
-    ]);
+    });
     expect(complete.data?.lastSuccessfulAt).toBe(new Date(0).toISOString());
     expect(complete.data?.isStale).toBe(true);
     expect(tbank.getPortfolio).not.toHaveBeenCalled();

src/modules/investments/portfolio/application/portfolio.service.ts

@@ -25,7 +25,7 @@ import {
   TbankSyncRepository,
 } from '../../tbank-sync/tbank-sync.api';
 import { portfolioStructure } from '../domain/portfolio-structure';
-import { sumMoneyByCurrency } from '../domain/portfolio-totals';
+import { sumMoney } from '../domain/portfolio-totals';
 import {
   portfolioFreshForMs,
   PortfolioRepository,
@@ -184,16 +184,16 @@ export class PortfolioService {
             isStale: portfolios.length
               ? portfolios.some((portfolio) => portfolio.isStale)
               : saved.membership.freshness !== 'fresh',
-            totalsByCurrency: sumMoneyByCurrency(
+            totals: sumMoney(
-              portfolios.flatMap((portfolio) => portfolio.totalsByCurrency),
+              portfolios.map((portfolio) => portfolio.totals),
             ),
-            cashBalances: sumMoneyByCurrency(
+            cash: sumMoney(
-              portfolios.flatMap((portfolio) => portfolio.cashBalances),
+              portfolios.map((portfolio) => portfolio.cash),
             ),
             positions: portfolios.flatMap((portfolio) => portfolio.positions),
             structure: portfolioStructure(
               portfolios.flatMap((portfolio) => portfolio.positions),
-              portfolios.flatMap((portfolio) => portfolio.cashBalances),
+              portfolios.map((portfolio) => portfolio.cash),
             ),
           };
     const work =

src/modules/investments/portfolio/domain/complete-valuation.spec.ts

@@ -1,14 +1,13 @@
 import { isCompleteValuation } from './complete-valuation';
 
 describe('isCompleteValuation', () => {
-  it('requires an actual currency total and every position value', () => {
+  it('requires an actual total and every position value', () => {
-    expect(isCompleteValuation({ totalsByCurrency: [], positions: [] })).toBe(false);
     expect(isCompleteValuation({
-      totalsByCurrency: [{ currency: 'RUB', value: '100' }],
+      totals: { value: '100' },
       positions: [{ currentValue: null }],
     })).toBe(false);
     expect(isCompleteValuation({
-      totalsByCurrency: [{ currency: 'RUB', value: '100' }],
+      totals: { value: '100' },
       positions: [{ currentValue: { currency: 'RUB', value: '0' } }],
     })).toBe(true);
   });

src/modules/investments/portfolio/domain/complete-valuation.ts

@@ -1,13 +1,11 @@
 type Valuation = {
   positions: { currentValue: unknown }[];
-  totalsByCurrency: unknown[];
+  totals: { value: string };
 };
 
-const MIN_TOTALS_COUNT = 0;
-
 export function isCompleteValuation(
   snapshot: Valuation,
 ): boolean {
-  return snapshot.totalsByCurrency.length > MIN_TOTALS_COUNT &&
+  return Boolean(snapshot.totals) &&
     snapshot.positions.every((position) => position.currentValue !== null);
 }

src/modules/investments/portfolio/domain/portfolio-structure.spec.ts

@@ -4,10 +4,9 @@ import { portfolioStructure } from './portfolio-structure';
 const position = (
   type: string,
   value: null | string,
-  currency = 'RUB',
 ): PortfolioPositionDto => ({
   type,
-  currentValue: value === null ? null : { currency, value },
+  currentValue: value === null ? null : { currency: 'RUB', value },
   quantity: '1',
   displayName: 'Fixture',
   figi: null,
@@ -20,18 +19,18 @@ const position = (
   averagePurchasePrice: null,
 });
 
+const rub = (value: string) => ({ currency: 'RUB', value });
+
 describe('portfolio structure', () => {
-  it('counts cash once and skips CURRENCY positions that mirror it', () => {
+  it('builds a single RUB composition with cash counted once', () => {
     const result = portfolioStructure(
       [
         position('STOCK', '60'),
         position('BOND', '20'),
-        position('CURRENCY', '10'),
       ],
-      [{ currency: 'RUB', value: '10' }],
+      [rub('10')],
     );
-    expect(result.currencies[0]).toEqual({
+    expect(result).toEqual({
-      currency: 'RUB',
       totalValue: '90',
       hasNegativeValues: false,
       categories: [
@@ -40,75 +39,58 @@ describe('portfolio structure', () => {
         { type: 'OTHER', value: '0', sharePercent: '0' },
         { type: 'CASH', value: '10', sharePercent: '11.111111' },
       ],
+      unvaluedCategories: [],
     });
   });
 
-  it('sums beyond Number precision and separates currencies without FX', () => {
+  it('sums beyond Number precision', () => {
     const result = portfolioStructure(
       [
         position('STOCK', '9007199254740993.000000001'),
         position('STOCK', '0.000000009'),
-        position('BOND', '2', 'USD'),
+        position('BOND', '3.000000001'),
       ],
-      [{ currency: 'USD', value: '1' }],
+      [rub('1')],
     );
-    expect(result.currencies[0].totalValue).toBe('9007199254740993.00000001');
+    expect(result.totalValue).toBe('9007199254740997.000000011');
-    expect(result.currencies[1].totalValue).toBe('3');
+    expect(result.categories[0].sharePercent).toBe('100');
-    expect(result.currencies[1].categories[1].sharePercent).toBe('66.666667');
+    expect(result.categories[1].sharePercent).toBe('0');
-    expect(result.currencies[1].categories[3].sharePercent).toBe('33.333333');
+    expect(result.categories[3].sharePercent).toBe('0');
   });
 
   it('represents cash-only, empty and zero-valued portfolios', () => {
-    expect(portfolioStructure([], []).currencies).toEqual([]);
+    expect(portfolioStructure([], [rub('0')]).totalValue).toBe('0');
+    expect(portfolioStructure([], [rub('10')]).categories[3].sharePercent).toBe('100');
     expect(
-      portfolioStructure([], [{ currency: 'EUR', value: '10' }]).currencies[0]
+      portfolioStructure([position('STOCK', '0')], [rub('0')]).categories.every(
-        .categories[3].sharePercent,
-    ).toBe('100');
-    expect(
-      portfolioStructure(
-        [position('STOCK', '0')],
-        [],
-      ).currencies[0].categories.every((item) => item.sharePercent === null),
-    ).toBe(true);
-  });
-
-  it('retains unvalued categories without assigning zero or guessing a currency', () => {
-    const result = portfolioStructure(
-      [position('BOND', null), position('BOND', null), position('STOCK', '50')],
-      [],
-    );
-    expect(result.unvaluedCategories).toEqual([{ type: 'BOND', count: 2 }]);
-    expect(result.currencies[0].totalValue).toBe('50');
-    expect(
-      result.currencies[0].categories.every(
         (item) => item.sharePercent === null,
       ),
     ).toBe(true);
+  });
+
+  it('retains unvalued categories without assigning zero', () => {
+    const result = portfolioStructure(
+      [position('BOND', null), position('BOND', null), position('STOCK', '50')],
+      [rub('0')],
+    );
+    expect(result.unvaluedCategories).toEqual([{ type: 'BOND', count: 2 }]);
+    expect(result.totalValue).toBe('50');
     expect(
-      portfolioStructure([position('OTHER', null)], []).currencies,
+      result.categories.every((item) => item.sharePercent === null),
-    ).toEqual([]);
+    ).toBe(true);
   });
 
   it.each([
-    [[position('STOCK', '-20'), position('STOCK', '100')], []],
+    [[position('STOCK', '-20'), position('STOCK', '100')], rub('0')],
-    [
+    [[], rub('-20')],
-      [],
+    [[position('BOND', '-20'), position('BOND', '20')], rub('0')],
-      [
-        { currency: 'RUB', value: '-20' },
-        { currency: 'RUB', value: '100' },
-      ],
-    ],
-    [[position('BOND', '-20')], []],
-    [[position('BOND', '-20'), position('BOND', '20')], []],
   ])(
     'preserves negative constituents even when their category nets positive or zero',
     (positions, cash) => {
-      const result = portfolioStructure(positions, cash);
+      const result = portfolioStructure(positions, [cash]);
-      expect(result.currencies[0].hasNegativeValues).toBe(true);
+      expect(result.hasNegativeValues).toBe(true);
       expect(
-        result.currencies[0].categories.every(
+        result.categories.every((item) => item.sharePercent === null),
-          (item) => item.sharePercent === null,
-        ),
       ).toBe(true);
     },
   );

src/modules/investments/portfolio/domain/portfolio-structure.ts

@@ -20,71 +20,52 @@ const categoryTypes = ['STOCK', 'BOND', 'OTHER', 'CASH'] as const;
 // Build from positions and cash, never from totals (which already include cash).
 export function portfolioStructure(
   positions: { currentValue: Money | null; type: string }[],
-  cash: Money[],
+  cashAmounts: Money[],
 ) {
-  const currencies = new Map<
+  const values = categoryTypes.map(() => decimalFromString('0'));
-    string,
+  let hasNegativeValues = false;
-    {
-      hasNegativeValues: boolean;
-      values: ReturnType<typeof decimalFromString>[];
-    }
-  >();
   const unvalued = new Map<string, number>();
   const include = (type: string, money: Money) => {
-    const group = currencies.get(money.currency) ?? {
-      values: categoryTypes.map(() => decimalFromString('0')),
-      hasNegativeValues: false,
-    };
     const index = categoryTypes.findIndex((category) => category === type);
     const value = decimalFromString(money.value);
     // eslint-disable-next-line security/detect-object-injection -- The numeric index belongs to the fixed portfolio category array.
-    group.values[index] = add(group.values[index], value);
+    values[index] = add(values[index], value);
-    group.hasNegativeValues ||= value.value < ZERO_AMOUNT;
+    hasNegativeValues ||= value.value < ZERO_AMOUNT;
-    currencies.set(money.currency, group);
   };
   for (const position of positions) {
-    // CURRENCY positions mirror cash, which is counted once as CASH below.
-    if (position.type === 'CURRENCY') continue;
     const type = ['BOND', 'STOCK'].includes(position.type)
       ? position.type
       : 'OTHER';
     if (position.currentValue) include(type, position.currentValue);
     else unvalued.set(type, (unvalued.get(type) ?? INITIAL_UNVALUED_COUNT) + POSITION_INCREMENT);
   }
-  for (const amount of cash) include('CASH', amount);
+  for (const amount of cashAmounts) include('CASH', amount);
 
+  const total = values.reduce(add, decimalFromString('0'));
+  const canCalculateShares =
+    !unvalued.size && !hasNegativeValues && total.value > ZERO_AMOUNT;
+  const categories = values.map((value, index) => ({
+    // eslint-disable-next-line security/detect-object-injection -- The numeric index belongs to the fixed portfolio category array.
+    type: categoryTypes[index],
+    value: formatDecimal(value),
+    // Rounded to six decimal places using integer arithmetic. Only the
+    // resulting dimensionless percentage is passed to chart geometry.
+    sharePercent: canCalculateShares
+      ? formatDecimal({
+          value:
+            (value.value *
+              DECIMAL_RADIX ** BigInt(total.scale - value.scale) *
+              PERCENT_SCALED_FACTOR +
+              total.value / ROUNDING_DIVISOR) /
+              total.value,
+          scale: SHARE_PERCENT_DECIMAL_PLACES,
+        })
+      : null,
+  }));
   return {
+    totalValue: formatDecimal(total),
+    hasNegativeValues,
+    categories,
     unvaluedCategories: [...unvalued].map(([type, count]) => ({ type, count })),
-    currencies: [...currencies]
-      .sort(([left], [right]) => left.localeCompare(right))
-      .map(([currency, group]) => {
-        const total = group.values.reduce(add, decimalFromString('0'));
-        const canCalculateShares =
-          !unvalued.size && !group.hasNegativeValues && total.value > ZERO_AMOUNT;
-        const categories = group.values.map((value, index) => ({
-          // eslint-disable-next-line security/detect-object-injection -- The numeric index belongs to the fixed portfolio category array.
-          type: categoryTypes[index],
-          value: formatDecimal(value),
-          // Rounded to six decimal places using integer arithmetic. Only the
-          // resulting dimensionless percentage is passed to chart geometry.
-          sharePercent: canCalculateShares
-            ? formatDecimal({
-                value:
-                  (value.value *
-                    DECIMAL_RADIX ** BigInt(total.scale - value.scale) *
-                    PERCENT_SCALED_FACTOR +
-                    total.value / ROUNDING_DIVISOR) /
-                    total.value,
-                scale: SHARE_PERCENT_DECIMAL_PLACES,
-              })
-            : null,
-        }));
-        return {
-          currency,
-          totalValue: formatDecimal(total),
-          hasNegativeValues: group.hasNegativeValues,
-          categories,
-        };
-      }),
   };
 }

src/modules/investments/portfolio/domain/portfolio-totals.ts

@@ -1,23 +1,12 @@
 import type { Money } from '#src/common/money.types';
 
-import {
+import { add, decimalFromString, formatDecimal } from '#src/common/decimal';
-  add,
-  decimalFromString,
-  formatDecimal,
-} from '#src/common/decimal';
 
-export function sumMoneyByCurrency(amounts: Money[]): Money[] {
+// RUB-only: all inputs are expected to be RUB Money.
-  const totals = new Map<string, ReturnType<typeof decimalFromString>>();
+export function sumMoney(amounts: Money[]): Money {
-  for (const amount of amounts) {
+  const total = amounts.reduce(
-    totals.set(
+    (sum, amount) => add(sum, decimalFromString(amount.value)),
-      amount.currency,
+    decimalFromString('0'),
-      add(
+  );
-        totals.get(amount.currency) ?? decimalFromString('0'),
+  return { currency: 'RUB', value: formatDecimal(total) };
-        decimalFromString(amount.value),
-      ),
-    );
-  }
-  return [...totals]
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([currency, value]) => ({ currency, value: formatDecimal(value) }));
 }

src/modules/investments/portfolio/infrastructure/portfolio.repository.ts

@@ -150,27 +150,23 @@ export class PortfolioRepository {
           create: { userId: attempt.userId, accountId },
           update: { deletedAt: null },
         });
-        for (const { currency, value } of snapshot.totalsByCurrency) {
+        await tx.tbankPortfolioValuePoint.upsert({
-          await tx.tbankPortfolioValuePoint.upsert({
+          where: {
-            where: {
+            userId_accountId_attemptId: {
-              userId_accountId_attemptId_currency: {
-                userId: attempt.userId,
-                accountId,
-                attemptId: attempt.attemptId,
-                currency,
-              },
-            },
-            create: {
               userId: attempt.userId,
               accountId,
               attemptId: attempt.attemptId,
-              currency,
-              value,
-              capturedAt: data.fetchedAt,
             },
-            update: {},
+          },
-          });
+          create: {
-        }
+            userId: attempt.userId,
+            accountId,
+            attemptId: attempt.attemptId,
+            value: snapshot.totals.value,
+            capturedAt: data.fetchedAt,
+          },
+          update: {},
+        });
       }
       return true;
     });
@@ -198,8 +194,9 @@ export function portfolioSnapshot(value: Prisma.JsonValue): PortfolioDto {
   const snapshot = value as null | Partial<PortfolioDto>;
   if (
     !Array.isArray(snapshot?.positions) ||
-    !Array.isArray(snapshot.totalsByCurrency) ||
+    !snapshot.totals?.currency ||
-    !Array.isArray(snapshot.cashBalances)
+    !snapshot.cash?.currency ||
+    !Array.isArray(snapshot.structure?.categories)
   ) {
     throw new Error('Corrupted portfolio snapshot payload');
   }

src/modules/investments/portfolio/infrastructure/tbank-portfolio.mapper.ts

@@ -8,13 +8,12 @@ import {
   multiply,
   subtract,
 } from '#src/common/decimal';
-import { decimal } from '#src/integrations/tbank/decimal';
+import { decimal, rubMoney } from '#src/integrations/tbank/decimal';
 import {
   metadataKey,
   type TbankInstrument,
   type TbankMoney,
   TbankPortfolio,
-  TbankPositions,
 } from '#src/integrations/tbank/tbank.api';
 
 import type { Classification } from '../application/position-classification.service';
@@ -22,6 +21,8 @@ import type { PortfolioDto, PortfolioPositionDto } from '../presentation/portfol
 
 import { portfolioStructure } from '../domain/portfolio-structure';
 
+const RUB = 'RUB';
+
 const types: Record<string, string> = {
   share: 'STOCK',
   bond: 'BOND',
@@ -35,32 +36,36 @@ const types: Record<string, string> = {
 
 function mapPortfolio(
   upstream: NonNullable<TbankPortfolio['positions']>,
-  cash: TbankMoney[],
+  cashBalances: TbankMoney[],
   metadata: ReadonlyMap<string, { data?: null | TbankInstrument }>,
   lastSuccessfulAt: string,
   classification: ReadonlyMap<string, Classification> = new Map(),
 ): PortfolioDto {
   const positions = upstream
+    // Currency positions mirror cash balances and are non-RUB holdings by definition.
+    .filter((position) => types[position.instrumentType?.toLowerCase() ?? ''] !== 'CURRENCY' &&
+      (!position.currentPrice?.currency?.trim() || position.currentPrice.currency.trim().toUpperCase() === RUB))
     .map((position) => mapPosition(position, metadata.get(metadataKey(position))?.data ?? null, classification.get(metadataKey(position))))
     .filter((position): position is PortfolioPositionDto => position !== null);
-  const balances = new Map<string, ReturnType<typeof decimal>>();
+  let cashTotal = decimal({});
-  for (const value of cash) {
+  for (const value of cashBalances) {
-    const currency = value.currency?.trim().toUpperCase();
+    if (value.currency?.trim().toUpperCase() !== RUB) continue;
-    const amount = decimal(value);
+    cashTotal = add(cashTotal, decimal(value));
-    if (!currency || isZero(amount)) continue;
-    balances.set(currency, add(balances.get(currency) ?? decimal({}), amount));
   }
-  const cashBalances = [...balances].map(([currency, value]) => ({
+  const cash: Money = { currency: RUB, value: formatDecimal(cashTotal) };
-    currency,
+  let total = cashTotal;
-    value: formatDecimal(value),
+  for (const position of positions) {
-  }));
+    if (!position.currentValue) continue;
+    total = add(total, decimalFromString(position.currentValue.value));
+  }
+  const totals: Money = { currency: RUB, value: formatDecimal(total) };
   return {
     lastSuccessfulAt,
     isStale: false,
-    totalsByCurrency: totalsByCurrency(upstream, cash),
+    totals,
     positions,
-    cashBalances,
+    cash,
-    structure: portfolioStructure(positions, cashBalances),
+    structure: portfolioStructure(positions, [cash]),
   };
 }
 
@@ -73,16 +78,16 @@ function mapPosition(
   if (isZero(quantity)) return null;
   const figi = position.figi?.trim() || null;
   const instrumentUid = position.instrumentUid?.trim() || null;
-  const currentPrice = money(position.currentPrice);
+  const currentPrice = rubMoney(position.currentPrice);
-  const averagePurchasePrice = money(position.averagePositionPrice);
+  const averagePurchasePrice = rubMoney(position.averagePositionPrice);
   const currentValue = currentPrice && {
-    currency: currentPrice.currency,
+    currency: RUB,
     value: formatDecimal(multiply(quantity, decimalFromString(currentPrice.value))),
   };
   const absoluteReturn =
-    currentPrice && averagePurchasePrice && currentPrice.currency === averagePurchasePrice.currency
+    currentPrice && averagePurchasePrice
       ? {
-          currency: currentPrice.currency,
+          currency: RUB,
           value: formatDecimal(multiply(
             subtract(decimalFromString(currentPrice.value), decimalFromString(averagePurchasePrice.value)),
             quantity,
@@ -106,44 +111,4 @@ function mapPosition(
   };
 }
 
-function money(value: TbankMoney | undefined): Money | null {
+export { mapPortfolio };
-  const currency = value?.currency?.trim().toUpperCase();
-  return currency && value
-    ? { currency, value: formatDecimal(decimal(value)) }
-    : null;
-}
-
-function totalsByCurrency(
-  positions: NonNullable<TbankPortfolio['positions']>,
-  money: NonNullable<TbankPositions['money']>,
-): Money[] {
-  const totals = new Map<string, ReturnType<typeof decimal>>();
-  const addTotal = (
-    currency: string | undefined,
-    amount: ReturnType<typeof decimal>,
-  ) => {
-    const normalizedCurrency = currency?.trim().toUpperCase();
-    if (!normalizedCurrency || isZero(amount)) return;
-    totals.set(
-      normalizedCurrency,
-      add(totals.get(normalizedCurrency) ?? decimal({}), amount),
-    );
-  };
-
-  for (const value of money) addTotal(value.currency, decimal(value));
-  for (const position of positions) {
-    const price = position.currentPrice;
-    // CURRENCY positions mirror the cash balances already added above.
-    if (!price || types[position.instrumentType?.toLowerCase() ?? ''] === 'CURRENCY') continue;
-    addTotal(
-      price.currency,
-      multiply(decimal(position.quantity ?? {}), decimal(price)),
-    );
-  }
-
-  return [...totals]
-    .filter(([, value]) => !isZero(value))
-    .map(([currency, value]) => ({ currency, value: formatDecimal(value) }));
-}
-
-export { mapPortfolio, totalsByCurrency };

src/modules/investments/portfolio/presentation/portfolio.dto.ts

@@ -85,22 +85,6 @@ export class PortfolioStructureCategoryDto {
   declare sharePercent: null | string;
 }
 
-export class PortfolioStructureCurrencyDto {
-  @ApiProperty()
-  declare currency: string;
-
-  @ApiProperty()
-  declare totalValue: string;
-
-  @ApiProperty({
-    description: 'Any negative constituent, even if netted positive.',
-  })
-  declare hasNegativeValues: boolean;
-
-  @ApiProperty({ type: PortfolioStructureCategoryDto, isArray: true })
-  declare categories: PortfolioStructureCategoryDto[];
-}
-
 export class PortfolioUnvaluedCategoryDto {
   @ApiProperty({ enum: ['STOCK', 'BOND', 'OTHER'] })
   declare type: string;
@@ -110,13 +94,21 @@ export class PortfolioUnvaluedCategoryDto {
 }
 
 export class PortfolioStructureDto {
-  @ApiProperty({ type: PortfolioStructureCurrencyDto, isArray: true })
+  @ApiProperty({ description: 'Exact known total as a decimal string.' })
-  declare currencies: PortfolioStructureCurrencyDto[];
+  declare totalValue: string;
+
+  @ApiProperty({
+    description: 'Any negative constituent, even if netted positive.',
+  })
+  declare hasNegativeValues: boolean;
+
+  @ApiProperty({ type: PortfolioStructureCategoryDto, isArray: true })
+  declare categories: PortfolioStructureCategoryDto[];
 
   @ApiProperty({
     type: PortfolioUnvaluedCategoryDto, isArray: true,
     description:
-      'Positions without current value and known valuation currency. Shares are unavailable across all currencies when nonempty.',
+      'Positions without current value. Shares are unavailable when nonempty.',
   })
   declare unvaluedCategories: PortfolioUnvaluedCategoryDto[];
 }
@@ -128,14 +120,14 @@ export class PortfolioDto {
   @ApiProperty()
   declare isStale: boolean;
 
-  @ApiProperty({ type: MoneyDto, isArray: true })
+  @ApiProperty({ type: MoneyDto })
-  declare totalsByCurrency: MoneyDto[];
+  declare totals: MoneyDto;
 
   @ApiProperty({ type: PortfolioPositionDto, isArray: true })
   declare positions: PortfolioPositionDto[];
 
-  @ApiProperty({ type: MoneyDto, isArray: true })
+  @ApiProperty({ type: MoneyDto })
-  declare cashBalances: MoneyDto[];
+  declare cash: MoneyDto;
 
   @ApiProperty({ type: PortfolioStructureDto })
   declare structure: PortfolioStructureDto;

src/modules/investments/upcoming-events/upcoming-event.mapper.ts

@@ -61,10 +61,10 @@ function projectedMoney(
   value: string,
   currency: string | undefined,
 ): UpcomingEventDto['projectedAmount'] {
-  const normalizedCurrency = currency?.trim().toUpperCase();
+  // RUB-only: projected income in other currencies is filtered out.
-  if (!normalizedCurrency) return null;
+  if (currency?.trim().toUpperCase() !== 'RUB') return null;
   return {
-    currency: normalizedCurrency,
+    currency: 'RUB',
     value: formatDecimal(multiply(quantity, decimalFromString(value))),
   };
 }

src/modules/investments/upcoming-events/upcoming-events.dto.ts

@@ -90,8 +90,8 @@ export class UpcomingEventsDto {
   @ApiProperty({ type: UpcomingEventDto, isArray: true })
   declare events: UpcomingEventDto[];
 
-  @ApiProperty({ type: MoneyDto, isArray: true })
+  @ApiProperty({ type: MoneyDto })
-  declare incomeTotalsByCurrency: MoneyDto[];
+  declare incomeTotal: MoneyDto;
 }
 
 export class UpcomingEventsResourceDto {

src/modules/investments/upcoming-events/upcoming-events.service.spec.ts

@@ -13,19 +13,19 @@ const metadata = {
   logoName: null,
 };
 describe('forecast financial projections', () => {
-  it('preserves registry dates, source currency and exact signed fractional quantities', () => {
+  it('preserves registry dates and exact signed fractional quantities', () => {
     expect(
       dividendEvent(metadata, decimalFromString('-2.5'), {
         recordDate: { seconds: String(Date.parse('2026-10-13Z') / 1000) },
-        dividendNet: { currency: 'usd', units: '10', nano: 1 },
+        dividendNet: { currency: 'rub', units: '10', nano: 1 },
       }),
     ).toMatchObject({
       date: '2026-10-13',
       dateKind: 'registry',
-      projectedAmount: { currency: 'USD', value: '-25.0000000025' },
+      projectedAmount: { currency: 'RUB', value: '-25.0000000025' },
     });
   });
-  it('does not invent an amount for offers or missing currency', () => {
+  it('does not invent an amount for offers, missing or non-RUB currency', () => {
     expect(
       bondEvent(metadata, decimalFromString('3'), {
         type: 'offer',
@@ -38,6 +38,12 @@ describe('forecast financial projections', () => {
         dividendNet: { units: '10' },
       }).projectedAmount,
     ).toBeNull();
+    expect(
+      dividendEvent(metadata, decimalFromString('3'), {
+        recordDate: { seconds: '1790812800' },
+        dividendNet: { currency: 'usd', units: '10' },
+      }).projectedAmount,
+    ).toBeNull();
   });
   it('preserves redemption as a non-income event with its exact amount', () => {
     expect(

src/modules/investments/upcoming-events/upcoming-events.service.ts

@@ -156,7 +156,7 @@ export class UpcomingEventsService {
           accountId,
           calculatedAt: new Date().toISOString(),
           events,
-          incomeTotalsByCurrency: incomeTotals(events),
+          incomeTotal: incomeTotal(events),
         }
       : undefined;
     return this.forecasts.result({
@@ -286,22 +286,13 @@ function dateWindow(query: UpcomingEventsQueryDto) {
   return { from, to };
 }
 
-function incomeTotals(events: UpcomingEventDto[]): MoneyDto[] {
+function incomeTotal(events: UpcomingEventDto[]): MoneyDto {
-  const totals = new Map<string, Decimal>();
+  let total: Decimal = { value: 0n, scale: 0 };
   for (const event of events) {
     if (!['coupon', 'dividend'].includes(event.type) || !event.projectedAmount) {
       continue;
     }
-    const current = totals.get(event.projectedAmount.currency) ?? {
+    total = add(total, decimalFromString(event.projectedAmount.value));
-      value: 0n,
-      scale: 0,
-    };
-    totals.set(
-      event.projectedAmount.currency,
-      add(current, decimalFromString(event.projectedAmount.value)),
-    );
   }
-  return [...totals]
+  return { currency: 'RUB', value: formatDecimal(total) };
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([currency, value]) => ({ currency, value: formatDecimal(value) }));
 }

test/bank-cards-durability.cjs

@@ -91,7 +91,7 @@ function seedTbank(owner) {
   db.transaction(() => {
     db.prepare('UPDATE TbankConnection SET membershipAt=?,membershipRevision=1 WHERE userId=?').run(now, owner);
     insert('TbankAccount', { ...scope, type: 'BROKERAGE', name: 'Synthetic persisted account', upstreamOrder: 0 });
-    insert('TbankPortfolio', { ...scope, payload: JSON.stringify({ positions: [], cashBalances: [], totalsByCurrency: [], structure: { currencies: [], unvaluedCategories: [] } }), fetchedAt: now });
+    insert('TbankPortfolio', { ...scope, payload: JSON.stringify({ positions: [], cash: { currency: 'RUB', value: '0' }, totals: { currency: 'RUB', value: '0' }, structure: { totalValue: '0', hasNegativeValues: false, categories: [], unvaluedCategories: [] } }), fetchedAt: now });
     insert('TbankOperation', { ...scope, brokerOperationId: 'durable-income', occurredAt: now, category: 'income', payload: JSON.stringify({ id: 'durable-income', payment: exact }) });
     insert('TbankOperationCoverage', { ...scope, from: now - 1000, to: now + 1000, fetchedAt: now, asOf: now });
     insert('TbankForecast', { userId: owner, revision, scopeKey: 'durable-forecast', membershipRevision: 1, payload: JSON.stringify({ incomeTotalsByCurrency: [exact] }), dependencyRevisions: JSON.stringify({ portfolio: 1 }), sourceTimestamps: JSON.stringify({ portfolio: new Date(now).toISOString() }), calculatedAt: now });

test/online-upstream.ts

@@ -62,12 +62,12 @@ export function failUpstream(rpc: jest.Mock, kind: 'bond' | 'share', code: numbe
     uid: 'e6123145-9665-43e0-8413-cd61b8aa9b13',
   };
   const healthy = new Map<string, unknown>([
-    ['bondBy', { instrument }],
+    ['bondBy', { instrument: { ...instrument, currency: 'rub' } }],
     ['findInstrument', { instruments: [instrument] }],
     ['getAssetBy', { asset: { description: 'description' } }],
     ['getAssetFundamentals', { fundamentals: [] }],
     ['getLastPrices', { lastPrices: [] }],
-    ['shareBy', { instrument }],
+    ['shareBy', { instrument: { ...instrument, currency: 'rub' } }],
   ]);
   const failure = Object.assign(new Error('grpc failure'), {
     code,

test/openapi-contract.e2e-spec.ts

@@ -98,7 +98,7 @@ describe('OpenAPI contract (integration)', () => {
       expect.arrayContaining([
         'accountId',
         'period',
-        'totalsByCurrency',
+        'total',
         'calculatedAt',
         'bucketGranularity',
         'buckets',

test/portfolio-structure.e2e-spec.ts

@@ -111,25 +111,20 @@ describe('Portfolio structure HTTP contract', () => {
       expect((response.body as { data: unknown }).data).toMatchObject({
         structure: {
           unvaluedCategories: [],
-          currencies: [
+          totalValue: id === 'all' ? '200' : '100',
+          hasNegativeValues: false,
+          categories: [
             {
-              currency: 'RUB',
+              type: 'STOCK',
-              totalValue: id === 'all' ? '200' : '100',
+              value: id === 'all' ? '120' : '60',
-              hasNegativeValues: false,
+              sharePercent: '60',
-              categories: [
+            },
-                {
+            { type: 'BOND', value: '0', sharePercent: '0' },
-                  type: 'STOCK',
+            { type: 'OTHER', value: '0', sharePercent: '0' },
-                  value: id === 'all' ? '120' : '60',
+            {
-                  sharePercent: '60',
+              type: 'CASH',
-                },
+              value: id === 'all' ? '80' : '40',
-                { type: 'BOND', value: '0', sharePercent: '0' },
+              sharePercent: '40',
-                { type: 'OTHER', value: '0', sharePercent: '0' },
-                {
-                  type: 'CASH',
-                  value: id === 'all' ? '80' : '40',
-                  sharePercent: '40',
-                },
-              ],
             },
           ],
         },
@@ -149,15 +144,11 @@ describe('Portfolio structure HTTP contract', () => {
     expect((response.body as { data: unknown }).data).toMatchObject({
       structure: {
         unvaluedCategories: [{ type: 'BOND', count: 1 }],
-        currencies: [
+        categories: [
-          {
+          { sharePercent: null },
-            categories: [
+          { sharePercent: null },
-              { sharePercent: null },
+          { sharePercent: null },
-              { sharePercent: null },
+          { value: '40', sharePercent: null },
-              { sharePercent: null },
-              { value: '40', sharePercent: null },
-            ],
-          },
         ],
       },
     });
@@ -174,17 +165,13 @@ describe('Portfolio structure HTTP contract', () => {
       .expect(200);
     expect((response.body as { data: unknown }).data).toMatchObject({
       structure: {
-        currencies: [
+        hasNegativeValues: true,
-          {
+        totalValue: '150',
-            hasNegativeValues: true,
+        categories: [
-            totalValue: '150',
+          { value: '120', sharePercent: null },
-            categories: [
+          { sharePercent: null },
-              { value: '120', sharePercent: null },
+          { sharePercent: null },
-              { sharePercent: null },
+          { value: '30', sharePercent: null },
-              { sharePercent: null },
-              { value: '30', sharePercent: null },
-            ],
-          },
         ],
       },
     });

test/tbank-income-local.e2e-spec.ts

@@ -103,7 +103,6 @@ describe('local income completeness and exact money (SQLite)', () => {
       for (const [id, units, nano, currency, type] of [
         ['same', '10', 1, 'rub', 'OPERATION_TYPE_COUPON'],
         ['negative', '-2', -500000000, 'rub', 'OPERATION_TYPE_DIVIDEND'],
-        ['usd', '3', 0, 'usd', 'OPERATION_TYPE_COUPON'],
       ] as const) {
         await prisma.tbankOperation.create({
           data: {
@@ -130,11 +129,8 @@ describe('local income completeness and exact money (SQLite)', () => {
       assert(result.data);
       expect(result.meta.availability).toBe('available');
       expect(result.meta.completeness).toBe('complete');
-      expect(result.data.totalsByCurrency.map((row) => row.total)).toEqual([
+      expect(result.data.total.total).toEqual({ currency: 'RUB', value: '15.000000002' });
-        { currency: 'RUB', value: '15.000000002' },
+      expect(result.data.entries).toHaveLength(4);
-        { currency: 'USD', value: '6' },
-      ]);
-      expect(result.data.entries).toHaveLength(6);
       expect(
         result.data.entries
           .filter((row) => row.id === 'same')
@@ -185,7 +181,7 @@ describe('local income completeness and exact money (SQLite)', () => {
     assert(after.data);
     expect(after.data.entries.find((entry) => entry.account?.id === 'a' && entry.id === 'same')?.logoName).toBe('bond.png');
     expect(after.data.entries.find((entry) => entry.account?.id === 'b' && entry.id === 'same')?.logoName).toBeNull();
-    expect(after.data.totalsByCurrency).toEqual(base.totalsByCurrency);
+    expect(after.data.total).toEqual(base.total);
     expect(after.data.calculatedAt).toBe(base.calculatedAt);
     expect(upstream.getOperationsByCursor).not.toHaveBeenCalled();
   });
@@ -205,8 +201,8 @@ describe('local income completeness and exact money (SQLite)', () => {
       new Date('2025-03-31T21:00:00Z'),
     );
     expect(
-      (await read('a', 'from=2025-03-01&to=2025-03-31')).data?.totalsByCurrency,
+      (await read('a', 'from=2025-03-01&to=2025-03-31')).data?.total.total,
-    ).toEqual([]);
+    ).toEqual({ currency: 'RUB', value: '0' });
     expect(upstream.getOperationsByCursor).toHaveBeenCalledWith(
       'synthetic', expect.objectContaining({ accountId: 'b' }),
     );
@@ -225,11 +221,8 @@ describe('local income completeness and exact money (SQLite)', () => {
     });
     const result = await read();
     assert(result.data);
-    expect(result.data.entries).toHaveLength(6);
+    expect(result.data.entries).toHaveLength(4);
-    expect(
+    expect(result.data.total.total).toEqual({ currency: 'RUB', value: '25.000000002' });
-      result.data.totalsByCurrency.find(({ currency }) => currency === 'RUB')
-        ?.total,
-    ).toEqual({ currency: 'RUB', value: '25.000000002' });
   });
   it('preserves the complete financial result and timestamp through failed atomic reconciliation', async () => {
     const before = await read();

test/tbank-ledger-local.e2e-spec.ts

@@ -268,7 +268,7 @@ describe('persistent ledger HTTP and cursor (SQLite)', () => {
     expect(
       income.data?.entries.map(({ id, occurredAt }) => ({ id, occurredAt })),
     ).toEqual(expected);
-    expect(income.data?.totalsByCurrency[0].total).toEqual({
+    expect(income.data?.total.total).toEqual({
       currency: 'RUB',
       value: '2.000000002',
     });

test/tbank-local-reads.e2e-spec.ts

@@ -218,32 +218,27 @@ describe('local accounts and portfolio HTTP (SQLite)', () => {
       bondPositionCount: 0,
       fundPositionCount: 0,
       totalPositionCount: 1,
-      totalsByCurrency: [{ currency: 'RUB', value: '21.100000002' }],
+      totals: { currency: 'RUB', value: '21.100000002' },
-      cashBalances: [{ currency: 'RUB', value: '1.1' }],
+      cash: { currency: 'RUB', value: '1.1' },
       structure: {
-        currencies: [{
+        totalValue: '21.100000002',
-          currency: 'RUB',
+        hasNegativeValues: false,
-          totalValue: '21.100000002',
+        categories: [
-          hasNegativeValues: false,
+          { type: 'STOCK', value: '20.000000002', sharePercent: '94.78673' },
-          categories: [
+          { type: 'BOND', value: '0', sharePercent: '0' },
-            { type: 'STOCK', value: '20.000000002', sharePercent: '94.78673' },
+          { type: 'OTHER', value: '0', sharePercent: '0' },
-            { type: 'BOND', value: '0', sharePercent: '0' },
+          { type: 'CASH', value: '1.1', sharePercent: '5.21327' },
-            { type: 'OTHER', value: '0', sharePercent: '0' },
+        ],
-            { type: 'CASH', value: '1.1', sharePercent: '5.21327' },
-          ],
-        }],
         unvaluedCategories: [],
       },
-      unrealizedReturnByCurrency: [
+      unrealizedReturn: { absolute: '0', costBasis: '0', percent: null, partial: true },
-        { currency: 'RUB', absolute: '0', costBasis: '0', percent: null, partial: true },
-      ],
     });
     const portfolio = await get('brokerage-accounts/account/portfolio').expect(
       200,
     );
     expect(
-      (portfolio.body as PortfolioResourceDto).data?.totalsByCurrency,
+      (portfolio.body as PortfolioResourceDto).data?.totals,
-    ).toEqual([{ currency: 'RUB', value: '21.100000002' }]);
+    ).toEqual({ currency: 'RUB', value: '21.100000002' });
     expect(upstream.getOpenAccounts).not.toHaveBeenCalled();
     expect(upstream.getPortfolio).toHaveBeenCalledTimes(1);
     expect(upstream.getInstrumentByFigi).not.toHaveBeenCalled();
@@ -315,7 +310,7 @@ describe('local accounts and portfolio HTTP (SQLite)', () => {
       logoName: 'enriched.png',
       quantity: '2',
     });
-    expect(after.data?.totalsByCurrency).toEqual(before.data?.totalsByCurrency);
+    expect(after.data?.totals).toEqual(before.data?.totals);
     expect(after.data?.lastSuccessfulAt).toBe(before.data?.lastSuccessfulAt);
     expect(after.meta.dataRevision).not.toBe(before.meta.dataRevision);
     expect(upstream.getPortfolio).toHaveBeenCalledTimes(1);
@@ -513,12 +508,9 @@ describe('local accounts and portfolio HTTP (SQLite)', () => {
     const summaries = (await get('brokerage-accounts').expect(200))
       .body as BrokerageAccountsResourceDto;
     expect(summaries.data?.[0].portfolioSummary).toMatchObject({
-      totalsByCurrency: [{ currency: 'RUB', value: '21.1' }],
+      totals: { currency: 'RUB', value: '21.1' },
-      cashBalances: [{ currency: 'RUB', value: '1.1' }],
+      cash: { currency: 'RUB', value: '1.1' },
-      structure: { currencies: [{ currency: 'RUB' }] },
+      unrealizedReturn: { absolute: '0', costBasis: '0', percent: null, partial: true },
-      unrealizedReturnByCurrency: [
-        { currency: 'RUB', absolute: '0', costBasis: '0', percent: null, partial: true },
-      ],
       stockPositionCount: 1,
       bondPositionCount: 0,
       fundPositionCount: 0,

test/tbank-portfolio-publish.e2e-spec.ts

@@ -16,18 +16,15 @@ describe('portfolio publication (SQLite)', () => {
   const snapshot = {
     lastSuccessfulAt: '2026-01-01T00:00:00.000Z',
     isStale: false,
-    totalsByCurrency: [],
+    totals: { currency: 'RUB', value: '0' },
     positions: [],
-    cashBalances: [],
+    cash: { currency: 'RUB', value: '0' },
-    structure: { currencies: [], unvaluedCategories: [] },
+    structure: { totalValue: '0', hasNegativeValues: false, categories: [], unvaluedCategories: [] },
   } satisfies PortfolioDto;
   const accountId = 'account';
   const valuedSnapshot = {
     ...snapshot,
-    totalsByCurrency: [
+    totals: { currency: 'RUB', value: '200' },
-      { currency: 'RUB', value: '200' },
-      { currency: 'USD', value: '10' },
-    ],
   } satisfies PortfolioDto;
   const createRunningAttempt = () =>
     prisma.tbankSyncWork.create({
@@ -95,7 +92,7 @@ describe('portfolio publication (SQLite)', () => {
     expect(await prisma.tbankPortfolio.count()).toBe(1);
   });
 
-  it('rolls back the snapshot, first value point and claim when the second point fails', async () => {
+  it('rolls back the snapshot, value point and claim when the point write fails', async () => {
     const previousFetchedAt = new Date('2025-12-31T00:00:00.000Z');
     const previousCapturedAt = new Date('2025-12-31T01:00:00.000Z');
     await prisma.tbankPortfolio.create({
@@ -114,7 +111,6 @@ describe('portfolio publication (SQLite)', () => {
         points: {
           create: {
             attemptId: 'previous-attempt',
-            currency: 'RUB',
             value: '100',
             capturedAt: previousCapturedAt,
           },
@@ -123,11 +119,9 @@ describe('portfolio publication (SQLite)', () => {
     });
     await createRunningAttempt();
     interceptTransaction((tx) => {
-      const upsert = tx.tbankPortfolioValuePoint.upsert.bind(tx.tbankPortfolioValuePoint);
       jest
         .spyOn(tx.tbankPortfolioValuePoint, 'upsert')
-        .mockImplementationOnce((args) => upsert(args))
+        .mockRejectedValueOnce(new Error('injected point failure'));
-        .mockRejectedValueOnce(new Error('injected second point failure'));
     });
 
     await expect(
@@ -136,7 +130,7 @@ describe('portfolio publication (SQLite)', () => {
         accountId,
         valuedSnapshot,
       ),
-    ).rejects.toThrow('injected second point failure');
+    ).rejects.toThrow('injected point failure');
 
     expect(
       await prisma.tbankPortfolio.findUnique({

test/tbank-read-baseline.e2e-spec.ts

@@ -114,7 +114,7 @@ describe('T-Bank persisted read budget', () => {
           (item) =>
             item.instrumentKind === 'INSTRUMENT_TYPE_SHARE' &&
             item.ticker.includes(query),
-        ),
+        ).map((item) => ({ uid: item.uid, ticker: item.ticker, name: item.name, isin: item.isin, instrumentKind: item.instrumentKind, classCode: item.classCode, apiTradeAvailableFlag: item.apiTradeAvailableFlag })),
       ),
     findBonds: (_token: string, query: string) =>
       counted(
@@ -123,7 +123,7 @@ describe('T-Bank persisted read budget', () => {
           (item) =>
             item.instrumentKind === 'INSTRUMENT_TYPE_BOND' &&
             item.ticker.includes(query),
-        ),
+        ).map((item) => ({ uid: item.uid, ticker: item.ticker, name: item.name, isin: item.isin, instrumentKind: item.instrumentKind, classCode: item.classCode, apiTradeAvailableFlag: item.apiTradeAvailableFlag })),
       ),
     getShare: (_token: string, uid: string) =>
       counted(
@@ -279,9 +279,9 @@ describe('T-Bank persisted read budget', () => {
               currentPrice: { currency: 'rub', units: '1000' },
               averagePositionPrice: { currency: 'rub', units: '900' },
             }],
-            totalsByCurrency: [{ currency: 'RUB', value: '1100' }],
+            totals: { currency: 'RUB', value: '1100' },
-            cashBalances: [{ currency: 'RUB', value: '100' }],
+            cash: { currency: 'RUB', value: '100' },
-            structure: { currencies: [], unvaluedCategories: [] },
+            structure: { totalValue: '1100', hasNegativeValues: false, categories: [], unvaluedCategories: [] },
           },
           fetchedAt: now,
         },

test/tbank-value-history.e2e-spec.ts

@@ -80,7 +80,7 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
       ],
     });
     upstream.getPositions.mockResolvedValue({
-      money: [{ units: '5', currency: 'usd' }],
+      money: [{ units: '5', currency: 'rub' }],
     });
   });
 
@@ -123,7 +123,7 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
   }
 
   describe('1.1 Point persistence', () => {
-    it('writes points for fully valued snapshot with two currencies', async () => {
+    it('writes a single RUB point for a fully valued snapshot', async () => {
       await createUser('owner');
       await putConnection('owner', 'token-a').expect(200);
       await publishPortfolio('owner', 'a');
@@ -133,12 +133,10 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
         include: { points: true },
       });
       expect(history?.deletedAt).toBeNull();
-      expect(history?.points).toHaveLength(2);
+      expect(history?.points).toHaveLength(1);
 
-      const rubPoint = history?.points.find((p) => p.currency === 'RUB');
+      const rubPoint = history?.points[0];
-      const usdPoint = history?.points.find((p) => p.currency === 'USD');
+      expect(rubPoint?.value).toBe('26');
-      expect(rubPoint?.value).toBe('21');
-      expect(usdPoint?.value).toBe('5');
 
       const snapshot = await prisma.tbankPortfolio.findUniqueOrThrow({
         where: {
@@ -201,7 +199,7 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
       expect(points).toHaveLength(0);
     });
 
-    it('writes no points for empty account without currency', async () => {
+    it('writes a zero point for an empty fully valued account', async () => {
       upstream.getPortfolio.mockResolvedValue({ positions: [] });
       upstream.getPositions.mockResolvedValue({ money: [] });
 
@@ -212,7 +210,8 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
       const points = await prisma.tbankPortfolioValuePoint.findMany({
         where: { userId: 'owner', accountId: 'a' },
       });
-      expect(points).toHaveLength(0);
+      expect(points).toHaveLength(1);
+      expect(points[0].value).toBe('0');
     });
 
     it('deduplicates repeated publication of same attempt', async () => {
@@ -258,7 +257,7 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
       const points = await prisma.tbankPortfolioValuePoint.findMany({
         where: { userId: 'owner', accountId: 'a' },
       });
-      expect(points).toHaveLength(2);
+      expect(points).toHaveLength(1);
     });
 
     it('late attempt after token replacement adds no points', async () => {
@@ -282,10 +281,7 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
       const published = {
         lastSuccessfulAt: new Date().toISOString(),
         isStale: false,
-        totalsByCurrency: [
+        totals: { currency: 'RUB', value: '100' },
-          { currency: 'RUB', value: '100' },
-          { currency: 'USD', value: '50' },
-        ],
         positions: [
           {
             figi: 'stock',
@@ -302,8 +298,8 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
             issuer: null,
           },
         ],
-        cashBalances: [{ currency: 'USD', value: '50' }],
+        cash: { currency: 'RUB', value: '0' },
-        structure: { currencies: [], unvaluedCategories: [] },
+        structure: { totalValue: '100', hasNegativeValues: false, categories: [], unvaluedCategories: [] },
       };
 
       const result = await app.get(PortfolioService)['repository'].publish(oldWork, 'a', published);
@@ -323,7 +319,7 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
       const pointsBefore = await prisma.tbankPortfolioValuePoint.findMany({
         where: { userId: 'owner', accountId: 'a' },
       });
-      expect(pointsBefore).toHaveLength(2);
+      expect(pointsBefore).toHaveLength(1);
 
       upstream.getPortfolio.mockRejectedValue(new Error('Upstream failed'));
       await publishPortfolio('owner', 'a');
@@ -331,7 +327,7 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
       const pointsAfter = await prisma.tbankPortfolioValuePoint.findMany({
         where: { userId: 'owner', accountId: 'a' },
       });
-      expect(pointsAfter).toHaveLength(2);
+      expect(pointsAfter).toHaveLength(1);
       expect(pointsAfter).toEqual(pointsBefore);
     });
   });
@@ -345,7 +341,7 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
       const oldPoints = await prisma.tbankPortfolioValuePoint.findMany({
         where: { userId: 'owner', accountId: 'a' },
       });
-      expect(oldPoints).toHaveLength(2);
+      expect(oldPoints).toHaveLength(1);
 
       upstream.validateToken.mockResolvedValue([accounts[0]]);
       await putConnection('owner', 'token-b').expect(200);
@@ -361,8 +357,8 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
         where: { userId: 'owner', accountId: 'a' },
         orderBy: { createdAt: 'asc' },
       });
-      expect(newPoints.length).toBeGreaterThan(2);
+      expect(newPoints.length).toBeGreaterThan(1);
-      expect(newPoints.slice(0, 2)).toEqual(oldPoints);
+      expect(newPoints.slice(0, 1)).toEqual(oldPoints);
     });
 
     it('hides history when account disappears from membership', async () => {
@@ -392,7 +388,7 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
       const pointsB = await prisma.tbankPortfolioValuePoint.findMany({
         where: { userId: 'owner', accountId: 'b' },
       });
-      expect(pointsB).toHaveLength(2);
+      expect(pointsB).toHaveLength(1);
     });
 
     it('leaves visibility unchanged on membership fetch error', async () => {
@@ -424,7 +420,7 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
       const points = await prisma.tbankPortfolioValuePoint.findMany({
         where: { userId: 'owner', accountId: 'a' },
       });
-      expect(points).toHaveLength(2);
+      expect(points).toHaveLength(1);
 
       await request(app.getHttpServer())
         .delete('/api/v1/tbank-connection')
@@ -450,7 +446,7 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
       const pointsAfter = await prisma.tbankPortfolioValuePoint.findMany({
         where: { userId: 'owner', accountId: 'a' },
       });
-      expect(pointsAfter.length).toBeGreaterThan(2);
+      expect(pointsAfter.length).toBeGreaterThan(1);
     });
 
     it('unhides when disappeared account returns in membership', async () => {
@@ -530,7 +526,7 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
       const points = await prisma.tbankPortfolioValuePoint.findMany({
         where: { userId: 'owner', accountId: 'a' },
       });
-      expect(points).toHaveLength(2);
+      expect(points).toHaveLength(1);
     });
   });
 });

test/upcoming-events.e2e-spec.ts

@@ -113,9 +113,9 @@ describe('saved payout calendars and complete forecasts (SQLite HTTP)', () => {
       lastSuccessfulAt: new Date().toISOString(),
       isStale: false,
       positions,
-      totalsByCurrency: [],
+      totals: { currency: 'RUB', value: '0' },
-      cashBalances: [],
+      cash: { currency: 'RUB', value: '0' },
-      structure: { currencies: [], unvaluedCategories: [] },
+      structure: { totalValue: '0', hasNegativeValues: false, categories: [], unvaluedCategories: [] },
     };
     await prisma.tbankPortfolio.upsert({
       where: {
@@ -273,17 +273,14 @@ describe('saved payout calendars and complete forecasts (SQLite HTTP)', () => {
       single.data?.events.find((event) => event.type === 'offer')
         ?.projectedAmount,
     ).toBeNull();
-    expect(single.data?.incomeTotalsByCurrency).toEqual([
+    expect(single.data?.incomeTotal).toEqual({ currency: 'RUB', value: '6' });
-      { currency: 'RUB', value: '6' },
-      { currency: 'USD', value: '20.000000002' },
-    ]);
     const all = (await events('all').expect(200))
       .body as UpcomingEventsResourceDto;
     expect(
       all.data?.events.every((event) => event.account?.id === 'account'),
     ).toBe(true);
-    expect(all.data?.incomeTotalsByCurrency).toEqual(
+    expect(all.data?.incomeTotal).toEqual(
-      single.data?.incomeTotalsByCurrency,
+      single.data?.incomeTotal,
     );
     expect(moex.bondEvents).toHaveBeenCalledWith('BOND');
     expect(upstream.getBondCoupons).not.toHaveBeenCalled();
@@ -334,7 +331,7 @@ describe('saved payout calendars and complete forecasts (SQLite HTTP)', () => {
     expect(newRange.data).toEqual({
       ...saved.data,
       events: [],
-      incomeTotalsByCurrency: [],
+      incomeTotal: { currency: 'RUB', value: '0' },
     });
     expect(newRange.data?.window).toEqual(window);
     await prisma.tbankConnection.update({
@@ -372,8 +369,8 @@ describe('saved payout calendars and complete forecasts (SQLite HTTP)', () => {
     }
     expect(
       ((await events().expect(200)).body as UpcomingEventsResourceDto).data
-        ?.incomeTotalsByCurrency,
+        ?.incomeTotal,
-    ).toEqual([{ currency: 'USD', value: '90.000000009' }]);
+    ).toEqual({ currency: 'RUB', value: '0' });
   });
 
   it('serves instrument payouts from shared calendars with private exact holdings and retains successful source timestamps on failure', async () => {
@@ -539,9 +536,7 @@ describe('saved payout calendars and complete forecasts (SQLite HTTP)', () => {
     await settled();
     const result = (await events().expect(200))
       .body as UpcomingEventsResourceDto;
-    expect(result.data?.incomeTotalsByCurrency).toEqual([
+    expect(result.data?.incomeTotal).toEqual({ currency: 'RUB', value: '6' });
-      { currency: 'RUB', value: '6' },
-    ]);
     expect(moex.bondEvents).toHaveBeenCalledWith('BOND');
   });
 
@@ -574,9 +569,7 @@ describe('saved payout calendars and complete forecasts (SQLite HTTP)', () => {
         await settled();
         const before = (await events().expect(200))
           .body as UpcomingEventsResourceDto;
-        expect(before.data?.incomeTotalsByCurrency).toEqual([
+        expect(before.data?.incomeTotal).toEqual({ currency: 'RUB', value: '6' });
-          { currency: 'RUB', value: '6' },
-        ]);
         const calendar = await prisma.tbankInstrumentSource.findFirstOrThrow({
           where: { kind: 'bond-events' },
         });
@@ -675,7 +668,7 @@ describe('saved payout calendars and complete forecasts (SQLite HTTP)', () => {
     const w1 = windowOf(day1, '2099-03-04');
     const dividend = (date: string) => ({
       recordDate: time(date),
-      dividendNet: { units: '10', nano: 1, currency: 'usd' },
+      dividendNet: { units: '10', nano: 1, currency: 'rub' },
     });
     const defaultEvents = async () =>
       (await get('brokerage-accounts/account/events').expect(200))
@@ -705,9 +698,7 @@ describe('saved payout calendars and complete forecasts (SQLite HTTP)', () => {
       await refresh({});
       const first = await defaultEvents();
       expect(first.data?.window).toEqual(w0);
-      expect(first.data?.incomeTotalsByCurrency).toEqual([
+      expect(first.data?.incomeTotal).toEqual({ currency: 'RUB', value: '20.000000002' });
-        { currency: 'USD', value: '20.000000002' },
-      ]);
 
       jest.setSystemTime(new Date(`${day1}T12:00:00Z`));
       await portfolio([position(shareUid, '5')]);
@@ -720,9 +711,7 @@ describe('saved payout calendars and complete forecasts (SQLite HTTP)', () => {
         '2099-02-05',
         '2099-03-04',
       ]);
-      expect(second.data?.incomeTotalsByCurrency).toEqual([
+      expect(second.data?.incomeTotal).toEqual({ currency: 'RUB', value: '100.00000001' });
-        { currency: 'USD', value: '100.00000001' },
-      ]);
       const stale = (await events('account', 'owner', w0).expect(200))
         .body as UpcomingEventsResourceDto;
       expect(stale.data?.calculatedAt).toBe(second.data?.calculatedAt);
@@ -736,7 +725,7 @@ describe('saved payout calendars and complete forecasts (SQLite HTTP)', () => {
       expect(disjoint.data).toEqual({
         ...second.data,
         events: [],
-        incomeTotalsByCurrency: [],
+        incomeTotal: { currency: 'RUB', value: '0' },
       });
       expect(await prisma.tbankForecast.count()).toBe(2);
     });
@@ -779,7 +768,7 @@ describe('saved payout calendars and complete forecasts (SQLite HTTP)', () => {
     const dividend = (units: string, dividendType = 'Regular') => ({
       recordDate: time(date),
       dividendType,
-      dividendNet: { units, currency: 'usd' },
+      dividendNet: { units, currency: 'rub' },
     });
     // One hourly walk: the scheduler stamps it once and passes it to every account.
     const startWalk = async () => {
@@ -803,16 +792,12 @@ describe('saved payout calendars and complete forecasts (SQLite HTTP)', () => {
     it('picks up a changed and then a cancelled payout on the next pass of the same window', async () => {
       upstream.getDividends.mockResolvedValue([dividend('10')]);
       await pass(await startWalk());
-      expect((await latest()).data?.incomeTotalsByCurrency).toEqual([
+      expect((await latest()).data?.incomeTotal).toEqual({ currency: 'RUB', value: '20' });
-        { currency: 'USD', value: '20' },
-      ]);
       const first = await dividendRow();
 
       upstream.getDividends.mockResolvedValue([dividend('30')]);
       await pass(await startWalk());
-      expect((await latest()).data?.incomeTotalsByCurrency).toEqual([
+      expect((await latest()).data?.incomeTotal).toEqual({ currency: 'RUB', value: '60' });
-        { currency: 'USD', value: '60' },
-      ]);
       expect((await dividendRow()).dataRevision).toBe(first.dataRevision + 1);
 
       upstream.getDividends.mockResolvedValue([dividend('30', 'Cancelled')]);