fix(install): блокировать переход с формы совета без заполненных данных

Кнопка «Продолжить» проверяла только число слотов совета, а не email и
обязательные поля ФЛ. Добавлена валидация на фронте и в install.interactor,
чтобы частично заполненный состав не уходил на цепь.

Co-authored-by: Cursor <cursoragent@cursor.com>

.github/workflows/release.yaml

@@ -1,38 +1,54 @@
 name: Release
 
-# Единый релизный workflow по push'у тэга `v*`.
+# Релизный workflow по push'у в testnet/main (FF-промоушн-модель, см.
+# scripts/RELEASE.md).
 #
 # Порядок (через jobs.needs):
 #   1) release             — контракты + контейнеры + webhook деплоя (атомарно)
-#   2) publish-packages    — npm publish через lerna (если не -alpha)
+#   2) publish-packages    — npm publish через lerna (только ветка main)
 #   3) trigger-coopenomics — workflow_dispatch сборки сайта C9S/coopenomics на
-#                            Gitea (если не -alpha + ветка main); он сам тянет
-#                            mono и пересобирает доки.
+#                            Gitea (только ветка main); он сам тянет mono и
+#                            пересобирает доки.
 #
 # publish-docs (gh-pages на github.com) удалён 2026-05-25 — после переезда на
 # Gitea Pages-публикация невалидна; доки деплоятся через C9S/coopenomics.
 #
 # Зачем последовательно: пакеты/доки/внешний триггер не должны уезжать,
-# если релиз контрактов или контейнеров провалился. Раньше четыре workflow'а
-# стартовали параллельно по одному тэгу — отсюда гонка из инцидента 2026-05-13
-# с ledger2 walletop sweep'ом (см. историю release.yaml до объединения).
+# если релиз контрактов или контейнеров провалился.
 #
-# Гейт `-alpha` унифицирован: пакеты + доки + триггер docs пропускают только
-# не-alpha тэги. -beta/-rc/-test в проекте не используются (см. CLAUDE.md),
-# поэтому проще иметь один паттерн `!contains(github.ref, '-alpha')`.
-# IS_PROD в release-job остаётся на `(alpha|beta|rc|test)` — он определяет
-# деплой-webhook (testnet vs production) и тэг `:latest` у образов;
-# намеренно строже, чтобы случайный -rc-тэг не уехал на прод.
+# Триггер — push в testnet/main с изменением lerna.json. Версию бампает
+# `lerna version` ОДИН раз на dev (scripts/cut-release.sh); тот же коммит едет
+# вверх по fast-forward (scripts/promote.sh). lerna.json меняется только на
+# релизном бампе, поэтому обычные feature-пуши деплой не триггерят. dev в
+# триггере НЕТ: cut на dev только бампает версию, деплой начинается с testnet
+# (staging) и завершается main (production).
 #
-# Резолв ветки. Тэг семантики окружения не несёт (например `v2026.5.13-alpha-2`
-# может лежать на testnet или dev — определяет именно ветка, на которую сделан
-# merge перед тэгом). Поэтому ищем первое совпадение SHA с remote-ветками
-# main/testnet/dev. branch экспортируется как outputs.branch для downstream jobs.
+# Окружение определяет ВЕТКА (main → production, testnet → staging), а не
+# суффикс версии: единая версия едет во все среды, поэтому source of truth —
+# ветка, на которую сделан промоушн. Версия читается из закоммиченного
+# lerna.json. Гейты npm-publish/доки — `branch == main`.
 
 on:
   push:
-    tags:
-      - 'v*'
+    branches: [testnet, main]
+    paths:
+      - 'lerna.json'
+  # Ручной деплой: выбрать окружение и (опционально) версию/коммит. Нужен для
+  # отката на старую версию, редеплоя без бампа и точечного hotfix в один контур —
+  # всё, что FF-промоушн (scripts/promote.sh, только вперёд) сделать не может.
+  workflow_dispatch:
+    inputs:
+      environment:
+        description: 'Куда деплоить'
+        type: choice
+        options:
+          - testnet
+          - main
+        required: true
+      ref:
+        description: 'Релизный тег/коммит для сборки (пусто = верхушка выбранного окружения)'
+        required: false
+        default: ''
 
 permissions:
   contents: write
@@ -49,23 +65,32 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          # push → собираем пушнутый коммит; ручной запуск → выбранный ref
+          # (пусто = верхушка ветки окружения, на которой запущен workflow).
+          ref: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.ref) || github.sha }}
 
-      - name: Resolve branch, build mode and tags
+      - name: Resolve branch, build mode and version
         id: resolve
         run: |
-          TAG_NAME="${{ github.ref_name }}"
-          SHA="${{ github.sha }}"
-          BRANCH=""
-          for candidate in main testnet dev; do
-            if git branch -r --contains "$SHA" 2>/dev/null | grep -qE "^[[:space:]]*origin/${candidate}$"; then
-              BRANCH="$candidate"
-              break
-            fi
-          done
-          if [ -z "$BRANCH" ]; then
-            echo "::error::Тэг $TAG_NAME ($SHA) не лежит ни на одной из dev/testnet/main"
+          # Окружение: при ручном workflow_dispatch — из inputs.environment;
+          # при push — это ветка push'а (testnet/main). Версия/сборка берутся
+          # из реально вычекнутого дерева, не из ветки-триггера.
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            BRANCH="${{ github.event.inputs.environment }}"
+          else
+            BRANCH="${{ github.ref_name }}"
+          fi
+          SHA="$(git rev-parse HEAD)"
+
+          # Версия — из закоммиченного lerna.json. Её бампит lerna version ОДИН
+          # раз на dev (scripts/cut-release.sh), и тот же коммит едет по FF в
+          # testnet/main. Тэг как триггер больше не используется.
+          RAW_VERSION="$(sed -nE 's/.*"version"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/p' lerna.json | head -1)"
+          if [ -z "$RAW_VERSION" ]; then
+            echo "::error::Не удалось прочитать version из lerna.json"
             exit 1
           fi
+          TAG_NAME="v${RAW_VERSION}"
 
           case "$BRANCH" in
             main)
@@ -83,17 +108,22 @@ jobs:
               CONTRACTS_TAG=dev
               CONTRACTS_EXTRA=
               ;;
+            *)
+              echo "::error::Неподдерживаемая ветка $BRANCH (ожидались testnet/main/dev)"
+              exit 1
+              ;;
           esac
 
-          # IS_PROD определяет webhook деплоя (PRODUCTION vs TESTNET) и тэг :latest.
-          # Сознательно строже гейта publish-* — случайный -rc/-beta тэг не должен
-          # уехать на прод-вебхук, даже если в npm/docs его опубликовали.
-          if [[ "$TAG_NAME" =~ -(alpha|beta|rc|test) ]]; then
-            IS_PROD=false
-            WEBHOOK_URL='${{ vars.TESTNET_WEBHOOK_URL }}'
-          else
+          # Окружение деплоя определяет ВЕТКА: main → production, иначе → testnet.
+          # IS_PROD управляет деплой-webhook (PRODUCTION vs TESTNET) и тэгом :latest
+          # у образов. Раньше критерием был суффикс -alpha у тэга; теперь единая
+          # версия едет во все среды, поэтому источник истины — ветка промоушна.
+          if [ "$BRANCH" = "main" ]; then
             IS_PROD=true
             WEBHOOK_URL='${{ vars.PRODUCTION_WEBHOOK_URL }}'
+          else
+            IS_PROD=false
+            WEBHOOK_URL='${{ vars.TESTNET_WEBHOOK_URL }}'
           fi
 
           {
@@ -334,14 +364,16 @@ jobs:
 
   # ============================================================================
   # publish-packages — npm publish (бывший publish-packages.yaml).
-  # Гейт: не-alpha. Не зависит от ветки.
+  # Гейт: ветка main. Версия для publish — из закоммиченного package.json
+  # (lerna publish from-package); её бампит cut-release.sh на dev, тот же коммит
+  # доезжает до main по FF.
   # Жёстко прибиваем версию pnpm, которой сгенерён lockfile (lockfileVersion 9.0
   # = pnpm 9/10). Иначе action-setup может подтянуть другую версию и переписать
   # pnpm-lock.yaml → Lerna EUNCOMMIT.
   # ============================================================================
   publish-packages:
     needs: release
-    if: ${{ !contains(github.ref, '-alpha') }}
+    if: ${{ needs.release.outputs.branch == 'main' }}
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -364,7 +396,7 @@ jobs:
 
   # ============================================================================
   # trigger-coopenomics-docs — пересборка сайта C9S/coopenomics.
-  # Гейт: не-alpha + ветка main.
+  # Гейт: ветка main.
   #
   # coopenomics переехал на Gitea (C9S/coopenomics); его publish-docs.yaml
   # клонирует mono и пересобирает сайт. Gitea НЕ имеет API для
@@ -376,7 +408,7 @@ jobs:
   # ============================================================================
   trigger-coopenomics-docs:
     needs: release
-    if: ${{ !contains(github.ref, '-alpha') && needs.release.outputs.branch == 'main' }}
+    if: ${{ needs.release.outputs.branch == 'main' }}
     runs-on: ubuntu-latest
     steps:
       - name: Trigger coopenomics website rebuild (Gitea workflow_dispatch)
@@ -392,11 +424,11 @@ jobs:
   # webhook DOCS_DEPLOY_WEBHOOK_URL. Отдельная от coopenomics публикация —
   # обе доки уезжают синхронно по релизу. Извлечён из бывшего publish-docs:
   # gh-pages на github.com выпилен как мёртвый, остался реальный deploy-webhook
-  # (приёмник деплоит доки на своей стороне). Гейт: не-alpha + ветка main.
+  # (приёмник деплоит доки на своей стороне). Гейт: ветка main.
   # ============================================================================
   trigger-mono-docs:
     needs: release
-    if: ${{ !contains(github.ref, '-alpha') && needs.release.outputs.branch == 'main' }}
+    if: ${{ needs.release.outputs.branch == 'main' }}
     runs-on: ubuntu-latest
     steps:
       - name: Trigger docs deployment webhook

CLAUDE.md

@@ -38,6 +38,8 @@ ln -s /home/admin/mono-ai-4/components/controller/.env $WT/components/controller
 
 **Базовая ветка mono-ai-1 — `dev`.** Прямые коммиты в `dev` для мелких фиксов разрешены и не требуют feature-ветки/PR (отменено 2026-05-22 пользователем). Для крупных задач — feature-ветка (`feat/...` или `fix/...`) от dev и PR в dev; merge делает пользователь на GitHub. Push в `main` / `mvp` — по-прежнему только через PR.
 
+**Релиз/деплой — FF-промоушн `dev → testnet → main`** (см. `scripts/RELEASE.md`). Версию бампает `lerna` ОДИН раз на dev (`scripts/cut-release.sh`), тот же коммит едет вверх по fast-forward (`scripts/promote.sh testnet|main`). `testnet`/`main` не несут своих коммитов — только FF-указатели, поэтому merge-конфликтов нет. **В `testnet`/`main` прямых коммитов и повторных бампов версии быть не должно** — это ломает FF. Деплой триггерит push в testnet/main с изменением `lerna.json`; окружение определяет ветка (main → prod). Старые `publish-alpha.sh`/`publish-prod.sh` (merge `-X theirs` + per-branch бамп + back-merge) удалены — они и плодили 20-package.json конфликты.
+
 **Не stash'ить `-u` при unstaged WIP пользователя.** Это создаёт окно для потери при drop/конфликте. Если нужно временно убрать unstaged — `git stash push -- <конкретные-paths>` либо коммит-в-feature, и только свои файлы. Кейс 2026-05-18: после `git stash -u`+`drop` при конфликте потерял WIP пользователя (infra.ts/config.ts/quasar.config.cjs и др.).
 
 ### Story-by-story для проекта «Стол заказов» (mono-ai-4 на marketplace2)

components/blago-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coopenomics/blago-cli",
-  "version": "2026.6.8-2",
+  "version": "2026.6.24",
   "description": "CLI синхронизации артефактов Благорост с бэкендом через @coopenomics/sdk",
   "type": "module",
   "private": true,

components/boot/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coopenomics/boot",
   "type": "module",
-  "version": "2026.6.8-2",
+  "version": "2026.6.24",
   "private": true,
   "packageManager": "pnpm@9.0.6",
   "description": "CLI-утилита инициализации блокчейна и кооператива",
@@ -26,6 +26,7 @@
     "boot:remote": "esno src/index.ts boot:remote",
     "reboot:clean": "cd components/boot/scripts && bash clean_reboot.sh",
     "reboot:extra": "cd components/boot/scripts && bash extra_reboot.sh",
+    "reboot:blago": "cd components/boot/scripts && bash blago_reboot.sh",
     "create-coop": "esno src/index.ts create-coop",
     "clear": "./scripts/clear.sh",
     "start": "./scripts/restart.sh",

components/boot/scripts/blago_reboot.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# Полный перезапуск dev-среды для теста Благороста одной командой:
+#   1) extra_reboot.sh — чистая цепь + кооператив + совет 5 человек +
+#      dev-shortcut онбординга capital (extensions.capital: все *_done=true);
+#   2) ожидание готовности controller (GraphQL отвечает);
+#   3) seed-capital до фазы $SEED_UP_TO (default 04-contributor): программы
+#      УХД/Благорост + setconfig, проекты, регистрация ant как участника.
+#
+# Глубину сида можно менять: SEED_UP_TO=08-investments pnpm run reboot:blago
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT_DIR="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+if [ -f "$ROOT_DIR/.env" ]; then
+  set -a
+  # shellcheck disable=SC1091
+  source "$ROOT_DIR/.env"
+  set +a
+fi
+
+bash "$SCRIPT_DIR/extra_reboot.sh"
+
+# Per-instance адрес controller'а — из корневого .env (API_URL); coopback после
+# force-recreate поднимается десятки секунд, seed-фазы без него падают.
+GRAPHQL_URL="${API_URL:-http://127.0.0.1:2998/v1/graphql}"
+echo "Ждём готовности controller ($GRAPHQL_URL)..."
+until curl -s --max-time 3 -o /dev/null -X POST -H 'Content-Type: application/json' \
+  --data '{"query":"{__typename}"}' "$GRAPHQL_URL"; do
+  sleep 3
+done
+echo "Controller готов."
+
+UP_TO="${SEED_UP_TO:-04-contributor}"
+echo "Сидируем capital до фазы $UP_TO..."
+cd "$SCRIPT_DIR/.."
+CONTROLLER_GRAPHQL_URL="$GRAPHQL_URL" pnpm exec esno src/scripts/seed-capital/index.ts --up-to="$UP_TO"
+
+echo "Готово: среда Благорост поднята (seed до $UP_TO)."

components/boot/src/configs/contracts.ts

@@ -128,4 +128,9 @@ export default [
     path: path.join(userBase, 'apps'),
     target: 'apps',
   },
+  {
+    name: 'expense',
+    path: path.join(userBase, 'expense'),
+    target: 'expense',
+  },
 ]

components/boot/src/configs/index.ts

@@ -154,6 +154,10 @@ export default {
       name: 'apps',
       code_permissions_to: ['apps'],
     },
+    {
+      name: 'expense',
+      code_permissions_to: ['expense'],
+    },
     // {
     //   name: provider_chairman,
     // },

components/boot/src/configs/protocol_features/BUILTIN-SAVANNA.json

@@ -0,0 +1,33 @@
+{
+  "protocol_feature_type": "builtin",
+  "dependencies": [
+    "09e86cb0accf8d81c9e85d34bea4b925ae936626d00c984e4691186891f5bc16",
+    "1a99a59d87e06e09ec5b028a9cbb7749b4a5ad8819004365d02dc4379a8b7241",
+    "2652f5f96006294109b3dd0bbde63693f55324af452b799ee137a81a905eed25",
+    "299dcb6af692324b899b39f16d5a530a33062804e41f09dc97e9f156b4476707",
+    "35c2186cc36f7bb4aeaf4487b36e57039ccf45a9136aa856a5d569ecca55ef2b",
+    "4a90c00d55454dc5b059055ca213579c6ea856967712a56017487886a4d4cc0f",
+    "4e7bf348da00a945489b2a681749eb56f5de00b900014e137ddae39f48f69d67",
+    "4fca8bd82bbd181e714e283f83e1b45d95ca5af40fb89ad3977b653c448f78c2",
+    "5443fcf88330c586bc0e5f3dee10e7f63c76c00249c87fe4fbf7f38c082006b4",
+    "63320dd4a58212e4d32d1f58926b73ca33a247326c2a5e9fd39268d2384e011a",
+    "68dcaa34c0517d19666e6b33add67351d8c5f69e999ca1e37931bc410a297428",
+    "6bcb40a24e49c26d0a60513b6aeb8551d264e4717f306b81a37a5afb3b47cedc",
+    "8ba52fe7a3956c5cd3a656a3174b931d3bb2abb45578befc59f283ecd816a405",
+    "ad9e3d8f650687709fd68f4b90b41f7d825a365b02c23a636cef88ac2ac00c43",
+    "bcd2a26394b36614fd4894241d3c451ab0f6fd110958c3423073621a70826e99",
+    "c3a6138c5061cf291310887c0b5c71fcaffeab90d5deb50d3b9e687cead45071",
+    "d528b9f6e9693f45ed277af93474fd473ce7d831dae2180cca35d907bd10cb40",
+    "e0fb64b1085cc5538970158d05a009c24e276fb94e1a0bf6a528b48fbc4ff526",
+    "ef43112c6543b88db2283a2e077278c315ae2c84719a8b25f25cc88565fbea99",
+    "f0af56d2c5a48d60a4a5b5c903edfb7db3a736a94ed589d0b797df33ff9d3e1d",
+    "fce57d2331667353a0eac6b4209b67b843a7262a848af0a49a6e2fa9f6584eb4"
+  ],
+  "description_digest": "01a8bebb4922c38293a8909668f7d00ba4a21a455c69719ad7dcc33ea1e631c0",
+  "subjective_restrictions": {
+    "earliest_allowed_activation_time": "1970-01-01T00:00:00.000",
+    "preactivation_required": true,
+    "enabled": true
+  },
+  "builtin_feature_codename": "SAVANNA"
+}

components/cleos/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coopenomics/cleos",
-  "version": "2026.6.8-2",
+  "version": "2026.6.24",
   "private": true,
   "description": "Обёртка над кошельком cleos для EOSIO блокчейна",
   "scripts": {

components/contracts/CMakeLists.txt

@@ -58,6 +58,7 @@ add_contract_build(registrator)
 add_contract_build(gateway)
 add_contract_build(marketplace)
 add_contract_build(apps)
+add_contract_build(expense)
 add_contract_build(system)
 
 # Опции для тестов

components/contracts/cpp/capital/app/expense_managment/program_expenses/createpgexp.cpp

@@ -0,0 +1,65 @@
+/**
+ * @brief Инициировать программный расход через шасси expense.
+ *
+ * capital — только инициатор. Резервирует средства в @c program_expense_pool,
+ * создаёт скелет записи progexpense (status=CREATED, как маркер pending), затем
+ * шлёт inline action `expense::createexp(...)` с callback handler `{capital, onpgexpdone}`.
+ * Шасси expense обслуживает весь дальнейший flow (авторизация совета, выдача аванса,
+ * отчёт, закрытие либо отклонение) и на терминальном переходе шлёт inline `onpgexpdone`.
+ *
+ * @param coopname        Кооператив
+ * @param expense_hash    Хеш расхода (= proposal_hash в шасси)
+ * @param creator         Инициатор расхода
+ * @param items           Позиции СЗ (см. ExpenseDomain::item); механика оплаты per-item
+ * @param description     Описание для отчётности
+ * @param statement       Документ-заявление (ProgramExpenseStatement)
+ *
+ * @ingroup public_actions
+ * @ingroup public_capital_actions
+ *
+ * @note Авторизация требуется от @p coopname.
+ */
+void capital::createpgexp(name coopname, checksum256 expense_hash, name creator,
+                          std::vector<ExpenseDomain::item> items,
+                          std::string description, document2 statement) {
+  require_auth(coopname);
+
+  verify_document_or_fail(statement, {creator});
+  eosio::check(!items.empty(), "Программный расход должен содержать хотя бы один item");
+
+  // Сумма расхода — сумма planned_amount всех items.
+  asset amount = items.front().planned_amount;
+  amount.amount = 0;
+  for (const auto &it : items) {
+    amount += it.planned_amount;
+  }
+  Wallet::validate_asset(amount);
+  eosio::check(amount.amount > 0, "Сумма программного расхода должна быть положительной");
+
+  auto exist = Capital::get_program_expense(coopname, expense_hash);
+  eosio::check(!exist.has_value(), "Программный расход с указанным хэшем уже существует");
+
+  // Резерв в пуле до отправки в шасси — две параллельные заявки не превысят пул.
+  Capital::State::reserve_program_expense(coopname, amount);
+
+  Capital::Expenses::create_program_expense(coopname, expense_hash, creator,
+                                            amount, description, statement);
+
+  // Inline action в шасси expense с callback handler на capital::onpgexpdone.
+  // data пустой — capital резолвит запись по expense_hash, дополнительный payload не нужен.
+  ExpenseDomain::callback_handler callback{
+    .contract = _capital,
+    .action   = Names::Capital::ON_PROGRAM_EXPENSE_DONE,
+    .data     = std::vector<char>{}
+  };
+
+  // Authority — _capital: у capital@eosio.code нет coopname@active, а
+  // expense::createexp принимает контракты-инициаторы по contracts_whitelist.
+  eosio::action(
+    eosio::permission_level{_capital, "active"_n},
+    _expense,
+    Names::External::CREATE_EXPENSE_PROPOSAL,
+    std::make_tuple(coopname, creator, expense_hash,
+                    ledger2_wallets::PROGRAM_EXPENSE_POOL, items, callback, statement)
+  ).send();
+}

components/contracts/cpp/capital/app/expense_managment/program_expenses/onpgexpdone.cpp

@@ -0,0 +1,65 @@
+/**
+ * @brief Callback от шасси expense на финализацию program-расхода.
+ *
+ * Шасси expense шлёт его inline (authority — _expense@active) когда закончило
+ * flow (closeexp или declexp). capital не делает ledger2-проводок —
+ * они уже сделаны шасси на payexp/reportexp/returnexp/overspendexp. capital
+ * только обновляет @c program_expense_pool и удаляет запись из @c progexpenses.
+ *
+ *   status == ExpenseDomain::ProposalStatus::CLOSED (4):
+ *     total_actual <= reserved → consume(total_actual) + release(остаток);
+ *     total_actual >  reserved (был overspendexp) → consume(reserved) +
+ *       прямое списание превышения из program_expense_pool.
+ *   status == ExpenseDomain::ProposalStatus::DECLINED (5):
+ *     release(reserved); decline возможен только до оплат (total_actual == 0).
+ *
+ * @param coopname     Кооператив
+ * @param expense_hash Хеш расхода (ключ в progexpenses)
+ * @param status       ExpenseDomain::ProposalStatus
+ * @param total_actual Фактически потраченная сумма
+ * @param data         Произвольный payload от инициатора (не используется на MVP)
+ *
+ * @ingroup public_actions
+ * @ingroup public_capital_actions
+ *
+ * @note Авторизация требуется от @p _expense — inline-callback шасси.
+ */
+void capital::onpgexpdone(name coopname, checksum256 expense_hash, uint8_t status,
+                          eosio::asset total_actual, std::vector<char> data) {
+  require_auth(_expense);
+
+  auto pgexp = Capital::Expenses::get_program_expense_or_fail(coopname, expense_hash);
+  const auto reserved = pgexp.amount;
+
+  if (status == static_cast<uint8_t>(ExpenseDomain::ProposalStatus::CLOSED)) {
+    eosio::check(total_actual.symbol == reserved.symbol,
+                 "Символ total_actual не совпадает с зарезервированной суммой");
+    eosio::check(total_actual.amount >= 0,
+                 "total_actual не может быть отрицательным");
+
+    if (total_actual.amount <= reserved.amount) {
+      if (total_actual.amount > 0) {
+        Capital::State::consume_program_expense(coopname, total_actual);
+      }
+      const asset leftover = reserved - total_actual;
+      if (leftover.amount > 0) {
+        Capital::State::release_program_expense(coopname, leftover);
+      }
+    } else {
+      // Перерасход (overspendexp в шасси): резерв списываем полностью,
+      // превышение — напрямую из свободного пула программных расходов.
+      Capital::State::consume_program_expense(coopname, reserved);
+      const asset excess = total_actual - reserved;
+      Capital::State::spend_program_expense_pool(coopname, excess);
+    }
+  } else if (status == static_cast<uint8_t>(ExpenseDomain::ProposalStatus::DECLINED)) {
+    // Шасси отклоняет СЗ только до первой оплаты — резерв возвращается целиком.
+    eosio::check(total_actual.amount == 0,
+                 "DECLINED с ненулевым total_actual — нарушение инварианта шасси");
+    Capital::State::release_program_expense(coopname, reserved);
+  } else {
+    eosio::check(false, "onpgexpdone принимает только статусы CLOSED либо DECLINED");
+  }
+
+  Capital::Expenses::delete_program_expense(coopname, pgexp.id);
+}

components/contracts/cpp/capital/app/expense_managment/program_expenses/topupprogexp.cpp

@@ -0,0 +1,33 @@
+/**
+ * @brief Пополняет пул программных расходов из общего инвестиционного пула программы.
+ *
+ * Программные расходы — это целевые списания «Благорост», не аллоцированные ни в один проект
+ * (хозяйственные расходы программы, оплата инфраструктуры программы и т.п.). Прежде чем
+ * создавать запрос на программный расход, председатель пополняет дедикейтнутый пул
+ * @c program_expense_pool из общего @c global_available_invest_pool. Помимо счётчиков
+ * state наполняется КООПЕРАТИВНЫЙ ledger2-кошелёк @c PROGRAM_EXPENSE_POOL (w.cap.pgexp) —
+ * именно из него шасси expense оплачивает СЗ; личные L3-кошельки пайщиков (w.cap.blago)
+ * при расходах не изменяются.
+ *
+ * @param coopname Кооператив (scope state)
+ * @param amount   Сумма пополнения (символ строго совпадает с программой)
+ * @ingroup public_actions
+ * @ingroup public_capital_actions
+ *
+ * @note Авторизация требуется от аккаунта: @p coopname (председатель).
+ */
+void capital::topupprogexp(name coopname, eosio::asset amount) {
+  require_auth(coopname);
+
+  Capital::State::topup_program_expense_pool(coopname, amount);
+
+  // Кошелёк-резерв пула: ISSUE w.cap.pgexp без бухпроводки (деньги физически
+  // на 51 с момента взносов — выделяется только назначение под расходы).
+  // Синтетический process_hash — у пополнения нет естественного анкера.
+  const uint64_t now_us = eosio::current_time_point().time_since_epoch().count();
+  const std::string anchor = coopname.to_string() + ":pgtopup:" + std::to_string(now_us);
+  const checksum256 process_hash = eosio::sha256(anchor.c_str(), anchor.size());
+
+  Ledger2::apply(_capital, coopname, operations::capital::PROGRAM_EXPENSE_TOPUP, amount,
+                 name{}, process_hash, "capital:topupprogexp");
+}

components/contracts/cpp/capital/capital.cpp

@@ -95,6 +95,12 @@
 #include "app/debt_managment/create_debt/declinedebt.cpp"
 #include "app/debt_managment/settle_debt/settledebt.cpp"
 
+// Управление программными расходами через шасси expense.
+// capital — инициатор + получатель callback, шасси обслуживает весь flow.
+#include "app/expense_managment/program_expenses/topupprogexp.cpp"
+#include "app/expense_managment/program_expenses/createpgexp.cpp"
+#include "app/expense_managment/program_expenses/onpgexpdone.cpp"
+
 // Управление расходами
 #include "app/expense_managment/create_expense/approveexpns.cpp"
 #include "app/expense_managment/create_expense/capauthexpns.cpp"

components/contracts/cpp/capital/capital.hpp

@@ -48,6 +48,7 @@ constexpr uint128_t CRPS_PRECISION_FACTOR = 100000000000000ULL; ///< Масшт
 #include <eosio/asset.hpp>
 #include "../lib/index.hpp"
 #include "domain/index.hpp"
+#include "../expense/expense.hpp"   // ExpenseDomain::item / callback_handler — для inline-action в шасси
 
 
 using namespace eosio;
@@ -322,4 +323,38 @@ public:
     [[eosio::action]]
     void settledebt(name coopname, name username, eosio::asset amount, document2 statement);
 
+    // Программные расходы через шасси expense.
+    // capital — инициатор + получатель callback, шасси держит весь flow расхода.
+
+    [[eosio::action]]
+    void topupprogexp(name coopname, eosio::asset amount);
+
+    /**
+     * @brief Инициировать программный расход через шасси expense.
+     * Резервирует amount в program_expense_pool, создаёт запись progexpense,
+     * шлёт inline action expense::createexp с callback={capital, onpgexpdone}.
+     * Шасси обслуживает весь flow (auth/pay/report/close|decline) и шлёт callback.
+     *
+     * items[] — позиции СЗ (см. ExpenseDomain::item); механика оплаты per-item
+     * (item.mechanics: ADVANCE — аванс, DIRECT — прямая оплата).
+     */
+    [[eosio::action]]
+    void createpgexp(name coopname, checksum256 expense_hash, name creator,
+                     std::vector<ExpenseDomain::item> items,
+                     std::string description, document2 statement);
+
+    /**
+     * @brief Callback от шасси expense на финализацию program-расхода.
+     * Шасси шлёт его inline (authority — _expense@active, require_auth(_expense))
+     * после терминального перехода flow (CLOSED либо DECLINED).
+     *
+     *   status == CLOSED   → consume(total_actual) + release(остаток резерва);
+     *                         при total_actual > reserved (перерасход) превышение
+     *                         списывается напрямую из program_expense_pool.
+     *   status == DECLINED → release(reserved); decline возможен только до оплат.
+     */
+    [[eosio::action]]
+    void onpgexpdone(name coopname, checksum256 expense_hash, uint8_t status,
+                     eosio::asset total_actual, std::vector<char> data);
+
 };

components/contracts/cpp/capital/domain/entities/expenses.hpp

@@ -178,8 +178,96 @@ namespace Capital::Expenses {
     Capital::expense_index expenses(_capital, coopname.value);
     auto expense = expenses.find(expense_id);
     eosio::check(expense != expenses.end(), "Расход не найден");
-    
+
     expenses.erase(expense);
   }
 
+} // namespace Capital::Expenses
+
+namespace Capital {
+
+  /**
+   * @brief Таблица программных расходов — целевые списания «Благорост»,
+   *        не привязанные к конкретному проекту.
+   * @par Область памяти (scope): coopname
+   * @par Имя таблицы (table): progexpenses
+   */
+  struct [[eosio::table, eosio::contract(CAPITAL)]] program_expense {
+    uint64_t id;                                    ///< Внутренний ключ
+    name coopname;                                  ///< Имя кооператива
+    name username;                                  ///< Инициатор расхода (председатель / казначей)
+
+    name status = Expenses::Status::CREATED;        ///< Статус (CREATED/APPROVED/AUTHORIZED/PAID/DECLINED — общий enum)
+    checksum256 expense_hash;                       ///< Хеш расхода — анкер процесса p.cap.expns
+    uint64_t fund_id;                               ///< Идентификатор фонда списания
+    eosio::asset amount;                            ///< Сумма расхода
+    std::string description;                        ///< Описание (для отчётности)
+
+    document2 expense_statement;                    ///< Служебная записка (ProgramExpenseStatement)
+    document2 approved_statement;                   ///< Записка, принятая председателем
+    document2 authorization;                        ///< Решение совета
+
+    time_point_sec spended_at = current_time_point();
+
+    uint64_t primary_key() const { return id; }
+    uint64_t by_username() const { return username.value; }
+    checksum256 by_expense_hash() const { return expense_hash; }
+  };
+
+  typedef eosio::multi_index<
+    "progexpenses"_n, program_expense,
+    indexed_by<"byusername"_n, const_mem_fun<program_expense, uint64_t, &program_expense::by_username>>,
+    indexed_by<"byhash"_n, const_mem_fun<program_expense, checksum256, &program_expense::by_expense_hash>>
+  > program_expense_index;
+
+  inline std::optional<program_expense> get_program_expense(eosio::name coopname, const checksum256 &hash) {
+    program_expense_index t(_capital, coopname.value);
+    auto idx = t.get_index<"byhash"_n>();
+    auto itr = idx.find(hash);
+    if (itr == idx.end()) return std::nullopt;
+    return program_expense(*itr);
+  }
+
+} // namespace Capital
+
+namespace Capital::Expenses {
+
+  inline program_expense get_program_expense_or_fail(eosio::name coopname, const checksum256 &expense_hash) {
+    auto v = Capital::get_program_expense(coopname, expense_hash);
+    eosio::check(v.has_value(), "Программный расход с указанным хэшем не найден");
+    return v.value();
+  }
+
+  inline void create_program_expense(
+    eosio::name coopname,
+    const checksum256 &expense_hash,
+    eosio::name username,
+    const eosio::asset &amount,
+    const std::string &description,
+    const document2 &statement
+  ) {
+    Capital::program_expense_index t(_capital, coopname.value);
+    uint64_t id = get_global_id_in_scope(_capital, coopname, "progexpenses"_n);
+
+    t.emplace(coopname, [&](auto &e) {
+      e.id = id;
+      e.coopname = coopname;
+      e.username = username;
+      e.expense_hash = expense_hash;
+      e.fund_id = Ledger::accounts::GENERAL_EXPENSES;
+      e.status = Status::CREATED;
+      e.spended_at = current_time_point();
+      e.expense_statement = statement;
+      e.amount = amount;
+      e.description = description;
+    });
+  }
+
+  inline void delete_program_expense(eosio::name coopname, uint64_t id) {
+    Capital::program_expense_index t(_capital, coopname.value);
+    auto itr = t.find(id);
+    eosio::check(itr != t.end(), "Программный расход не найден");
+    t.erase(itr);
+  }
+
 } // namespace Capital::Expenses

components/contracts/cpp/capital/domain/entities/global_state.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <eosio/binary_extension.hpp>
+
 using namespace eosio;
 using std::string;
 
@@ -40,7 +42,18 @@ namespace Capital {
     double program_membership_cumulative_reward_per_share;               ///< Накопительное вознаграждение на долю в членских взносах
 
     config config;                                           ///< Управляемая конфигурация контракта
-    
+
+    // ВНИМАНИЕ: поля программных расходов добавлены ПОСЛЕ config и обёрнуты в
+    // binary_extension. Поля в таблицу EOSIO можно дописывать только в ХВОСТ
+    // struct и только через binary_extension — иначе ломается десериализация
+    // уже записанного global_state. Инцидент 2026-06-16: эти поля были вставлены
+    // перед config напрямую (без extension) и задеплоены на прод — таблица state
+    // перестала читаться (get table → "Invalid symbol", action'ы падали на unpack).
+    // Инвариант: оба поля материализуются вместе (всегда оба has_value или оба
+    // пустые), чтобы порядок хвостовых extension оставался консистентным.
+    eosio::binary_extension<asset> program_expense_pool;     ///< Доступная сумма программы под целевые расходы (без аллокации в проекты)
+    eosio::binary_extension<asset> program_expense_reserved; ///< Сумма, зарезервированная под approved/authorized программные расходы
+
     uint64_t primary_key() const { return coopname.value; }     ///< Первичный ключ (1)
   };
 
@@ -50,6 +63,16 @@ namespace Capital {
   
 
 namespace State {
+
+/**
+  * @brief Значение binary_extension<asset> или ноль с символом @p sym, если поле
+  *        ещё не материализовано (старая запись, созданная до добавления
+  *        program_expense_* через binary_extension).
+  */
+inline asset ext_or_zero(const eosio::binary_extension<asset>& v, const eosio::symbol& sym) {
+  return v.has_value() ? v.value() : asset(0, sym);
+}
+
 /**
   * @brief Обновляет глобальное состояние новыми значениями.
   *
@@ -78,7 +101,7 @@ inline global_state get_global_state(name coopname) {
 
 /**
  * @brief Проверяет что контракт инициализирован.
- * 
+ *
  * @param coopname Имя кооператива.
  */
 inline void is_initialized(name coopname) {
@@ -86,6 +109,116 @@ inline void is_initialized(name coopname) {
   auto itr = global_state_inst.find(coopname.value);
   eosio::check(itr != global_state_inst.end(), "Контракт не инициализирован");
 }
+
+/**
+ * @brief Пополняет пул программных расходов на @p amount из общего пула инвестиций программы.
+ *        Вызывается из action topupprogexp (председатель).
+ */
+inline void topup_program_expense_pool(eosio::name coopname, const asset &amount) {
+  global_state_table global_state_inst(_capital, _capital.value);
+  auto itr = global_state_inst.find(coopname.value);
+  eosio::check(itr != global_state_inst.end(), "Контракт не инициализирован");
+  eosio::check(amount.is_valid() && amount.amount > 0, "Сумма пополнения должна быть положительной");
+  eosio::check(itr->global_available_invest_pool >= amount,
+               "Недостаточно свободных инвестиций программы для пополнения пула расходов");
+
+  global_state_inst.modify(itr, _capital, [&](auto &s) {
+    asset pool     = ext_or_zero(s.program_expense_pool, amount.symbol);
+    asset reserved = ext_or_zero(s.program_expense_reserved, amount.symbol);
+    s.global_available_invest_pool -= amount;
+    pool += amount;
+    s.program_expense_pool     = pool;
+    s.program_expense_reserved = reserved;
+  });
+}
+
+/**
+ * @brief Резервирует средства под approved/authorized программный расход:
+ *        program_expense_pool -= amount, program_expense_reserved += amount.
+ */
+inline void reserve_program_expense(eosio::name coopname, const asset &amount) {
+  global_state_table global_state_inst(_capital, _capital.value);
+  auto itr = global_state_inst.find(coopname.value);
+  eosio::check(itr != global_state_inst.end(), "Контракт не инициализирован");
+  eosio::check(amount.is_valid() && amount.amount > 0, "Сумма резерва должна быть положительной");
+  eosio::check(ext_or_zero(itr->program_expense_pool, amount.symbol) >= amount,
+               "Недостаточно средств в пуле программных расходов");
+
+  global_state_inst.modify(itr, _capital, [&](auto &s) {
+    asset pool     = ext_or_zero(s.program_expense_pool, amount.symbol);
+    asset reserved = ext_or_zero(s.program_expense_reserved, amount.symbol);
+    pool     -= amount;
+    reserved += amount;
+    s.program_expense_pool     = pool;
+    s.program_expense_reserved = reserved;
+  });
+}
+
+/**
+ * @brief Освобождает зарезервированное при отклонении программного расхода:
+ *        program_expense_reserved -= amount, program_expense_pool += amount.
+ */
+inline void release_program_expense(eosio::name coopname, const asset &amount) {
+  global_state_table global_state_inst(_capital, _capital.value);
+  auto itr = global_state_inst.find(coopname.value);
+  eosio::check(itr != global_state_inst.end(), "Контракт не инициализирован");
+  eosio::check(amount.is_valid() && amount.amount > 0, "Сумма освобождения должна быть положительной");
+  eosio::check(ext_or_zero(itr->program_expense_reserved, amount.symbol) >= amount,
+               "Зарезервированных программных расходов меньше указанной суммы");
+
+  global_state_inst.modify(itr, _capital, [&](auto &s) {
+    asset pool     = ext_or_zero(s.program_expense_pool, amount.symbol);
+    asset reserved = ext_or_zero(s.program_expense_reserved, amount.symbol);
+    reserved -= amount;
+    pool     += amount;
+    s.program_expense_pool     = pool;
+    s.program_expense_reserved = reserved;
+  });
+}
+
+/**
+ * @brief Окончательное списание программного расхода (callback onpgexpdone, CLOSED):
+ *        program_expense_reserved -= amount. Деньги уже ушли через шасси expense,
+ *        ledger2-проводки сделаны на payexp/reportexp/returnexp.
+ */
+inline void consume_program_expense(eosio::name coopname, const asset &amount) {
+  global_state_table global_state_inst(_capital, _capital.value);
+  auto itr = global_state_inst.find(coopname.value);
+  eosio::check(itr != global_state_inst.end(), "Контракт не инициализирован");
+  eosio::check(amount.is_valid() && amount.amount > 0, "Сумма списания должна быть положительной");
+  eosio::check(ext_or_zero(itr->program_expense_reserved, amount.symbol) >= amount,
+               "Зарезервированных программных расходов меньше указанной суммы");
+
+  global_state_inst.modify(itr, _capital, [&](auto &s) {
+    asset pool     = ext_or_zero(s.program_expense_pool, amount.symbol);
+    asset reserved = ext_or_zero(s.program_expense_reserved, amount.symbol);
+    reserved -= amount;
+    s.program_expense_pool     = pool;
+    s.program_expense_reserved = reserved;
+  });
+}
+
+/**
+ * @brief Прямое списание из свободного пула программных расходов — превышение
+ *        факта над резервом при закрытии расхода с перерасходом (overspendexp
+ *        в шасси выдал доплату из BLAGOROST_FUND сверх зарезервированного).
+ */
+inline void spend_program_expense_pool(eosio::name coopname, const asset &amount) {
+  global_state_table global_state_inst(_capital, _capital.value);
+  auto itr = global_state_inst.find(coopname.value);
+  eosio::check(itr != global_state_inst.end(), "Контракт не инициализирован");
+  eosio::check(amount.is_valid() && amount.amount > 0, "Сумма списания должна быть положительной");
+  eosio::check(ext_or_zero(itr->program_expense_pool, amount.symbol) >= amount,
+               "Недостаточно средств в пуле программных расходов для покрытия перерасхода — пополните пул (topupprogexp)");
+
+  global_state_inst.modify(itr, _capital, [&](auto &s) {
+    asset pool     = ext_or_zero(s.program_expense_pool, amount.symbol);
+    asset reserved = ext_or_zero(s.program_expense_reserved, amount.symbol);
+    pool -= amount;
+    s.program_expense_pool     = pool;
+    s.program_expense_reserved = reserved;
+  });
+}
 }// namespace State
 
 }// namespace Capital

components/contracts/cpp/expense/CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.5)
+
+project(expense)
+
+find_package(cdt)
+
+add_contract(expense expense expense.cpp)
+if(IS_TESTNET)
+    target_compile_definitions(expense PUBLIC IS_TESTNET=1)
+endif()

components/contracts/cpp/expense/expense.cpp

@@ -0,0 +1,425 @@
+// expense.cpp — шасси расходов (первый потребитель: Благорост).
+//
+// Принцип: контракт-владелец расходных операций, агностичен к программе-источнику.
+// Кошелёк-пул приходит в createexp параметром source_wallet; ledger2-коды всех
+// операций жизненного цикла выводятся из него через EXPENSE_OPERATION_SETS
+// (фабричная настройка — подключение нового пула не меняет этот контракт).
+// Механика оплаты per-item (ADVANCE | DIRECT) выбирает код внутри набора;
+// callback-handler сохраняется как переменная.
+
+#include "expense.hpp"
+
+namespace D = ExpenseDomain;
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+namespace {
+
+asset zero_like(const asset& a) { return asset{0, a.symbol}; }
+
+asset sum_planned(const std::vector<D::item>& items) {
+  if (items.empty()) return asset{0, eosio::symbol{"RUB", 4}};
+  asset total = zero_like(items.front().planned_amount);
+  for (const auto& it : items) total += it.planned_amount;
+  return total;
+}
+
+// Набор ledger2-кодов операций шасси по кошельку-источнику СЗ. Один источник =
+// один набор (EXPENSE_OPERATION_SETS в ledger2) — в коде expense нет
+// захардкоженных operation_code, контракт настраивается на любой пул.
+const ExpenseOperationSet& expense_ops_for(eosio::name source_wallet) {
+  const auto* set = find_expense_operation_set(source_wallet);
+  eosio::check(set != nullptr,
+               "Для кошелька-источника не настроен набор операций шасси расходов (EXPENSE_OPERATION_SETS)");
+  return *set;
+}
+
+D::proposals_index get_proposals(eosio::name self, eosio::name coopname) {
+  return D::proposals_index(self, coopname.value);
+}
+
+auto find_proposal(D::proposals_index& tbl, const eosio::checksum256& proposal_hash) {
+  auto idx = tbl.get_index<"byhash"_n>();
+  return idx.find(proposal_hash);
+}
+
+void send_callback_if_any(const D::callback_handler& cb,
+                          eosio::name coopname,
+                          const eosio::checksum256& proposal_hash,
+                          uint8_t status,
+                          const eosio::asset& amount,
+                          eosio::name self) {
+  if (cb.contract.value == 0) return;
+  // Payload: (coopname, proposal_hash, status, total_actual, data).
+  // status = ExpenseDomain::ProposalStatus — инициатор различает CLOSED vs DECLINED.
+  // coopname нужен инициатору для скоупа таблиц (capital::progexpenses scope=coopname).
+  eosio::action(
+    eosio::permission_level{self, "active"_n},
+    cb.contract,
+    cb.action,
+    std::make_tuple(coopname, proposal_hash, status, amount, cb.data)
+  ).send();
+}
+
+} // namespace
+
+// ── actions ──────────────────────────────────────────────────────────────────
+
+void expense::createexp(name coopname, name username,
+                        checksum256 proposal_hash,
+                        name source_wallet,
+                        std::vector<D::item> items,
+                        D::callback_handler callback,
+                        document2 statement) {
+  // Прямой вызов backend'а — авторизация кооператива; inline от контракта-инициатора
+  // (capital::createpgexp и т.п.) — авторизация по whitelist, как в ledger2::apply.
+  if (!has_auth(coopname)) {
+    check_auth_and_get_payer_or_fail(contracts_whitelist);
+  }
+
+  verify_document_or_fail(statement, {username});
+  eosio::check(!items.empty(), "СЗ должен содержать хотя бы один item");
+  eosio::check(ledger2_is_known_wallet(source_wallet),
+               "source_wallet не найден в LEDGER2_WALLET_REGISTRY");
+  // Источник определяет ledger2-коды всех операций жизненного цикла —
+  // отказываем сразу при создании, а не в момент оплаты.
+  expense_ops_for(source_wallet);
+
+  auto tbl = get_proposals(get_self(), coopname);
+  eosio::check(find_proposal(tbl, proposal_hash) == tbl.get_index<"byhash"_n>().end(),
+               "СЗ с таким proposal_hash уже существует");
+
+  // Механика оплаты задаётся на каждом item отдельно (ADVANCE | DIRECT) —
+  // в одном СЗ допустимо смешение: ledger2-проводка payexp идёт по-позиционно
+  // с кодом, выведенным из механики конкретного item'а.
+  for (auto& it : items) {
+    eosio::check(it.planned_amount.is_valid() && it.planned_amount.amount > 0,
+                 "planned_amount каждого item должен быть положительным");
+    eosio::check(it.mechanics <= static_cast<uint8_t>(D::Mechanics::DIRECT),
+                 "Неизвестная mechanics item (0 = ADVANCE, 1 = DIRECT)");
+    eosio::check(it.recipient_type <= static_cast<uint8_t>(D::RecipientType::ORG),
+                 "Неизвестный recipient_type item");
+
+    // Инвариант: пайщик (SELF/MEMBER) получает только аванс под отчёт на личные
+    // реквизиты (расходом станет после его отчёта чеком); организация — только
+    // прямую оплату по выставленным реквизитам, аванс ей не выдаётся.
+    if (it.recipient_type == static_cast<uint8_t>(D::RecipientType::ORG)) {
+      eosio::check(it.mechanics == static_cast<uint8_t>(D::Mechanics::DIRECT),
+                   "Организации/ИП доступна только оплата по счёту (DIRECT)");
+    } else {
+      eosio::check(it.mechanics == static_cast<uint8_t>(D::Mechanics::ADVANCE),
+                   "Пайщику средства выдаются только авансом под отчёт (ADVANCE)");
+      eosio::check(it.recipient != name(),
+                   "recipient обязателен для получателя-пайщика");
+      eosio::check(is_account(it.recipient),
+                   "Аккаунт получателя-пайщика не существует");
+    }
+
+    it.status        = static_cast<uint8_t>(D::ItemStatus::APPROVED);
+    it.actual_amount = zero_like(it.planned_amount);
+  }
+
+  const auto total = sum_planned(items);
+
+  tbl.emplace(get_self(), [&](auto& row) {
+    row.id              = tbl.available_primary_key();
+    row.coopname        = coopname;
+    row.proposal_hash   = proposal_hash;
+    row.username        = username;
+    row.source_wallet   = source_wallet;
+    row.status          = static_cast<uint8_t>(D::ProposalStatus::CREATED);
+    row.items           = items;
+    row.total_planned   = total;
+    row.total_actual    = zero_like(total);
+    row.callback        = callback;
+    row.statement_doc   = statement;
+    row.decision_doc    = document2{};
+    row.created_at      = eosio::current_time_point();
+    row.updated_at      = row.created_at;
+  });
+
+  // СЗ утверждает совет (как возвраты паевых взносов): ставим вопрос в повестку.
+  // Утверждение председателем после голосования → callback authexp от _soviet;
+  // отклонение (отрицательный консенсус / просрочка) → declexp с причиной.
+  ::Soviet::create_agenda(
+    _expense,
+    coopname,
+    username,
+    get_valid_soviet_action("createexp"_n),
+    proposal_hash,
+    _expense,
+    "authexp"_n,
+    "declexp"_n,
+    statement,
+    std::string("")
+  );
+}
+
+void expense::authexp(name coopname, checksum256 proposal_hash, document2 decision) {
+  require_auth(_soviet);
+
+  auto tbl = get_proposals(get_self(), coopname);
+  auto idx = tbl.get_index<"byhash"_n>();
+  auto it  = idx.find(proposal_hash);
+  eosio::check(it != idx.end(), "СЗ не найден");
+  eosio::check(it->status == static_cast<uint8_t>(D::ProposalStatus::CREATED),
+               "Авторизовать можно только СЗ в статусе CREATED");
+
+  verify_document_or_fail(decision);
+
+  idx.modify(it, get_self(), [&](auto& row) {
+    row.decision_doc = decision;
+    row.status       = static_cast<uint8_t>(D::ProposalStatus::AUTHORIZED);
+    row.updated_at   = eosio::current_time_point();
+  });
+}
+
+void expense::declexp(name coopname, checksum256 proposal_hash, std::string reason) {
+  require_auth(_soviet);
+
+  auto tbl = get_proposals(get_self(), coopname);
+  auto idx = tbl.get_index<"byhash"_n>();
+  auto it  = idx.find(proposal_hash);
+  eosio::check(it != idx.end(), "СЗ не найден");
+  // Отклонение возможно только пока ни один item не оплачен: после payexp деньги
+  // уже ушли через ledger2, и decline разъехался бы с учётом инициатора
+  // (callback DECLINED возвращает инициатору весь резерв). Частично исполненный
+  // СЗ завершается обычным путём: reportexp / returnexp → closeexp.
+  eosio::check(it->status == static_cast<uint8_t>(D::ProposalStatus::CREATED) ||
+               it->status == static_cast<uint8_t>(D::ProposalStatus::AUTHORIZED),
+               "Отклонить можно только СЗ без оплат (статусы CREATED / AUTHORIZED)");
+
+  idx.modify(it, get_self(), [&](auto& row) {
+    row.status     = static_cast<uint8_t>(D::ProposalStatus::DECLINED);
+    row.updated_at = eosio::current_time_point();
+  });
+
+  // Callback инициатору (capital::onpgexpdone и т.п.); total_actual здесь всегда 0 —
+  // оплат до decline не было (см. проверку статусов выше).
+  send_callback_if_any(it->callback, coopname, proposal_hash,
+                       static_cast<uint8_t>(D::ProposalStatus::DECLINED),
+                       it->total_actual, get_self());
+}
+
+void expense::payexp(name coopname, checksum256 proposal_hash, checksum256 item_hash,
+                     asset actual_amount) {
+  require_auth(coopname);
+
+  auto tbl = get_proposals(get_self(), coopname);
+  auto idx = tbl.get_index<"byhash"_n>();
+  auto it  = idx.find(proposal_hash);
+  eosio::check(it != idx.end(), "СЗ не найден");
+  eosio::check(it->status == static_cast<uint8_t>(D::ProposalStatus::AUTHORIZED) ||
+               it->status == static_cast<uint8_t>(D::ProposalStatus::PARTIALLY_PAID),
+               "Оплата возможна только из статусов AUTHORIZED / PARTIALLY_PAID");
+  eosio::check(actual_amount.is_valid() && actual_amount.amount > 0,
+               "actual_amount должен быть положительным");
+
+  bool item_found = false;
+  uint8_t paid_mechanics = 0;
+  name paid_recipient{};
+
+  idx.modify(it, get_self(), [&](auto& row) {
+    bool all_reported = true;
+    for (auto& i : row.items) {
+      if (i.item_hash == item_hash) {
+        eosio::check(i.status == static_cast<uint8_t>(D::ItemStatus::APPROVED),
+                     "Item уже оплачен или закрыт");
+        eosio::check(actual_amount.symbol == i.planned_amount.symbol,
+                     "Символ actual_amount не совпадает с планом item");
+        eosio::check(actual_amount.amount <= i.planned_amount.amount,
+                     "Сумма оплаты не может превышать план item; доплата сверх плана — через overspendexp");
+        i.actual_amount = actual_amount;
+        // DIRECT не имеет фазы подотчёта (нет ADVANCE_HOLD): закрывающие документы
+        // прикладывает сам кассир, item считается отчитанным сразу после оплаты.
+        i.status = static_cast<D::Mechanics>(i.mechanics) == D::Mechanics::DIRECT
+          ? static_cast<uint8_t>(D::ItemStatus::REPORTED)
+          : static_cast<uint8_t>(D::ItemStatus::PAID);
+        paid_mechanics = i.mechanics;
+        paid_recipient = i.recipient;
+        item_found = true;
+      }
+      if (i.status != static_cast<uint8_t>(D::ItemStatus::REPORTED)) {
+        all_reported = false;
+      }
+    }
+    eosio::check(item_found, "item с заданным hash не найден в СЗ");
+    row.total_actual += actual_amount;
+    // DIRECT-only СЗ становится готов к закрытию сразу после последней оплаты.
+    row.status = all_reported
+      ? static_cast<uint8_t>(D::ProposalStatus::REPORT_SUBMITTED)
+      : static_cast<uint8_t>(D::ProposalStatus::PARTIALLY_PAID);
+    row.updated_at = eosio::current_time_point();
+  });
+
+  // ledger2-проводка по механике оплаченного item'а — выдача аванса или прямая
+  // оплата; коды выводятся из кошелька-источника СЗ. СЗ может смешивать механики.
+  // username нужен ledger2 только для USER_SHARED-стороны (кошелёк-подотчёт) —
+  // это ПОЛУЧАТЕЛЬ аванса, не автор СЗ.
+  const auto& ops = expense_ops_for(it->source_wallet);
+  const auto code = static_cast<D::Mechanics>(paid_mechanics) == D::Mechanics::ADVANCE
+    ? ops.advance
+    : ops.direct;
+  Ledger2::apply(get_self(), coopname, code, actual_amount,
+                 paid_recipient, proposal_hash, "expense:payexp");
+}
+
+void expense::reportexp(name coopname, checksum256 proposal_hash, checksum256 item_hash) {
+  require_auth(coopname);
+
+  auto tbl = get_proposals(get_self(), coopname);
+  auto idx = tbl.get_index<"byhash"_n>();
+  auto it  = idx.find(proposal_hash);
+  eosio::check(it != idx.end(), "СЗ не найден");
+  eosio::check(it->status == static_cast<uint8_t>(D::ProposalStatus::PARTIALLY_PAID),
+               "Отчёт возможен только по СЗ в статусе PARTIALLY_PAID");
+
+  asset item_amount = asset{0, it->total_actual.symbol};
+  bool item_found = false;
+  name item_recipient{};
+
+  idx.modify(it, get_self(), [&](auto& row) {
+    bool all_reported = true;
+    for (auto& i : row.items) {
+      if (i.item_hash == item_hash) {
+        eosio::check(i.status == static_cast<uint8_t>(D::ItemStatus::PAID),
+                     "Отчёт возможен только для оплаченных items");
+        eosio::check(static_cast<D::Mechanics>(i.mechanics) == D::Mechanics::ADVANCE,
+                     "reportexp применим только к ADVANCE-механике");
+        i.status   = static_cast<uint8_t>(D::ItemStatus::REPORTED);
+        item_amount = i.actual_amount;
+        item_recipient = i.recipient;
+        item_found  = true;
+      }
+      if (i.status != static_cast<uint8_t>(D::ItemStatus::REPORTED)) {
+        all_reported = false;
+      }
+    }
+    eosio::check(item_found, "item с заданным hash не найден в СЗ");
+    if (all_reported) {
+      row.status = static_cast<uint8_t>(D::ProposalStatus::REPORT_SUBMITTED);
+    }
+    row.updated_at = eosio::current_time_point();
+  });
+
+  // ledger2: BURN кошелька-подотчёта на остаточный actual item'а (выдано −
+  // возвращено + доплачено), без бухпроводки — проводка уже сделана при выдаче.
+  // Подотчёт числится на получателе аванса — его username и закрывает burn.
+  // Полный возврат аванса (actual == 0) — burn не нужен, подотчёт уже пуст.
+  if (item_amount.amount > 0) {
+    Ledger2::apply(get_self(), coopname, expense_ops_for(it->source_wallet).report, item_amount,
+                   item_recipient, proposal_hash, "expense:reportexp");
+  }
+}
+
+void expense::closeexp(name coopname, checksum256 proposal_hash) {
+  require_auth(coopname);
+
+  auto tbl = get_proposals(get_self(), coopname);
+  auto idx = tbl.get_index<"byhash"_n>();
+  auto it  = idx.find(proposal_hash);
+  eosio::check(it != idx.end(), "СЗ не найден");
+  eosio::check(it->status == static_cast<uint8_t>(D::ProposalStatus::REPORT_SUBMITTED),
+               "Закрыть можно только СЗ в статусе REPORT_SUBMITTED");
+
+  idx.modify(it, get_self(), [&](auto& row) {
+    row.status     = static_cast<uint8_t>(D::ProposalStatus::CLOSED);
+    row.updated_at = eosio::current_time_point();
+  });
+
+  // Callback на финализацию (capital::onpgexpdone и т.п.) — если был установлен при createexp.
+  send_callback_if_any(it->callback, coopname, proposal_hash,
+                       static_cast<uint8_t>(D::ProposalStatus::CLOSED),
+                       it->total_actual, get_self());
+}
+
+void expense::returnexp(name coopname, checksum256 proposal_hash, checksum256 item_hash,
+                        asset return_amount) {
+  require_auth(coopname);
+
+  auto tbl = get_proposals(get_self(), coopname);
+  auto idx = tbl.get_index<"byhash"_n>();
+  auto it  = idx.find(proposal_hash);
+  eosio::check(it != idx.end(), "СЗ не найден");
+  eosio::check(it->status == static_cast<uint8_t>(D::ProposalStatus::PARTIALLY_PAID),
+               "Возврат возможен только по СЗ в статусе PARTIALLY_PAID");
+
+  bool item_found = false;
+  name item_recipient{};
+
+  idx.modify(it, get_self(), [&](auto& row) {
+    for (auto& i : row.items) {
+      if (i.item_hash == item_hash) {
+        eosio::check(i.status == static_cast<uint8_t>(D::ItemStatus::PAID),
+                     "Возврат возможен только из статуса PAID");
+        eosio::check(static_cast<D::Mechanics>(i.mechanics) == D::Mechanics::ADVANCE,
+                     "returnexp применим только к ADVANCE-механике");
+        eosio::check(return_amount.is_valid() &&
+                     return_amount.symbol == i.actual_amount.symbol,
+                     "Символ return_amount не совпадает с item");
+        eosio::check(return_amount.amount > 0 && return_amount.amount <= i.actual_amount.amount,
+                     "return_amount должен быть положительным и не превышать actual_amount");
+        // Settlement-запись: статус item НЕ меняется (остаётся PAID) — после
+        // возврата остатка получатель штатно отчитывается reportexp по
+        // фактически потраченной части (при полном возврате — actual == 0).
+        i.actual_amount -= return_amount;
+        item_recipient = i.recipient;
+        item_found = true;
+        break;
+      }
+    }
+    eosio::check(item_found, "item с заданным hash не найден в СЗ");
+    row.total_actual -= return_amount;
+    row.updated_at   = eosio::current_time_point();
+  });
+
+  // ledger2: TRANSFER подотчёт → пул-источник (зеркало выдачи аванса).
+  // Подотчёт снимается с получателя аванса.
+  Ledger2::apply(get_self(), coopname, expense_ops_for(it->source_wallet).refund, return_amount,
+                 item_recipient, proposal_hash, "expense:returnexp");
+}
+
+void expense::overspendexp(name coopname, checksum256 proposal_hash, checksum256 item_hash,
+                           asset overspend_amount) {
+  require_auth(coopname);
+  eosio::check(overspend_amount.amount > 0, "overspend_amount должен быть положительным");
+
+  auto tbl = get_proposals(get_self(), coopname);
+  auto idx = tbl.get_index<"byhash"_n>();
+  auto it  = idx.find(proposal_hash);
+  eosio::check(it != idx.end(), "СЗ не найден");
+  eosio::check(it->status == static_cast<uint8_t>(D::ProposalStatus::PARTIALLY_PAID),
+               "Перерасход возможен только по СЗ в статусе PARTIALLY_PAID");
+
+  bool item_found = false;
+  name item_recipient{};
+
+  idx.modify(it, get_self(), [&](auto& row) {
+    for (auto& i : row.items) {
+      if (i.item_hash == item_hash) {
+        eosio::check(i.status == static_cast<uint8_t>(D::ItemStatus::PAID),
+                     "Перерасход регистрируется только из статуса PAID");
+        eosio::check(static_cast<D::Mechanics>(i.mechanics) == D::Mechanics::ADVANCE,
+                     "overspendexp применим только к ADVANCE-механике");
+        eosio::check(overspend_amount.is_valid() &&
+                     overspend_amount.symbol == i.actual_amount.symbol,
+                     "Символ overspend_amount не совпадает с item");
+        // Settlement-запись: статус item НЕ меняется (остаётся PAID) — подотчёт
+        // (теперь на полную сумму выдано + доплата) закрывается штатным reportexp,
+        // который сделает burn ADVANCE_HOLD на итоговый actual.
+        i.actual_amount += overspend_amount;
+        item_recipient = i.recipient;
+        item_found = true;
+        break;
+      }
+    }
+    eosio::check(item_found, "item с заданным hash не найден в СЗ");
+    row.total_actual += overspend_amount;
+    row.updated_at   = eosio::current_time_point();
+  });
+
+  // ledger2: доплата перерасхода — TRANSFER пул-источник → подотчёт получателя
+  // (зеркало выдачи аванса на сумму доплаты). Закрытие на полную сумму — в reportexp.
+  Ledger2::apply(get_self(), coopname, expense_ops_for(it->source_wallet).overspend, overspend_amount,
+                 item_recipient, proposal_hash, "expense:overspend");
+}

components/contracts/cpp/expense/expense.hpp

@@ -0,0 +1,233 @@
+#pragma once
+
+#include <eosio/eosio.hpp>
+#include <eosio/asset.hpp>
+#include <eosio/crypto.hpp>
+#include "../lib/index.hpp"
+
+using namespace eosio;
+using std::string;
+
+/**
+ *  @defgroup public_expense Контракт EXPENSE
+ *  @brief Шасси расходов цифрового кооператива (MVP — Благорост).
+ *
+ *  Универсальный контракт: principal storage = СЗ-расход с массивом items;
+ *  кошелёк-источник (пул) приходит параметром source_wallet, ledger2-коды всех
+ *  операций жизненного цикла выводятся из него через EXPENSE_OPERATION_SETS
+ *  (ledger2/operations.hpp) — подключение нового пула не меняет контракт;
+ *  механика оплаты per-item (ADVANCE | DIRECT) выбирает код внутри набора;
+ *  callback на финализацию (контракт+action+data) сохраняется при createexp
+ *  как переменная — `expense` агностичен к программе-получателю.
+ *
+ *  See: components/desktop/extensions/expenses/NAMING-C28-28.md (v3).
+ */
+
+namespace ExpenseDomain {
+
+  /**
+   * @brief Способ оплаты item-а в СЗ.
+   *   ADVANCE — пайщик-получатель оплачивает, затем приносит чек.
+   *   DIRECT  — кассир/председатель платит организации напрямую.
+   */
+  enum class Mechanics : uint8_t {
+    ADVANCE = 0,
+    DIRECT  = 1,
+  };
+
+  /**
+   * @brief Получатель платежа в item-е.
+   *   SELF    — сам создатель СЗ.
+   *   MEMBER  — другой пайщик.
+   *   ORG     — внешняя организация.
+   */
+  enum class RecipientType : uint8_t {
+    SELF   = 0,
+    MEMBER = 1,
+    ORG    = 2,
+  };
+
+  enum class ProposalStatus : uint8_t {
+    CREATED          = 0,  ///< СЗ создан, ждёт подписи signact1 создателя.
+    AUTHORIZED       = 1,  ///< СЗ подписан signact2 (совет), готов к оплате.
+    PARTIALLY_PAID   = 2,  ///< Часть item-ов оплачена.
+    REPORT_SUBMITTED = 3,  ///< Отчёт о расходе подан, ждёт авторизации совета.
+    CLOSED           = 4,  ///< СЗ-отчёт авторизован — расход закрыт.
+    DECLINED         = 5,  ///< СЗ отклонён до или после авторизации.
+  };
+
+  enum class ItemStatus : uint8_t {
+    APPROVED  = 0,  ///< Запланирован, ждёт оплаты.
+    PAID      = 1,  ///< Оплачен (ADVANCE — выдан пайщику; DIRECT — оплачен организации).
+    REPORTED  = 2,  ///< Закрыт отчётом (чек приложен). DIRECT-item получает его сразу при payexp.
+    RETURNED  = 3,  ///< Зарезервировано, не используется: returnexp уменьшает actual_amount, статус остаётся PAID до отчёта.
+    OVERSPENT = 4,  ///< Зарезервировано, не используется: overspendexp увеличивает actual_amount, статус остаётся PAID до отчёта.
+  };
+
+  /**
+   * @brief Callback на финализацию — устанавливается при createexp как переменная.
+   *
+   * Контракт expense не знает про capital/blagorost — он просто вызывает inline
+   * action на (contract, action) и прокидывает data наружу. Пустой contract = нет callback.
+   *
+   * Пример: для расхода в РИД-проект Благороста UI/backend заполняет
+   * { "capital"_n, "onexpreport"_n, packed(wip_project_hash) }.
+   */
+  struct callback_handler {
+    eosio::name        contract;
+    eosio::name        action;
+    std::vector<char>  data;
+    EOSLIB_SERIALIZE(callback_handler, (contract)(action)(data))
+  };
+
+  /**
+   * @brief Item — одна строка СЗ-расхода.
+   */
+  struct item {
+    eosio::checksum256 item_hash;
+    uint8_t            mechanics;         ///< Mechanics
+    uint8_t            recipient_type;    ///< RecipientType
+    eosio::name        recipient;         ///< username (для SELF/MEMBER), либо name-идентификатор (для ORG)
+    std::string        description;
+    eosio::asset       planned_amount;
+    eosio::asset       actual_amount;     ///< 0 пока не оплачено / не отчиталось
+    uint8_t            status;            ///< ItemStatus
+
+    EOSLIB_SERIALIZE(item, (item_hash)(mechanics)(recipient_type)(recipient)(description)(planned_amount)(actual_amount)(status))
+  };
+
+  /**
+   * @brief Таблица СЗ-расходов. Scope = coopname.
+   */
+  struct [[eosio::table, eosio::contract("expense")]] proposal {
+    uint64_t              id;
+    eosio::name           coopname;       ///< кооператив (= scope таблицы; дублируем полем по канону)
+    eosio::checksum256    proposal_hash;
+    eosio::name           username;       ///< создатель
+    eosio::name           source_wallet;  ///< семантически — из какого ЦПП/фонда (w.cap.blago, w.sov.expns, …)
+    uint8_t               status;         ///< ProposalStatus
+    std::vector<item>     items;
+    eosio::asset          total_planned;
+    eosio::asset          total_actual;
+    callback_handler      callback;       ///< опционально; contract.value == 0 = нет callback
+    document2             statement_doc;  ///< type=2010, signact1 создателя
+    document2             decision_doc;   ///< type=2011, signact2 совета
+    eosio::time_point_sec created_at;
+    eosio::time_point_sec updated_at;
+
+    uint64_t primary_key()      const { return id; }
+    eosio::checksum256 by_hash() const { return proposal_hash; }
+    uint64_t by_username()      const { return username.value; }
+    uint64_t by_status()        const { return static_cast<uint64_t>(status); }
+
+    EOSLIB_SERIALIZE(proposal,
+      (id)(coopname)(proposal_hash)(username)(source_wallet)(status)
+      (items)(total_planned)(total_actual)(callback)(statement_doc)(decision_doc)
+      (created_at)(updated_at))
+  };
+
+  using proposals_index = eosio::multi_index<"proposals"_n, proposal,
+    eosio::indexed_by<"byhash"_n,     eosio::const_mem_fun<proposal, eosio::checksum256, &proposal::by_hash>>,
+    eosio::indexed_by<"byusername"_n, eosio::const_mem_fun<proposal, uint64_t, &proposal::by_username>>,
+    eosio::indexed_by<"bystatus"_n,   eosio::const_mem_fun<proposal, uint64_t, &proposal::by_status>>
+  >;
+
+} // namespace ExpenseDomain
+
+/**
+ *  @ingroup public_contracts
+ *  @brief Шасси расходов — 8 actions, MVP только Благорост.
+ */
+class [[eosio::contract("expense")]] expense : public contract {
+public:
+    using contract::contract;
+
+    /**
+     * @brief Создать и подать СЗ-расход.
+     *
+     * Создание и подача — одна транзакция (slug createexp). На входе: items + источник
+     * (source_wallet) + опц. callback на финализацию.
+     * Подписывает создатель (signact1 statement_doc, type=2010).
+     *
+     * Авторизация: coopname (прямой вызов backend'а) либо контракт-инициатор из
+     * contracts_whitelist (inline, например capital::createpgexp).
+     * Механика оплаты — per-item (item.mechanics: ADVANCE | DIRECT); ledger2-код
+     * операции выводится из механики позиции в момент оплаты payexp.
+     *
+     * Ставит вопрос в повестку совета (soviet::createagenda, тип createexp):
+     * утверждение совета → callback authexp, отклонение → declexp.
+     */
+    [[eosio::action]]
+    void createexp(name coopname, name username,
+                   checksum256 proposal_hash,
+                   name source_wallet,
+                   std::vector<ExpenseDomain::item> items,
+                   ExpenseDomain::callback_handler callback,
+                   document2 statement);
+
+    /**
+     * @brief Авторизовать СЗ советом (signact2 decision_doc, type=2011).
+     * Callback решения совета — вызывается только контрактом soviet после
+     * голосования и утверждения председателем. После этого расход доступен для оплаты.
+     */
+    [[eosio::action]]
+    void authexp(name coopname, checksum256 proposal_hash, document2 decision);
+
+    /**
+     * @brief Отклонить СЗ. Callback решения совета (отрицательный консенсус
+     * голосов «против» либо просрочка повестки) — вызывается только контрактом
+     * soviet. Возможно только до первой оплаты (CREATED / AUTHORIZED):
+     * после payexp средства уже ушли через ledger2, и СЗ завершается обычным
+     * путём reportexp / returnexp → closeexp.
+     */
+    [[eosio::action]]
+    void declexp(name coopname, checksum256 proposal_hash, std::string reason);
+
+    /**
+     * @brief Оплатить item — выдача аванса (ADVANCE) или прямая оплата организации (DIRECT).
+     * Контракт зовёт Ledger2::apply с кодом из набора операций кошелька-источника
+     * (EXPENSE_OPERATION_SETS: source_wallet + механика item'а → operation_code).
+     * actual_amount не может превышать план item (доплата — через overspendexp).
+     * DIRECT-item не имеет фазы подотчёта и помечается REPORTED сразу; когда все
+     * items REPORTED — proposal переходит в REPORT_SUBMITTED прямо из payexp.
+     */
+    [[eosio::action]]
+    void payexp(name coopname, checksum256 proposal_hash, checksum256 item_hash,
+                asset actual_amount);
+
+    /**
+     * @brief Отчёт о расходе (ADVANCE) — пайщик закрывает item чеком.
+     * Зовёт Ledger2::apply(o.exp.advrpt) на остаточный actual item'а (при полном
+     * возврате аванса burn пропускается). Когда все items reported — статус
+     * proposal становится REPORT_SUBMITTED.
+     */
+    [[eosio::action]]
+    void reportexp(name coopname, checksum256 proposal_hash, checksum256 item_hash);
+
+    /**
+     * @brief Закрытие расхода советом — финальный signact2 СЗ-отчёта.
+     * Если у proposal заполнен callback — отправляет inline action на (callback.contract, callback.action, callback.data).
+     */
+    [[eosio::action]]
+    void closeexp(name coopname, checksum256 proposal_hash);
+
+    /**
+     * @brief Возврат неиспользованного аванса (ADVANCE-остаток).
+     * Settlement-запись: уменьшает actual_amount item'а, статус остаётся PAID —
+     * фактически потраченная часть закрывается затем штатным reportexp.
+     * Зовёт Ledger2::apply(o.exp.advret).
+     */
+    [[eosio::action]]
+    void returnexp(name coopname, checksum256 proposal_hash, checksum256 item_hash,
+                   asset return_amount);
+
+    /**
+     * @brief Доплата при перерасходе (ADVANCE).
+     * Settlement-запись: увеличивает actual_amount item'а, статус остаётся PAID.
+     * Зовёт Ledger2::apply(o.exp.over) — выдача доплаты; закрытие подотчёта на
+     * полную сумму (выдано + доплата) делает последующий reportexp.
+     */
+    [[eosio::action]]
+    void overspendexp(name coopname, checksum256 proposal_hash, checksum256 item_hash,
+                      asset overspend_amount);
+};

components/contracts/cpp/lib/consts.hpp

@@ -85,7 +85,8 @@ static constexpr eosio::name _capital_program = "blagorost"_n; ///< Кошелё
 
 static const std::set<eosio::name> soviet_actions = {
     "joincoop"_n, //регистрация пайщика
-    
+    "leavecoop"_n, //выход пайщика из кооператива (возврат паевого взноса)
+
     //MEET
     "creategm"_n,//предложение повестки планового общего собрание
     "completegm"_n, //решение общего собрания пайщиков
@@ -102,7 +103,10 @@ static const std::set<eosio::name> soviet_actions = {
 
     //WALLET
     "createwthd"_n, //создать заявление на возврат паевого взноса
-    
+
+    //EXPENSE
+    "createexp"_n, //служебная записка-смета о расходах (шасси расходов)
+
     //LEDGER
     "ledgerwthd"_n, //заявление на списание со счета через ledger
     
@@ -165,6 +169,7 @@ static constexpr uint64_t _capital_program_id = 4;
     static constexpr eosio::name _ledger = "ledger"_n;
     static constexpr eosio::name _ledger2 = "ledger2"_n;
     static constexpr eosio::name _apps = "apps"_n;
+    static constexpr eosio::name _expense = "expense"_n;
     static constexpr eosio::name _power_account = "eosio.power"_n;
     static constexpr eosio::name _saving_account = "eosio.saving"_n;
     
@@ -193,7 +198,8 @@ static constexpr uint64_t _capital_program_id = 4;
         "ledger"_n,
         "ledger2"_n,
         "capital"_n,
-        "apps"_n
+        "apps"_n,
+        "expense"_n
         // Добавьте остальные стандартные или пользовательские контракты по необходимости
       };
 

components/contracts/cpp/lib/core/ledger2/operations.hpp

@@ -61,6 +61,7 @@ namespace operations {
     inline constexpr eosio::name SETTLE_MINSHARE = "o.reg.setmin"_n; ///< Зачисление минимального паевого по решению совета (Dr 76 / Cr 80, TRANSFER REGISTRATION_PENDING → MIN_SHARE_FUND).
     inline constexpr eosio::name SETTLE_ENTRANCE = "o.reg.setent"_n; ///< Зачисление вступительного по решению совета (Dr 76 / Cr 86, TRANSFER REGISTRATION_PENDING → ENTRANCE_FEES).
     inline constexpr eosio::name REFUND          = "o.reg.refund"_n; ///< Возврат регистрационного взноса при отказе совета (Dr 76 / Cr 51, BURN REGISTRATION_PENDING — деньги уходят из системы банковским переводом кандидату).
+    inline constexpr eosio::name MOVE_MINSHARE   = "o.reg.mvmin"_n;  ///< Перенос минимального паевого на главный паевой при выходе из кооператива (TRANSFER MIN_SHARE_FUND → SHARE_FUND_PAY, без Dr/Cr — оба кошелька на счёте 80). Готовит полный паевой к возврату.
   }
 
   // wallet
@@ -85,6 +86,7 @@ namespace operations {
     inline constexpr eosio::name WITHDRAW_FROM_CAPITAL = "o.cap.wthcap"_n; ///< Возврат паевого из ЦПП «Благорост» в кошелёк пайщика (TRANSFER BLAGOROST_FUND → SHARE_FUND_PAY, без Dr/Cr).
     inline constexpr eosio::name CONVERT_TO_SHARE    = "o.cap.cnvshr"_n;   ///< Конвертация сегмента: РИД → главный кошелёк (TRANSFER GENERATOR_FUND → SHARE_FUND_PAY, без Dr/Cr — бухпроводка уже была сделана в ACCEPT_RID).
     inline constexpr eosio::name CONVERT_TO_BLAGO    = "o.cap.cnvbl"_n;    ///< Конвертация сегмента: РИД → ЦПП «Благорост» (TRANSFER GENERATOR_FUND → BLAGOROST_FUND, без Dr/Cr — бухпроводка уже была сделана в ACCEPT_RID).
+    inline constexpr eosio::name PROGRAM_EXPENSE_TOPUP = "o.cap.pgtop"_n; ///< Пополнение пула программных расходов из инвестиций программы (ISSUE PROGRAM_EXPENSE_POOL, без Dr/Cr — деньги уже на 51, выделяется кооперативный резерв под расходы; паевые L3-кошельки пайщиков не трогаются).
   }
 
   // marketplace
@@ -98,6 +100,27 @@ namespace operations {
     inline constexpr eosio::name CONVERT_AXN      = "o.sov.axncnv"_n;   ///< Трансляция паевого взноса в членский (Dr 80 / Cr 86, TRANSFER SHARE_FUND_PAY → DELEGATE_FEES).
   }
 
+  // expense — шасси расходов (MVP: только Благорост; хозрасходы из членских — отдельный эпик).
+  //
+  // Принципы (см. components/desktop/extensions/expenses/NAMING-C28-28.md):
+  //   - Контракт `expense` универсальный: operation_code передаётся в payload.
+  //   - Источник оплат — КООПЕРАТИВНЫЙ пул расходов (PROGRAM_EXPENSE_POOL),
+  //     пополняемый o.cap.pgtop; личные L3-кошельки пайщиков (w.cap.blago)
+  //     при оплатах СЗ не изменяются.
+  //   - При расходе из Благороста паевой фонд (80) НЕ трогается: меняется только форма
+  //     актива 51 → 08 (Дт 08 / Кт 51 для обеих механик).
+  //   - ADVANCE-отчёт (`o.exp.advrpt`) НЕ создаёт новой бухпроводки: проводка уже
+  //     сделана на `o.exp.blgadv` при выдаче.
+  //   - Callback на финализацию — переменная (`callback{contract, action, data}`),
+  //     заполняется при `expense::createexp`; expense ничего не знает про capital.
+  namespace expense {
+    inline constexpr eosio::name BLAGO_ADVANCE    = "o.exp.blgadv"_n;   ///< Выдача подотчётных из пула расходов (TRANSFER PROGRAM_EXPENSE_POOL → ADVANCE_HOLD, Dr 08 / Cr 51).
+    inline constexpr eosio::name BLAGO_DIRECT     = "o.exp.blgdir"_n;   ///< Прямая оплата из пула расходов (BURN PROGRAM_EXPENSE_POOL, Dr 08 / Cr 51).
+    inline constexpr eosio::name ADVANCE_REPORT   = "o.exp.advrpt"_n;   ///< Закрытие подотчёта пайщика (BURN ADVANCE_HOLD, без бухпроводки — canal 08/51 уже сделан на blgadv).
+    inline constexpr eosio::name ADVANCE_RETURN   = "o.exp.advret"_n;   ///< Возврат неиспользованного подотчёта (TRANSFER ADVANCE_HOLD → PROGRAM_EXPENSE_POOL, Dr 51 / Cr 08).
+    inline constexpr eosio::name OVERSPEND        = "o.exp.over"_n;     ///< Доплата сверх подотчёта (TRANSFER PROGRAM_EXPENSE_POOL → ADVANCE_HOLD, Dr 08 / Cr 51); сразу за ней expense вызывает ADVANCE_REPORT.
+  }
+
   // migration (только из migrate.cpp)
   //
   // В OPERATION_REGISTRY включены **только** те транзиты, которые проводятся
@@ -220,6 +243,15 @@ static constexpr OperationRegistryEntry OPERATION_REGISTRY[] = {
     ledger2_accounts::PARTICIPANT_SETTLEMENTS, ledger2_accounts::BANK_ACCOUNT,
     "Возврат регистрационного взноса при отказе совета" },
 
+  // 2e. Перенос минимального паевого на главный при выходе из кооператива:
+  // TRANSFER MIN_SHARE_FUND → SHARE_FUND_PAY (без Dr/Cr — оба кошелька на счёте 80).
+  // Консолидирует минимальный паевой на главный, чтобы вернуть его вместе с
+  // основным паевым через wallet-withdraw (o.wal.wthcpl, Дт 80 / Кт 51).
+  { operations::registrator::MOVE_MINSHARE, processes::wallet::WITHDRAW, WalletOp::TRANSFER,
+    ledger2_wallets::MIN_SHARE_FUND, ledger2_wallets::SHARE_FUND_PAY,
+    0, 0,
+    "Перенос минимального паевого на главный при выходе из кооператива" },
+
   // 3. Внесение паевого взноса: Dr 51 / Cr 80, ISSUE SHARE_FUND_PAY
   { operations::wallet::COMPLETE_DEPOSIT, processes::wallet::DEPOSIT, WalletOp::ISSUE, eosio::name{}, ledger2_wallets::SHARE_FUND_PAY,
     ledger2_accounts::BANK_ACCOUNT, ledger2_accounts::SHARE_FUND,
@@ -352,6 +384,72 @@ static constexpr OperationRegistryEntry OPERATION_REGISTRY[] = {
     0, 0,
     "Конвертация сегмента: РИД → ЦПП «Благорост»" },
 
+  // 19a. Пополнение пула программных расходов: ISSUE PROGRAM_EXPENSE_POOL, без Dr/Cr.
+  // Совет выделяет часть свободных инвестиций программы под целевые расходы:
+  // деньги физически на 51 с момента взносов, здесь появляется кооперативный
+  // резерв-кошелёк, из которого шасси expense оплачивает СЗ. Паевые L3-кошельки
+  // пайщиков (w.cap.blago, счёт 80) не изменяются — права требования сохраняются.
+  { operations::capital::PROGRAM_EXPENSE_TOPUP, processes::capital::PGEXP, WalletOp::ISSUE,
+    eosio::name{}, ledger2_wallets::PROGRAM_EXPENSE_POOL,
+    0, 0,
+    "Пополнение пула программных расходов ЦПП «Благорост»" },
+
+  // ----- Шасси расходов (o.exp.*) — вызываются из контракта expense -----
+  //
+  // Базовое состояние Благороста ДО расхода:
+  //   - Деньги физически на 51 с момента o.wal.depcpl (Dr 51 / Cr 80).
+  //   - 80 (паевой) наполнен; кошелёк w.cap.blago.
+  //   - 08 пустой (`o.cap.invest` — TRANSFER без проводок).
+  //
+  // Принцип: расход не уменьшает паевой фонд (80). Меняется только форма актива
+  // 51 → 08 (банк уходит, появляется WIP-проект).
+
+  // 20. Выдача подотчётных из пула программных расходов: Dr 08 / Cr 51,
+  // TRANSFER PROGRAM_EXPENSE_POOL → ADVANCE_HOLD.
+  // Источник — КООПЕРАТИВНЫЙ пул расходов (пополняется o.cap.pgtop); личные
+  // L3-кошельки пайщиков (w.cap.blago) при оплате СЗ не трогаются — их паевые
+  // взносы в программе не уменьшаются. Деньги физически уходят пайщику (Cr 51),
+  // стоимость капитализируется в WIP (Dr 08). ADVANCE_HOLD фиксирует
+  // ответственность получателя аванса (USER_SHARED) до отчёта.
+  { operations::expense::BLAGO_ADVANCE, processes::expense::PROPOSAL, WalletOp::TRANSFER,
+    ledger2_wallets::PROGRAM_EXPENSE_POOL, ledger2_wallets::ADVANCE_HOLD,
+    ledger2_accounts::NON_CURRENT_INVESTMENTS, ledger2_accounts::BANK_ACCOUNT,
+    "Выдача подотчётных из пула расходов ЦПП «Благорост»" },
+
+  // 21. Прямая оплата из пула программных расходов (DIRECT): Dr 08 / Cr 51,
+  // BURN PROGRAM_EXPENSE_POOL. Оплата организации по счёту; деньги уходят с 51,
+  // стоимость капитализируется в 08. Кошелёк-резерв не задействован.
+  { operations::expense::BLAGO_DIRECT, processes::expense::PROPOSAL, WalletOp::BURN,
+    ledger2_wallets::PROGRAM_EXPENSE_POOL, eosio::name{},
+    ledger2_accounts::NON_CURRENT_INVESTMENTS, ledger2_accounts::BANK_ACCOUNT,
+    "Прямая оплата из пула расходов ЦПП «Благорост»" },
+
+  // 22. Закрытие подотчёта пайщика по отчёту: BURN ADVANCE_HOLD, БЕЗ бухпроводки.
+  // Проводка Dr 08 / Cr 51 уже сделана на BLAGO_ADVANCE при выдаче. При отчёте только
+  // снимается кошелёк-резерв пайщика — никакого canal 08/51 второй раз.
+  { operations::expense::ADVANCE_REPORT, processes::expense::PROPOSAL, WalletOp::BURN,
+    ledger2_wallets::ADVANCE_HOLD, eosio::name{},
+    0, 0,
+    "Закрытие подотчёта пайщика по отчёту" },
+
+  // 23. Возврат неиспользованного подотчёта: Dr 51 / Cr 08,
+  // TRANSFER ADVANCE_HOLD → PROGRAM_EXPENSE_POOL.
+  // Зеркало BLAGO_ADVANCE: деньги возвращаются на 51, WIP-стоимость уменьшается,
+  // остаток снова доступен пулу расходов.
+  { operations::expense::ADVANCE_RETURN, processes::expense::PROPOSAL, WalletOp::TRANSFER,
+    ledger2_wallets::ADVANCE_HOLD, ledger2_wallets::PROGRAM_EXPENSE_POOL,
+    ledger2_accounts::BANK_ACCOUNT, ledger2_accounts::NON_CURRENT_INVESTMENTS,
+    "Возврат неиспользованного подотчёта в пул расходов" },
+
+  // 24. Доплата сверх подотчёта (перерасход): Dr 08 / Cr 51,
+  // TRANSFER PROGRAM_EXPENSE_POOL → ADVANCE_HOLD.
+  // Зеркало BLAGO_ADVANCE на сумму перерасхода. Контракт expense сразу за OVERSPEND
+  // вызывает ADVANCE_REPORT — две последовательные записи в одной транзакции `expense::overspendexp`.
+  { operations::expense::OVERSPEND, processes::expense::PROPOSAL, WalletOp::TRANSFER,
+    ledger2_wallets::PROGRAM_EXPENSE_POOL, ledger2_wallets::ADVANCE_HOLD,
+    ledger2_accounts::NON_CURRENT_INVESTMENTS, ledger2_accounts::BANK_ACCOUNT,
+    "Доплата сверх подотчёта (перерасход)" },
+
   // ----- Миграционные (o.mig.*) — вызываются только из migrate.cpp -----
 
   // 15. Миграция: минимальный паевой: Dr 51 / Cr 80, ISSUE MIN_SHARE_FUND
@@ -534,3 +632,105 @@ inline constexpr const OperationAdjustmentEntry* find_adjustment(eosio::name ope
   }
   return nullptr;
 }
+
+// =====================================================================
+// Наборы операций шасси расходов — фабричная настройка контракта expense.
+// =====================================================================
+//
+// Контракт `expense` агностичен к программе-источнику: кошелёк-пул приходит в
+// `createexp` параметром `source_wallet`, а ledger2-коды всех пяти операций
+// жизненного цикла (аванс / прямая оплата / отчёт / возврат / перерасход)
+// выводятся из этого кошелька через таблицу ниже — в коде expense нет ни
+// одного захардкоженного operation_code.
+//
+// Подключение шасси к новому пулу (например, кошельку членских взносов
+// кооперативного участка) = добавить 5 операций в OPERATION_REGISTRY и одну
+// строку здесь. Контракт expense при этом не меняется.
+struct ExpenseOperationSet {
+  eosio::name source_wallet;  ///< пул-источник средств (COOPERATIVE-кошелёк)
+  eosio::name advance;        ///< выдача аванса под отчёт (TRANSFER pool → подотчёт)
+  eosio::name direct;         ///< прямая оплата организации по счёту (BURN pool)
+  eosio::name report;         ///< закрытие подотчёта по отчёту (BURN подотчёта)
+  eosio::name refund;         ///< возврат неиспользованного аванса (TRANSFER подотчёт → pool)
+  eosio::name overspend;      ///< доплата при перерасходе (TRANSFER pool → подотчёт)
+};
+
+static constexpr ExpenseOperationSet EXPENSE_OPERATION_SETS[] = {
+  // Пул программных расходов ЦПП «Благорост» — source_wallet заполняет
+  // capital::createpgexp при создании СЗ через inline expense::createexp.
+  { ledger2_wallets::PROGRAM_EXPENSE_POOL,
+    operations::expense::BLAGO_ADVANCE,
+    operations::expense::BLAGO_DIRECT,
+    operations::expense::ADVANCE_REPORT,
+    operations::expense::ADVANCE_RETURN,
+    operations::expense::OVERSPEND },
+};
+
+static constexpr size_t EXPENSE_OPERATION_SETS_SIZE =
+  sizeof(EXPENSE_OPERATION_SETS) / sizeof(EXPENSE_OPERATION_SETS[0]);
+
+// Compile-time валидация наборов: каждый код существует в OPERATION_REGISTRY,
+// тип wallet-операции и привязка кошельков соответствуют роли кода в наборе.
+namespace ledger2_expense_sets_detail {
+  constexpr const OperationRegistryEntry* find_op(eosio::name code) {
+    for (size_t i = 0; i < OPERATION_REGISTRY_SIZE; ++i) {
+      if (OPERATION_REGISTRY[i].code == code) return &OPERATION_REGISTRY[i];
+    }
+    return nullptr;
+  }
+
+  constexpr bool source_wallets_unique() {
+    for (size_t i = 0; i < EXPENSE_OPERATION_SETS_SIZE; ++i) {
+      for (size_t j = i + 1; j < EXPENSE_OPERATION_SETS_SIZE; ++j) {
+        if (EXPENSE_OPERATION_SETS[i].source_wallet == EXPENSE_OPERATION_SETS[j].source_wallet) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  constexpr bool sets_consistent() {
+    for (size_t i = 0; i < EXPENSE_OPERATION_SETS_SIZE; ++i) {
+      const auto& s = EXPENSE_OPERATION_SETS[i];
+      const auto* adv = find_op(s.advance);
+      const auto* dir = find_op(s.direct);
+      const auto* rep = find_op(s.report);
+      const auto* ref = find_op(s.refund);
+      const auto* ovr = find_op(s.overspend);
+      if (!adv || !dir || !rep || !ref || !ovr) return false;
+      // Аванс: пул → кошелёк-подотчёт.
+      if (adv->wallet_op != WalletOp::TRANSFER || adv->wallet_from != s.source_wallet) return false;
+      const eosio::name hold = adv->wallet_to;
+      // Прямая оплата: сжигание с пула (подотчёт не задействован).
+      if (dir->wallet_op != WalletOp::BURN || dir->wallet_from != s.source_wallet) return false;
+      // Отчёт: сжигание подотчёта.
+      if (rep->wallet_op != WalletOp::BURN || rep->wallet_from != hold) return false;
+      // Возврат: подотчёт → пул.
+      if (ref->wallet_op != WalletOp::TRANSFER ||
+          ref->wallet_from != hold || ref->wallet_to != s.source_wallet) return false;
+      // Перерасход: пул → подотчёт (зеркало аванса на сумму доплаты).
+      if (ovr->wallet_op != WalletOp::TRANSFER ||
+          ovr->wallet_from != s.source_wallet || ovr->wallet_to != hold) return false;
+    }
+    return true;
+  }
+} // namespace ledger2_expense_sets_detail
+
+static_assert(ledger2_expense_sets_detail::source_wallets_unique(),
+              "EXPENSE_OPERATION_SETS: source_wallet должен быть уникален");
+static_assert(ledger2_expense_sets_detail::sets_consistent(),
+              "EXPENSE_OPERATION_SETS: набор операций не согласован с OPERATION_REGISTRY "
+              "(коды/типы wallet-операций/привязка кошельков)");
+
+/**
+ * @brief Поиск набора операций шасси расходов по кошельку-источнику.
+ */
+inline const ExpenseOperationSet* find_expense_operation_set(eosio::name source_wallet) {
+  for (size_t i = 0; i < EXPENSE_OPERATION_SETS_SIZE; ++i) {
+    if (EXPENSE_OPERATION_SETS[i].source_wallet == source_wallet) {
+      return &EXPENSE_OPERATION_SETS[i];
+    }
+  }
+  return nullptr;
+}

components/contracts/cpp/lib/core/ledger2/processes.hpp

@@ -54,6 +54,7 @@ namespace processes {
     inline constexpr eosio::name PROPERTY  = "p.cap.prop"_n;     ///< Приём имущественного паевого взноса (одноактовый).
     inline constexpr eosio::name PREIMP    = "p.cap.preimp"_n;   ///< Первичный учёт РИД-взноса до перехода на электронный учёт (одноактовый, anchor = preimp register hash).
     inline constexpr eosio::name WTHCAP    = "p.cap.wthcap"_n;   ///< Возврат паевого из ЦПП «Благорост» в кошелёк пайщика (одноактовый).
+    inline constexpr eosio::name PGEXP     = "p.cap.pgexp"_n;    ///< Пул программных расходов: пополнение из инвестиций программы (o.cap.pgtop, одноактовый).
   }
 
   // marketplace
@@ -61,6 +62,11 @@ namespace processes {
     inline constexpr eosio::name REQUEST   = "p.mkt.reqst"_n;    ///< Цикл запроса маркетплейса (o.mkt.supply + o.mkt.recv).
   }
 
+  // expense — шасси расходов (СЗ → авторизация → платёж → отчёт → закрытие)
+  namespace expense {
+    inline constexpr eosio::name PROPOSAL  = "p.exp.expns"_n;    ///< Цикл расхода по СЗ: o.exp.blgadv|blgdir (платёж) + опц. o.exp.over (перерасход) + o.exp.advrpt (отчёт ADVANCE) + опц. o.exp.advret (возврат). Анкер процесса — proposal_hash.
+  }
+
   // soviet
   namespace soviet {
     inline constexpr eosio::name AXN_CONVERT = "p.sov.axncnv"_n; ///< Конвертация паевого RUB → делегатский ЧВ (одноактовый).

components/contracts/cpp/lib/core/ledger2/wallets.hpp

@@ -65,9 +65,16 @@ struct ledger2_wallets {
   static constexpr eosio::name BLAGOROST_FUND       = "w.cap.blago"_n;   ///< Благорост — единый агрегированный кошелёк программы (USER_SHARED; ADR-009)
   static constexpr eosio::name GENERATOR_FUND       = "w.cap.gen"_n;     ///< Генератор — единый агрегированный кошелёк программы (COOPERATIVE — кооперативный пул, без L3-разреза по пайщику; L3-разрез из ADR-009 отменён из-за несовместимости с CRPS-перераспределением, см. wallets.hpp:107)
   static constexpr eosio::name PREIMP_FUND          = "w.cap.preimp"_n;  ///< Первичный учёт РИД-взносов до перехода на электронный учёт (USER_SHARED; o.cap.preimp / o.cap.drppre)
+  static constexpr eosio::name PROGRAM_EXPENSE_POOL = "w.cap.pgexp"_n;   ///< Пул программных расходов ЦПП «Благорост» (COOPERATIVE) — кооперативный кошелёк, из которого шасси expense оплачивает СЗ; пополняется topupprogexp (o.cap.pgtop), паевые L3-кошельки пайщиков (w.cap.blago) при расходах не трогаются
 
   // marketplace — выплаты
   static constexpr eosio::name SUPPLIER_PAYMENTS    = "w.mkt.payout"_n;  ///< Выплаты поставщикам (sink RECEIVE_CONFIRM, COOPERATIVE)
+
+  // expense — шасси расходов (подотчёт пайщика, USER_SHARED)
+  // Зеркало паттерна w.wal.wpend: кошелёк-резерв на пайщике-получателе ADVANCE-механики.
+  // На момент выдачи аванса фиксирует ответственность пайщика; на отчёте — BURN без новой бухпроводки
+  // (canal Дт 08 / Кт 51 уже сделан на o.exp.blgadv).
+  static constexpr eosio::name ADVANCE_HOLD         = "w.exp.adv"_n;     ///< Подотчётные средства пайщика (USER_SHARED; резерв при ADVANCE-механике шасси расходов)
 };
 
 /**
@@ -96,16 +103,17 @@ struct Ledger2WalletMeta {
   WalletKind       kind;
 };
 
-inline constexpr std::array<Ledger2WalletMeta, 16> LEDGER2_WALLET_REGISTRY = {{
-  // USER_SHARED (6) — L3-разрез по пайщику
+inline constexpr std::array<Ledger2WalletMeta, 18> LEDGER2_WALLET_REGISTRY = {{
+  // USER_SHARED (7) — L3-разрез по пайщику
   { ledger2_wallets::MIN_SHARE_FUND,    "Минимальный паевой взнос",                                 WalletKind::USER_SHARED },
   { ledger2_wallets::SHARE_FUND_PAY,    "Паевой взнос пайщика",                                     WalletKind::USER_SHARED },
   { ledger2_wallets::CK_MEMBER,         "ЦК — членская часть пайщика",                              WalletKind::USER_SHARED },
   { ledger2_wallets::BLAGOROST_FUND,    "ЦПП «Благорост» — единый кошелёк программы у пайщика",     WalletKind::USER_SHARED },
   { ledger2_wallets::PREIMP_FUND,       "Первичный учёт РИД-взносов до перехода на электронный учёт", WalletKind::USER_SHARED },
+  { ledger2_wallets::ADVANCE_HOLD,      "Подотчётные средства пайщика",                             WalletKind::USER_SHARED },
   { ledger2_wallets::REGISTRATION_PENDING, "Регистрационный взнос в ожидании решения совета",       WalletKind::USER_SHARED },
 
-  // COOPERATIVE (10) — единый кооперативный баланс, без L3
+  // COOPERATIVE (10) — единый кооперативный баланс, без L3 (Generator + 9 «единых пулов»)
   // GENERATOR_FUND переведён сюда из USER_SHARED (см. wallets.hpp:64) —
   // CRPS-распределение между сегментами проекта не поддерживает per-user
   // компенсирующие TRANSFER на approvecmmt, поэтому L3-проверка walletop
@@ -120,6 +128,7 @@ inline constexpr std::array<Ledger2WalletMeta, 16> LEDGER2_WALLET_REGISTRY = {{
   { ledger2_wallets::MIN_SHARE_USED,    "Использованные минимальные паевые взносы",                 WalletKind::COOPERATIVE },
   { ledger2_wallets::LOAN_ISSUED,       "Выданные пайщикам беспроцентные займы",                    WalletKind::COOPERATIVE },
   { ledger2_wallets::SUPPLIER_PAYMENTS, "Выплаты поставщикам",                                      WalletKind::COOPERATIVE },
+  { ledger2_wallets::PROGRAM_EXPENSE_POOL, "Пул программных расходов ЦПП «Благорост»",              WalletKind::COOPERATIVE },
 }};
 
 static constexpr size_t LEDGER2_WALLET_REGISTRY_SIZE = LEDGER2_WALLET_REGISTRY.size();
@@ -232,16 +241,48 @@ struct Ledger2WalletProgramMapping {
   uint64_t    required_program_id; // 0 = исключение (без проверки)
 };
 
-inline constexpr std::array<Ledger2WalletProgramMapping, 7> LEDGER2_USER_SHARED_PROGRAM_MAPPING = {{
+inline constexpr std::array<Ledger2WalletProgramMapping, 8> LEDGER2_USER_SHARED_PROGRAM_MAPPING = {{
   { ledger2_wallets::MIN_SHARE_FUND,    0 /* w.reg.minshr — без проверки */    },
   { ledger2_wallets::SHARE_FUND_PAY,    1 /* ЦК */                              },
   { ledger2_wallets::CK_MEMBER,         1 /* ЦК */                              },
   { ledger2_wallets::BLAGOROST_FUND,    4 /* Благорост */                       },
   { ledger2_wallets::GENERATOR_FUND,    3 /* Генератор */                       },
   { ledger2_wallets::PREIMP_FUND,       0 /* w.cap.preimp — РИД-учёт до перехода на электронный учёт, без проверки */ },
+  { ledger2_wallets::ADVANCE_HOLD,      0 /* w.exp.adv — подотчёт пайщика по СЗ; программа-источник проверена контрактом expense, повторная gate не нужна */ },
   { ledger2_wallets::REGISTRATION_PENDING, 0 /* w.reg.pend — кандидат ещё не член, соглашения нет, без проверки */ },
 }};
 
+/**
+ * @brief Сет «боевых» (паевых) кошельков пайщика, возвращаемых при выходе из
+ * кооператива (заявление registry 200 → одобрение совета `confirmexit`).
+ *
+ * Единый источник истины для суммы возврата. При одобрении выхода советом
+ * `registrator::confirmexit` обходит этот сет в цикле, аккумулирует доступный
+ * L3-баланс пайщика по каждому кошельку (>0), консолидирует на главный паевой
+ * (`w.wal.share`) и ставит всю сумму на возврат единым платежом. Тот же сет
+ * генерируется в cooptypes (`gen:from-cpp` → `wallets.generated.ts`) и
+ * используется backend-preview, поэтому расчёт на фронте всегда совпадает с
+ * тем, что реально вернёт контракт.
+ *
+ * Состав — только паевые/возвратные USER_SHARED-кошельки:
+ *   w.reg.minshr — минимальный паевой взнос;
+ *   w.wal.share  — целевой паевой взнос (ЦК);
+ *   w.cap.blago  — паевой взнос в ЦПП «Благорост».
+ *
+ * НЕ входят: w.wal.member (членский — невозвратный), w.exp.adv (подотчёт под
+ * расход), w.cap.gen (Генератор — COOPERATIVE, без L3-разреза по пайщику),
+ * w.cap.preimp (пред-импорт-учёт РИД).
+ *
+ * Каждому не-главному кошельку сета должна соответствовать операция переноса
+ * на `w.wal.share` в `Registrator::consolidate_share_to_main` (exit_helpers.hpp)
+ * — иначе runtime упадёт с явным сообщением (защита от тихой потери средств).
+ */
+inline constexpr std::array<eosio::name, 3> LEDGER2_EXIT_REFUND_WALLETS = {{
+  ledger2_wallets::MIN_SHARE_FUND,
+  ledger2_wallets::SHARE_FUND_PAY,
+  ledger2_wallets::BLAGOROST_FUND,
+}};
+
 /**
  * @brief Возвращает required program_id для USER_SHARED-кошелька.
  *

components/contracts/cpp/lib/core/names.hpp

@@ -50,6 +50,10 @@ namespace Names {
     // Коллбэки для расходов
     constexpr eosio::name AUTHORIZE_EXPENSE = "capauthexpns"_n;
     constexpr eosio::name DECLINE_EXPENSE = "capdeclexpns"_n;
+
+    // Программные расходы обслуживаются шасси expense; capital видит только
+    // инициирование (createpgexp) и этот callback завершения flow.
+    constexpr eosio::name ON_PROGRAM_EXPENSE_DONE = "onpgexpdone"_n;
     
     // Коллбэки для долгов
     constexpr eosio::name AUTHORIZE_DEBT = "debtauthcnfr"_n;
@@ -80,10 +84,13 @@ namespace Names {
     // Внешние действия в других контрактах
     constexpr eosio::name CREATE_OUTPAY = "createoutpay"_n;
     constexpr eosio::name OPEN_PROGRAM_WALLET = "openprogwall"_n;
-    
+
     // Действия для отправки в soviet
     constexpr eosio::name CREATE_APPROVAL = "createapprv"_n;
     constexpr eosio::name CREATE_AGENDA = "createagenda"_n;
+
+    // Шасси expense
+    constexpr eosio::name CREATE_EXPENSE_PROPOSAL = "createexp"_n;
   }
   
   namespace SovietActions {
@@ -120,6 +127,7 @@ namespace Names {
     constexpr eosio::name CREATE_INVESTMENT = "createinvest"_n; // акцепт инвестиции
     constexpr eosio::name CREATE_PROGRAM_INVESTMENT = "createpinv"_n; // акцепт программной инвестиции
     constexpr eosio::name CREATE_EXPENSE = "createexpnse"_n; // акцепт расхода
+    constexpr eosio::name CREATE_PROGRAM_EXPENSE = "createpgexp"_n; // акцепт программного расхода
     constexpr eosio::name CREATE_WITHDRAW_1 = "createwthd1"_n; // акцепт возврата из задания
     constexpr eosio::name CREATE_WITHDRAW_2 = "createwthd2"_n; // акцепт возврата из проекта
     constexpr eosio::name CREATE_WITHDRAW_3 = "createwthd3"_n; // акцепт возврата из программы

components/contracts/cpp/lib/domain/index.hpp

@@ -17,6 +17,7 @@
 #include "table_registrator_verification.hpp"
 #include "table_registrator_candidates.hpp"
 #include "table_registrator_candidates_legacy.hpp"
+#include "table_registrator_exits.hpp"
 
 // coops (soviet)
 #include "coops_access_helpers.hpp"

components/contracts/cpp/lib/domain/table_registrator_exits.hpp

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <optional>
+
+#include <eosio/asset.hpp>
+#include <eosio/crypto.hpp>
+#include <eosio/eosio.hpp>
+
+#include "../consts.hpp"
+#include "document_core.hpp"
+
+namespace Registrator {
+
+using namespace eosio;
+
+/**
+ * @ingroup public_tables
+ * @ingroup public_registrator_tables
+ * @par table: exits (registrator)
+ *
+ * @brief Заявление пайщика на выход из кооператива и сопровождающий его
+ * процесс возврата паевого взноса.
+ *
+ * Жизненный цикл (зеркало вступления reguser→confirmreg и возврата
+ * wallet::createwthd→authwthd→completewthd):
+ *   - exitcoop    → запись со статусом `pending`, повестка совета `leavecoop`;
+ *   - confirmexit → совет одобрил: статус `authorized`, консолидация
+ *                   минимального паевого на главный (o.reg.mvmin), резерв
+ *                   суммы возврата (o.wal.wthreq) и исходящий платёж в gateway;
+ *   - completexit → кассир подтвердил выплату: проводка Дт80/Кт51
+ *                   (o.wal.wthcpl), пайщик удаляется, аккаунт блокируется,
+ *                   запись стирается;
+ *   - declinexit  → отказ совета или отклонение платежа: снятие резерва
+ *                   (o.wal.wthdec, если он был сделан) и стирание записи.
+ *
+ * `quantity` — итоговая сумма возврата, вычисляется контрактом в момент
+ * одобрения советом (минимальный + целевой паевой пайщика по L3-балансам
+ * ledger2), а не доверяется клиенту.
+ */
+struct [[eosio::table, eosio::contract(REGISTRATOR)]] exit {
+  name username;
+  name coopname;
+  name status;                  ///< pending | authorized
+  time_point_sec created_at;
+  document2 statement;          ///< заявление о выходе (registry 200)
+  document2 approved_statement; ///< решение совета о выходе (авторизация)
+  checksum256 exit_hash;
+  asset quantity;               ///< итоговая сумма возврата (заполняется на confirmexit)
+
+  uint64_t primary_key() const { return username.value; }
+  checksum256 by_hash() const { return exit_hash; }
+};
+
+typedef multi_index<
+    "exits"_n, exit,
+    indexed_by<"byhash"_n, const_mem_fun<exit, checksum256, &exit::by_hash>>>
+    exits_index;
+
+inline std::optional<exit> get_exit_by_hash(name coopname, const checksum256 &hash) {
+  exits_index primary_index(_registrator, coopname.value);
+  auto secondary_index = primary_index.get_index<"byhash"_n>();
+
+  auto itr = secondary_index.find(hash);
+  if (itr == secondary_index.end()) {
+    return std::nullopt;
+  }
+
+  return *itr;
+}
+
+} // namespace Registrator

components/contracts/cpp/registrator/registrator.cpp

@@ -12,6 +12,12 @@
 #include "src/user/declinerfnd.cpp"
 #include "src/user/reguser.cpp"
 
+#include "src/exit/exit_helpers.hpp"
+#include "src/exit/exitcoop.cpp"
+#include "src/exit/confirmexit.cpp"
+#include "src/exit/completexit.cpp"
+#include "src/exit/declinexit.cpp"
+
 #include "src/account/createbranch.cpp"
 #include "src/account/newaccount.cpp"
 #include "src/account/updateaccnt.cpp"

components/contracts/cpp/registrator/registrator.hpp

@@ -85,6 +85,12 @@ public:
   [[eosio::action]] void changekey(eosio::name coopname, eosio::name changer, eosio::name username, eosio::public_key public_key);
   
   [[eosio::action]] void confirmreg(eosio::name coopname, checksum256 registration_hash, document2 authorization);
+
+  // Выход пайщика из кооператива (возврат паевого взноса) — src/exit/*.cpp
+  [[eosio::action]] void exitcoop(eosio::name coopname, eosio::name username, checksum256 exit_hash, document2 statement);
+  [[eosio::action]] void confirmexit(eosio::name coopname, checksum256 exit_hash, document2 authorization);
+  [[eosio::action]] void completexit(eosio::name coopname, checksum256 exit_hash);
+  [[eosio::action]] void declinexit(eosio::name coopname, checksum256 exit_hash, std::string reason);
   [[eosio::action]] void confirmpay(name coopname, checksum256 registration_hash);
   [[eosio::action]] void declinepay(name coopname, checksum256 registration_hash, std::string reason);
   [[eosio::action]] void declinereg(name coopname, checksum256 registration_hash, std::string reason);

components/contracts/cpp/registrator/src/exit/completexit.cpp

@@ -0,0 +1,35 @@
+/**
+ * @brief Завершение возврата паевого взноса при выходе из кооператива.
+ * Кассир подтвердил исходящий платёж — gateway вызывает этот коллбэк.
+ * Списываем зарезервированную сумму (o.wal.wthcpl: Дт80/Кт51, BURN с
+ * w.wal.wpend), удаляем пайщика из реестра совета и блокируем его аккаунт.
+ * Возврат назад невозможен — повторное участие только через новую регистрацию.
+ * @param coopname Наименование кооператива
+ * @param exit_hash Хэш процесса выхода
+ * @ingroup public_actions
+ * @ingroup public_registrator_actions
+
+ * @note Авторизация требуется от аккаунта: @p gateway
+ */
+void registrator::completexit(eosio::name coopname, checksum256 exit_hash) {
+  require_auth(_gateway);
+
+  auto exist = Registrator::get_exit_by_hash(coopname, exit_hash);
+  eosio::check(exist.has_value(), "Объект выхода не найден");
+
+  Registrator::exits_index exits(_registrator, coopname.value);
+  auto e = exits.find(exist->username.value);
+  eosio::check(e->status == "authorized"_n, "Только одобренные заявления на выход могут быть завершены");
+
+  eosio::name username = e->username;
+
+  // Проводка возврата паевого: списываем резерв w.wal.wpend, Дт80/Кт51.
+  std::string memo = "Возврат паевого взноса при выходе из кооператива, username=" + username.to_string();
+  Ledger2::apply(_registrator, coopname, operations::wallet::COMPLETE_WITHDRAW,
+                 e->quantity, username, exit_hash, memo);
+
+  // Финализируем выход: удаляем пайщика и блокируем аккаунт.
+  Registrator::finalize_member_exit(coopname, username);
+
+  exits.erase(e);
+}

components/contracts/cpp/registrator/src/exit/confirmexit.cpp

@@ -0,0 +1,76 @@
+/**
+ * @brief Одобрение советом выхода пайщика из кооператива.
+ * Совет одобрил заявление о выходе. Контракт сам вычисляет сумму возврата:
+ * обходит сет паевых кошельков LEDGER2_EXIT_REFUND_WALLETS (w.reg.minshr +
+ * w.wal.share + w.cap.blago), собирает доступный L3-баланс каждого, консолидирует
+ * на главный паевой (w.wal.share), резервирует всю сумму (o.wal.wthreq) и создаёт
+ * исходящий платёж в gateway. Если возвращать нечего — выход завершается сразу
+ * без платежа.
+ * @param coopname Наименование кооператива
+ * @param exit_hash Хэш процесса выхода
+ * @param authorization Документ-решение совета о выходе
+ * @ingroup public_actions
+ * @ingroup public_registrator_actions
+
+ * @note Авторизация требуется от аккаунта: @p soviet
+ */
+void registrator::confirmexit(eosio::name coopname, checksum256 exit_hash, document2 authorization) {
+  require_auth(_soviet);
+
+  auto exist = Registrator::get_exit_by_hash(coopname, exit_hash);
+  eosio::check(exist.has_value(), "Объект выхода не найден");
+
+  Registrator::exits_index exits(_registrator, coopname.value);
+  auto e = exits.find(exist->username.value);
+  eosio::check(e->status == "pending"_n, "Только ожидающие заявления на выход могут быть одобрены");
+
+  eosio::name username = e->username;
+
+  // оповещаем пайщика
+  require_recipient(username);
+
+  // Контракт сам считает сумму возврата по L3-балансам ledger2 — не доверяем
+  // клиенту. Обходим сет паевых («боевых») кошельков LEDGER2_EXIT_REFUND_WALLETS
+  // (источник истины — wallets.hpp; он же генерируется в cooptypes для
+  // backend-preview, поэтому расчёт на фронте совпадает с этим): аккумулируем
+  // доступный баланс каждого (>0) и тут же консолидируем его на главный паевой
+  // (w.wal.share), чтобы единым платежом вернуть весь паевой через o.wal.*.
+  eosio::asset total_return = eosio::asset(0, _root_govern_symbol);
+  for (const auto &wallet_name : LEDGER2_EXIT_REFUND_WALLETS) {
+    eosio::asset balance = Registrator::get_user_wallet_available(coopname, wallet_name, username);
+    if (balance.amount <= 0) continue;
+    total_return += balance;
+    Registrator::consolidate_share_to_main(coopname, username, wallet_name, balance, exit_hash);
+  }
+
+  exits.modify(e, _soviet, [&](auto &row) {
+    row.status = "authorized"_n;
+    row.approved_statement = authorization;
+    row.quantity = total_return;
+  });
+
+  if (total_return.amount > 0) {
+    // Резервируем сумму возврата: w.wal.share → w.wal.wpend (o.wal.wthreq).
+    std::string memo_req = "Резерв паевого взноса под выход из кооператива, username=" + username.to_string();
+    Ledger2::apply(_registrator, coopname, operations::wallet::REQUEST_WITHDRAW,
+                   total_return, username, exit_hash, memo_req);
+
+    // Создаём исходящий платёж в gateway с коллбэками completexit/declinexit.
+    Action::send<createoutpay_interface>(
+      _gateway,
+      "createoutpay"_n,
+      _registrator,
+      coopname,
+      username,
+      exit_hash,
+      total_return,
+      _registrator,
+      "completexit"_n,
+      "declinexit"_n
+    );
+  } else {
+    // Возвращать нечего — финализируем выход без платежа.
+    Registrator::finalize_member_exit(coopname, username);
+    exits.erase(e);
+  }
+}

components/contracts/cpp/registrator/src/exit/declinexit.cpp

@@ -0,0 +1,41 @@
+/**
+ * @brief Отказ в выходе из кооператива.
+ * Вызывается либо советом при отклонении заявления (до резервирования средств),
+ * либо gateway при отклонении исходящего платежа (после резервирования). Если
+ * сумма возврата уже была зарезервирована — снимаем резерв (o.wal.wthdec:
+ * w.wal.wpend → w.wal.share). Пайщик остаётся действующим членом кооператива.
+ * @param coopname Наименование кооператива
+ * @param exit_hash Хэш процесса выхода
+ * @param reason Причина отказа
+ * @ingroup public_actions
+ * @ingroup public_registrator_actions
+
+ * @note Авторизация требуется от аккаунта: @p soviet или @p gateway
+ */
+void registrator::declinexit(eosio::name coopname, checksum256 exit_hash, std::string reason) {
+  check_auth_and_get_payer_or_fail({_soviet, _gateway});
+
+  auto exist = Registrator::get_exit_by_hash(coopname, exit_hash);
+  eosio::check(exist.has_value(), "Объект выхода не найден");
+
+  Registrator::exits_index exits(_registrator, coopname.value);
+  auto e = exits.find(exist->username.value);
+
+  eosio::name username = e->username;
+
+  // Если резерв уже был сделан (отказ платежа после одобрения советом) —
+  // снимаем его, возвращая средства пайщику на главный паевой кошелёк.
+  // Минимальный паевой, ранее консолидированный на главный (o.reg.mvmin),
+  // остаётся на w.wal.share: пайщик сохраняет полную сумму паевого, аналитика
+  // минимального/целевого разреза при несостоявшемся выходе не восстанавливается.
+  if (e->status == "authorized"_n && e->quantity.amount > 0) {
+    std::string memo = "Снятие резерва паевого при отмене выхода из кооператива: " + reason;
+    Ledger2::apply(_registrator, coopname, operations::wallet::DECLINE_WITHDRAW,
+                   e->quantity, username, exit_hash, memo);
+  }
+
+  // оповещаем пайщика
+  require_recipient(username);
+
+  exits.erase(e);
+}

components/contracts/cpp/registrator/src/exit/exit_helpers.hpp

@@ -0,0 +1,95 @@
+#pragma once
+
+#include <eosio/asset.hpp>
+#include <eosio/eosio.hpp>
+
+#include "../../../lib/index.hpp"
+
+/**
+ * @brief Вспомогательные функции процедуры выхода пайщика из кооператива.
+ *
+ * Вынесены в отдельный заголовок (а не в table_registrator_exits.hpp), т.к.
+ * опираются на ledger2-кошельки и userwallets, которые подключаются позже в
+ * domain/index.hpp. Подключается в registrator.cpp перед exit-экшенами, когда
+ * весь lib/index.hpp уже доступен.
+ */
+namespace Registrator {
+
+using namespace eosio;
+
+/**
+ * @brief Доступный L3-баланс пайщика на USER_SHARED-кошельке ledger2.
+ *
+ * Возвращает available (без blocked) пары `(wallet_name, username)` из таблицы
+ * userwallets контракта ledger2. Если записи нет — нулевая сумма в базовой
+ * валюте управления.
+ */
+inline asset get_user_wallet_available(name coopname, name wallet_name, name username) {
+  userwallets_index userwallets(_ledger2, coopname.value);
+  auto idx = userwallets.get_index<"byuserwallet"_n>();
+  auto it = idx.find(combine_ids(wallet_name.value, username.value));
+  if (it == idx.end()) {
+    return asset(0, _root_govern_symbol);
+  }
+  return it->available;
+}
+
+/**
+ * @brief Консолидация доступного паевого кошелька пайщика на главный
+ * (`w.wal.share`) перед резервом возврата при выходе.
+ *
+ * Главный кошелёк (`w.wal.share`) уже целевой — перенос не нужен. Для остальных
+ * кошельков сета `LEDGER2_EXIT_REFUND_WALLETS` применяется операция переноса на
+ * главный:
+ *   w.reg.minshr → o.reg.mvmin  (MOVE_MINSHARE);
+ *   w.cap.blago  → o.cap.wthcap (WITHDRAW_FROM_CAPITAL).
+ *
+ * Кошелёк сета без операции переноса (новый паевой кошелёк забыли смаппить)
+ * валит транзакцию с явным сообщением — защита от тихой потери средств.
+ */
+inline void consolidate_share_to_main(name coopname, name username, name wallet_name, asset amount, checksum256 exit_hash) {
+  if (wallet_name == ledger2_wallets::SHARE_FUND_PAY) return; // уже на главном паевом
+
+  eosio::name op;
+  if (wallet_name == ledger2_wallets::MIN_SHARE_FUND) {
+    op = operations::registrator::MOVE_MINSHARE;       // w.reg.minshr → w.wal.share
+  } else if (wallet_name == ledger2_wallets::BLAGOROST_FUND) {
+    op = operations::capital::WITHDRAW_FROM_CAPITAL;   // w.cap.blago  → w.wal.share
+  } else {
+    eosio::check(false,
+      std::string{"Нет операции консолидации паевого кошелька "} + wallet_name.to_string() +
+      " на главный при выходе — добавьте маппинг в consolidate_share_to_main");
+  }
+
+  std::string memo = "Консолидация паевого взноса при выходе, кошелёк=" +
+                     wallet_name.to_string() + ", username=" + username.to_string();
+  Ledger2::apply(_registrator, coopname, op, amount, username, exit_hash, memo);
+}
+
+/**
+ * @brief Финализация выхода: удаление пайщика из реестра совета и блокировка
+ * аккаунта в registrator.
+ *
+ * Вызывается по завершении возврата паевого взноса (completexit) либо сразу,
+ * если возвращать нечего (нулевой паевой). После этого `get_participant_or_fail`
+ * для пайщика начинает падать — он лишён права подавать заявления.
+ */
+inline void finalize_member_exit(name coopname, name username) {
+  // удаляем пайщика из реестра совета (уменьшит счётчик активных пайщиков)
+  action(
+    permission_level{_registrator, "active"_n},
+    _soviet,
+    "delpartcpnt"_n,
+    std::make_tuple(coopname, username)
+  ).send();
+
+  // блокируем аккаунт в картотеке registrator
+  accounts_index accounts(_registrator, _registrator.value);
+  auto account = accounts.find(username.value);
+  eosio::check(account != accounts.end(), "Аккаунт не найден");
+  accounts.modify(account, _registrator, [&](auto &a) {
+    a.status = "blocked"_n;
+  });
+}
+
+} // namespace Registrator

components/contracts/cpp/registrator/src/exit/exitcoop.cpp

@@ -0,0 +1,57 @@
+/**
+ * @brief Подача заявления на выход из кооператива.
+ * Действующий пайщик подаёт подписанное заявление о выходе (registry 200).
+ * Создаётся объект выхода и повестка совета `leavecoop` на рассмотрение.
+ * Возврат паевого взноса произойдёт после одобрения советом (confirmexit).
+ * @param coopname Наименование кооператива
+ * @param username Имя пайщика, выходящего из кооператива
+ * @param exit_hash Хэш процесса выхода
+ * @param statement Подписанное заявление о выходе (registry 200)
+ * @ingroup public_actions
+ * @ingroup public_registrator_actions
+
+ * @note Авторизация требуется от аккаунта: @p coopname
+ */
+void registrator::exitcoop(eosio::name coopname, eosio::name username, checksum256 exit_hash, document2 statement) {
+  require_auth(coopname);
+
+  get_cooperative_or_fail(coopname);
+
+  // выйти может только действующий пайщик (не заблокированный)
+  get_participant_or_fail(coopname, username);
+
+  // повторная подача запрещена — у пайщика может быть только один процесс выхода
+  Registrator::exits_index exits(_registrator, coopname.value);
+  auto existing = exits.find(username.value);
+  eosio::check(existing == exits.end(), "Заявление на выход уже подано");
+
+  auto by_hash = Registrator::get_exit_by_hash(coopname, exit_hash);
+  eosio::check(!by_hash.has_value(), "Объект выхода уже существует с указанным хэшем");
+
+  // проверяем подпись заявления о выходе
+  verify_document_or_fail(statement);
+
+  exits.emplace(coopname, [&](auto &e) {
+    e.username = username;
+    e.coopname = coopname;
+    e.status = "pending"_n;
+    e.created_at = current_time_point();
+    e.statement = statement;
+    e.exit_hash = exit_hash;
+    e.quantity = asset(0, _root_govern_symbol);
+  });
+
+  // повестка совета на рассмотрение выхода с коллбэками confirmexit/declinexit
+  ::Soviet::create_agenda(
+    _registrator,
+    coopname,
+    username,
+    get_valid_soviet_action("leavecoop"_n),
+    exit_hash,
+    _registrator,                 // callback_contract
+    "confirmexit"_n,              // callback при одобрении
+    "declinexit"_n,               // callback при отказе
+    statement,
+    std::string("")
+  );
+}

components/contracts/cpp/soviet/soviet.cpp

@@ -49,6 +49,7 @@
 #include "src/fund/fundwithdraw.cpp"
 
 #include "src/participant/addparticipant.cpp"
+#include "src/participant/delparticipant.cpp"
 #include "src/participant/setminamt.cpp"
 #include "src/participant/block.cpp"
 #include "src/participant/cancelreg.cpp"

components/contracts/cpp/soviet/soviet.hpp

@@ -139,6 +139,9 @@ public:
   //regaccount.cpp
   [[eosio::action]] void addpartcpnt(eosio::name coopname, eosio::name username, eosio::name braname, eosio::name type, eosio::time_point_sec created_at, eosio::asset initial, eosio::asset minimum, bool spread_initial);
 
+  //delparticipant.cpp
+  [[eosio::action]] void delpartcpnt(eosio::name coopname, eosio::name username);
+
   //setminamt.cpp
   [[eosio::action]] void setminamt(eosio::name coopname, eosio::name username, eosio::asset minimum);
 

components/contracts/cpp/soviet/src/participant/delparticipant.cpp

@@ -0,0 +1,38 @@
+/**
+ * @brief Удаление пайщика из кооператива при выходе
+ * Стирает запись пайщика из реестра совета по завершении процедуры выхода
+ * (после возврата паевого взноса). Зеркало `addpartcpnt`. Если выбывающий
+ * пайщик был активным и имел право голоса — уменьшает счётчик активных
+ * пайщиков в registrator (как это делает `block`).
+ * @param coopname Наименование кооператива
+ * @param username Наименование выбывающего пайщика
+ * @ingroup public_actions
+ * @ingroup public_soviet_actions
+
+ * @note Авторизация требуется от аккаунта в белом списке контрактов
+ */
+void soviet::delpartcpnt(eosio::name coopname, eosio::name username) {
+  check_auth_and_get_payer_or_fail(contracts_whitelist);
+
+  get_cooperative_or_fail(coopname);
+
+  participants_index participants(_soviet, coopname.value);
+  auto participant = participants.find(username.value);
+  eosio::check(participant != participants.end(), "Пайщик не найден в кооперативе");
+
+  // Если пайщик был активным и имел право голоса — уменьшаем счётчик активных
+  // пайщиков (счётчик живёт в registrator, см. block.cpp / decparticpnt.cpp).
+  bool had_vote = participant->has_vote;
+  bool was_active = participant->status == "accepted"_n;
+
+  if (was_active && had_vote) {
+    action(
+      permission_level{_soviet, "active"_n},
+      _registrator,
+      "decparticpnt"_n,
+      std::make_tuple(coopname, username)
+    ).send();
+  }
+
+  participants.erase(participant);
+}

components/contracts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coopenomics/contracts",
-  "version": "2026.6.8-2",
+  "version": "2026.6.24",
   "private": true,
   "type": "module",
   "scripts": {
@@ -9,9 +9,6 @@
     "build:one": "./build.sh $1",
     "build:one:test": "contract=$1 mode=test ./build.sh",
     "enter": "./boot/scripts/enter.sh",
-    "testnet": "git checkout testnet && git merge dev && lerna publish prerelease && git push && git checkout dev && git merge testnet",
-    "production": "git checkout main && git merge -X theirs testnet && lerna publish --conventional-commits --conventional-graduate && git push && git checkout dev && git merge main",
-    "docs-publish": "pnpm gh-pages --nojekyll -d docs/site --repo git@github.com:coopenomics/monocoop.git",
     "standards:dev": "pnpm --filter @coopenomics/standards-site dev",
     "standards:build": "pnpm --filter @coopenomics/standards-site build",
     "standards:preview": "pnpm --filter @coopenomics/standards-site preview"

components/controller/.env-example

@@ -34,6 +34,13 @@ SMTP_USERNAME=
 SMTP_PASSWORD=
 EMAIL_FROM="'КО-ПОЧТАЛЬОН' <mail@coopenomics.world>"
 
+# Напоминатель об отчёте по авансу под отчёт (extensions/expenses).
+# Интервал тика сканера зеркала расходов (мс). Дефолт 6 ч. Письмо пайщику —
+# не чаще раза в неделю (троттлит идемпотентность Центра уведомлений).
+EXPENSE_ADVANCE_REMINDER_INTERVAL_MS=21600000
+# Сколько дней аванс может висеть без отчёта до первого напоминания. Дефолт 3.
+EXPENSE_ADVANCE_REMINDER_GRACE_DAYS=3
+
 # BLOCKHAIN
 BLOCKCHAIN_RPC=http://127.0.0.1:8888
 CHAIN_ID=cae86058a6d8698833afb474ab8a5ad8599c6cf54f9ebcf275dbac7055c16fe1

components/controller/migrations/V2.3.2__backfill_voskhod_capital_doc_data_hash.ts

@@ -0,0 +1,129 @@
+import { createHash } from 'node:crypto';
+import type { DataSource } from 'typeorm';
+import mongoose from 'mongoose';
+import config from '~/config/config';
+
+type MigrationLogger = {
+  info: (message: string) => void;
+  error: (message: string) => void;
+  warn: (message: string) => void;
+};
+
+const CAPITAL_DOC_REGISTRY_ID = 994;
+const TARGET_COOPNAME = 'voskhod';
+const COLLECTION_NAME = 'doc_private_data';
+
+const capitalProgramPrivateData = {
+  approval_protocol_number: '1',
+  approval_protocol_day: '15',
+  approval_protocol_month: 'января',
+  approval_protocol_year: '26',
+  cooperative_name: 'ВОСХОД',
+  cooperative_short_name: 'ПК',
+  cooperative_quoted_name: '«ВОСХОД»',
+  website: 'https://цифровой-кооператив.рф',
+  chairman_full_name: 'Муравьев Алексей Николаевич',
+  generator_program_purpose:
+    'развитию информационной экосистемы взаимодействия физических и юридических лиц, на основе международных кооперативных принципов и законодательства Российской Федерации в отношении потребительских обществ (кооперативов) под названием “Кооперативная Экономика”',
+  eoap_definition:
+    'информационная экосистема, интегрируемая в социально-экономическую среду Российской Федерации, состоящая из комплекса программных продуктов на базе технологии распределенного реестра, обеспечивающих широкое экономическое и социальное взаимодействие физических и юридических лиц, включая нерезидентов различных юрисдикций и организационно-правовых форм, на основе международных кооперативных принципов и законодательства Российской Федерации в отношении потребительских кооперативов (обществ) под названием “Кооперативная Экономика”',
+  generator_task_goal:
+    'центра привлечения и интеграции передовых инновационных цифровых разработок, а также экономических и социальных методов и решений',
+  idea_unit_cost: '50',
+  idea_unit_cost_words: 'пятьдесят',
+  blagorost_goal_expansion:
+    'вследствие увеличения количества Участников информационной кооперативной экосистемы - ЕОАП - для расширения и повышения социальной эффективности их экономического взаимодействия в некоммерческом формате',
+  blagorost_task_expansion:
+    'расширение участников ЕОАП - информационной кооперативной экосистемы как центра экономического взаимодействия в некоммерческом формате',
+  blagorost_task_development:
+    'развитие ЕОАП как центра привлечения и интеграции инновационных цифровых разработок, а также экономических и социальных методов и решений',
+  return_source_description:
+    'аппаратно-программная сеть узлов распределенного реестра в формате «СМЭВ+SWIFT», построенная на принципах самоорганизации и самофинансирования деятельности технологической инфраструктуры ЕОАП, обеспечивающей консенсус ее распределенных узлов по формированию базового продукта ЕОАП - полного цикла документооборота по синхронному взаимодействию пайщиков и кооперативов - участников экосистемы ЕОАП - через использование цифровых контрактов, с одновременным выполнением функций нотариата и учета финансовых и юридических событий',
+  return_additional_source:
+    'взносы пользователей ЕОАП, его отдельных программных продуктов и приложений, переданных Обществу или создаваемых в рамках Общества, которые интегрируются в ЕОАП',
+  offer_template_number: '______',
+};
+
+function stableStringify(value: unknown): string {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+
+  const entries = Object.keys(value as Record<string, unknown>)
+    .sort()
+    .map((key) => {
+      const v = (value as Record<string, unknown>)[key];
+      return `${JSON.stringify(key)}:${stableStringify(v)}`;
+    });
+
+  return `{${entries.join(',')}}`;
+}
+
+function calculateSha256(value: unknown): string {
+  return createHash('sha256').update(Buffer.from(stableStringify(value), 'utf8')).digest('hex').toUpperCase();
+}
+
+export default {
+  name: 'Backfill capital_program_doc_data_hash for voskhod',
+  validUntil: new Date('2027-05-01T00:00:00Z'),
+
+  async up({ dataSource, logger }: { dataSource: DataSource; logger: MigrationLogger }): Promise<boolean> {
+    if (config.coopname !== TARGET_COOPNAME) {
+      logger.info(`COOPNAME=${config.coopname}: миграция предназначена только для ${TARGET_COOPNAME}, пропускаю.`);
+      return true;
+    }
+
+    const hash = calculateSha256(capitalProgramPrivateData);
+    let mongo: mongoose.Connection | null = null;
+
+    try {
+      mongo = await mongoose.createConnection(config.mongoose.url).asPromise();
+      const db = mongo.db;
+      const collection = db.collection(COLLECTION_NAME);
+      await collection.createIndex({ hash: 1 }, { unique: true });
+      await collection.updateOne(
+        { hash },
+        {
+          $setOnInsert: {
+            hash,
+            registry_id: CAPITAL_DOC_REGISTRY_ID,
+            payload: capitalProgramPrivateData,
+            _created_at: new Date(),
+          },
+        },
+        { upsert: true }
+      );
+
+      const result = await dataSource.query(
+        `UPDATE extensions
+            SET config = jsonb_set(COALESCE(config, '{}'::jsonb), '{capital_program_doc_data_hash}', to_jsonb($1::text), true),
+                updated_at = NOW()
+          WHERE name = 'capital'`,
+        [hash]
+      );
+
+      logger.info(`capital_program_doc_data_hash=${hash} сохранён для ${TARGET_COOPNAME}; extensions updated=${result?.[1] ?? 'unknown'}.`);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error(`Ошибка миграции capital_program_doc_data_hash для ${TARGET_COOPNAME}: ${message}`);
+      return false;
+    } finally {
+      await mongo?.close();
+    }
+  },
+
+  async down({ dataSource, logger }: { dataSource: DataSource; logger: MigrationLogger }): Promise<boolean> {
+    if (config.coopname !== TARGET_COOPNAME) {
+      return true;
+    }
+
+    await dataSource.query(
+      `UPDATE extensions
+          SET config = COALESCE(config, '{}'::jsonb) - 'capital_program_doc_data_hash',
+              updated_at = NOW()
+        WHERE name = 'capital'`
+    );
+    logger.warn('capital_program_doc_data_hash удалён из config capital; запись doc_private_data оставлена как идемпотентный audit trail.');
+    return true;
+  },
+};

components/controller/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "create-nodejs-express-app",
-  "version": "2026.6.8-2",
+  "version": "2026.6.24",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "create-nodejs-express-app",
-      "version": "2026.6.8-2",
+      "version": "2026.6.24",
       "license": "MIT",
       "dependencies": {
         "@a2seven/yoo-checkout": "^1.1.4",

components/controller/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coopenomics/controller",
-  "version": "2026.6.8-2",
+  "version": "2026.6.24",
   "description": "Бэкенд GraphQL API кооператива на NestJS",
   "private": true,
   "bin": "bin/createNodejsApp.js",

components/controller/src/app.module.ts

@@ -76,6 +76,7 @@ import { UserModule } from './application/user/user.module';
 import { TokenApplicationModule } from './application/token/token-application.module';
 import { SettingsApplicationModule } from './application/settings/settings.module';
 import { RegistrationModule } from './application/registration/registration.module';
+import { MembershipExitModule } from './application/membership-exit/membership-exit.module';
 import { OnboardingApplicationModule } from './application/onboarding/onboarding-application.module';
 import { SearchModule } from './application/search/search.module';
 import { SignedDocumentsModule } from './application/signed-documents/signed-documents.module';
@@ -169,6 +170,7 @@ import { MutationLoggingInterceptor } from './application/common/interceptors/mu
     TokenApplicationModule,
     SettingsApplicationModule,
     RegistrationModule,
+    MembershipExitModule,
     OnboardingApplicationModule,
     SearchModule,
     SignedDocumentsModule,

components/controller/src/application/account/interactors/account.interactor.ts

@@ -189,16 +189,22 @@ export class AccountInteractor {
    * Назначение — почистить реестр от незавершённых/отклонённых регистраций
    * (тестеры, брошенные попытки) и освободить занятый e-mail для перерегистрации.
    *
-   * Различитель — СТАТУС, не наличие blockchain_account: on-chain аккаунт в этой
-   * среде заводится рано и присутствует уже у статуса `created`, поэтому он НЕ
-   * признак «принят/зарегистрирован» и для гейта не годится.
+   * Единственный гард — НЕ принят в кооператив. participant_account
+   * (accepted|blocked) появляется только после приёма советом, его наличие ⟺ член
+   * кооператива. Всё остальное (черновик, заявление, оплачен/на рассмотрении
+   * совета, отклонён, возврат) удаляемо — это и есть «незавершённая регистрация».
    *
-   * Запрещаем, только если:
-   *  - пайщик принят в кооператив (есть participant_account: accepted/blocked) —
-   *    активный член;
-   *  - статус пост-регистрационный (registered = после приёма вступительного
-   *    платежа, active) или blocked, либо любой будущий не-регистрационный —
-   *    allow-list fail-closed.
+   * Статус для гейта НЕ годится: воронка реально доходит лишь до `registered`
+   * (отказ совета и возврат взноса оставляют статус `registered`, а `failed`/
+   * `refunded` users.status никем не выставляются). Прежний allow-list
+   * `[created, joined, payed, failed, refunded]` исключал именно отклонённые/
+   * оплаченные брошенные регистрации — ровно те, ради которых задумана чистка.
+   *
+   * On-chain аккаунт заводится при оплате взноса (статус registered) и в EOSIO
+   * неудаляем — остаётся осиротевшим, имя в цепи занято навсегда. Для
+   * регистрационной чистки это приемлемо: off-chain учёт провайдера и цепь
+   * намеренно расходятся (см. registration-decline.listener — карточку кандидата
+   * на цепи снимает refundpay, системный аккаунт остаётся).
    */
   async deleteAccount(username: string): Promise<void> {
     const account = await this.accountDomainService.getAccount(username);
@@ -210,23 +216,6 @@ export class AccountInteractor {
       );
     }
 
-    // Регистрационная воронка до приёма вступительного платежа + терминальные
-    // отказы. Registered/Active/Blocked — НЕ удаляем.
-    const deletableStatuses: userStatus[] = [
-      userStatus['1_Created'],
-      userStatus['2_Joined'],
-      userStatus['3_Payed'],
-      userStatus['10_Failed'],
-      userStatus['100_Refunded'],
-    ];
-    const status = account.provider_account?.status as userStatus | undefined;
-    if (!status || !deletableStatuses.includes(status)) {
-      throw new HttpApiError(
-        HttpStatus.BAD_REQUEST,
-        'Удаление доступно только для пайщиков в незавершённом регистрационном статусе.'
-      );
-    }
-
     await this.userDomainService.deleteUserByUsername(username);
   }
 
@@ -361,7 +350,11 @@ export class AccountInteractor {
     };
 
     for (const account of provider_accounts.items) {
-      const item = await this.accountDomainService.getAccount(account.username);
+      // this.getAccount (а не accountDomainService.getAccount) — чтобы реестр получил
+      // registration_payment: иначе отказ совета (Registered + возврат взноса) на
+      // списке неотличим от «ожидает совет». Обогащение стоит 2 доп. запроса к
+      // платежам только для непринятых аккаунтов (гард `!participant_account`).
+      const item = await this.getAccount(account.username);
       result.items.push(item);
     }
 

components/controller/src/application/common/dto/pagination.dto.ts

@@ -53,3 +53,47 @@ export function createPaginationResult<T>(ItemType: new (...args: any[]) => T, n
   }
   return PaginationResult;
 }
+
+/**
+ * Сборка `PaginationResult<U>` для consumer'ов, читающих через inter-порт
+ * (нет своего Repository.findAndCount, доступен только raw `{items, totalCount}`).
+ *
+ * Зачем: вычисление `totalPages`/`currentPage` из `PaginationInputDTO` — общая
+ * детерминированная логика; дублировать её в каждом consumer'е = canon-долг.
+ */
+export function buildPaginationResult<T, U>(
+  raw: { items: T[]; totalCount: number },
+  options: PaginationInputDTO | undefined,
+  mapItem: (it: T) => U,
+): PaginationResult<U> {
+  const limit = options?.limit;
+  const page = options?.page != null ? Math.max(1, options.page) : 1;
+  const totalPages = limit != null && limit > 0 ? Math.max(1, Math.ceil(raw.totalCount / limit)) : 1;
+  return {
+    items: raw.items.map(mapItem),
+    totalCount: raw.totalCount,
+    totalPages,
+    currentPage: page,
+  };
+}
+
+/**
+ * Канон-конверсия `PaginationInputDTO` → `{limit, offset, sortBy, sortOrder}`
+ * для адаптеров inter-портов / внешних read API, не принимающих page-form.
+ */
+export function paginationInputToOffset(options?: PaginationInputDTO): {
+  limit?: number;
+  offset?: number;
+  sortBy?: string;
+  sortOrder?: 'ASC' | 'DESC';
+} {
+  const limit = options?.limit;
+  const page = options?.page != null ? Math.max(1, options.page) : 1;
+  const offset = limit != null ? (page - 1) * limit : undefined;
+  return {
+    limit,
+    offset,
+    sortBy: options?.sortBy,
+    sortOrder: options?.sortOrder,
+  };
+}

components/controller/src/application/document/documents-dto/expense-proposal-decision-document.dto.ts

@@ -0,0 +1,133 @@
+import { InputType, Field, IntersectionType, OmitType, Int } from '@nestjs/graphql';
+import { IsString, IsNotEmpty, IsArray, ValidateNested, ArrayMinSize, IsInt, IsOptional } from 'class-validator';
+import { Type } from 'class-transformer';
+import { Cooperative } from 'cooptypes';
+import { GenerateMetaDocumentInputDTO } from '~/application/document/dto/generate-meta-document-input.dto';
+import { MetaDocumentInputDTO } from '~/application/document/dto/meta-document-input.dto';
+import { SignedDigitalDocumentInputDTO } from '~/application/document/dto/signed-digital-document-input.dto';
+
+type Action = Cooperative.Registry.ExpenseProposalDecision.Action;
+type ItemAction = Cooperative.Registry.ExpenseProposalStatement.IExpenseItem;
+type HeaderAction = Cooperative.Registry.ExpenseProposalStatement.IExpenseProposalHeader;
+type DecisionBody = Cooperative.Registry.ExpenseProposalDecision.IExpenseProposalDecisionBody;
+
+@InputType('ExpenseProposalDecisionItemInput')
+class ExpenseProposalDecisionItemInputDTO implements ItemAction {
+  @Field()
+  @IsString()
+  number!: string;
+
+  @Field()
+  @IsString()
+  description!: string;
+
+  @Field()
+  @IsString()
+  amount!: string;
+
+  @Field()
+  @IsString()
+  recipient_type!: 'SELF' | 'MEMBER' | 'ORG';
+
+  @Field()
+  @IsString()
+  mechanics!: 'ADVANCE' | 'DIRECT';
+}
+
+@InputType('ExpenseProposalDecisionHeaderInput')
+class ExpenseProposalDecisionHeaderInputDTO implements HeaderAction {
+  @Field()
+  @IsString()
+  description!: string;
+
+  @Field()
+  @IsString()
+  total_amount!: string;
+
+  @Field(() => Int)
+  @IsInt()
+  items_count!: number;
+
+  @Field()
+  @IsString()
+  source_wallet!: string;
+
+  @Field({ nullable: true })
+  @IsOptional()
+  @IsString()
+  deadline?: string;
+
+  @Field({ nullable: true })
+  @IsOptional()
+  @IsString()
+  fund_name?: string;
+}
+
+@InputType('ExpenseProposalDecisionBodyInput')
+class ExpenseProposalDecisionBodyInputDTO implements DecisionBody {
+  @Field({ description: 'Род решения (approve / decline)' })
+  @IsString()
+  kind!: 'approve' | 'decline';
+
+  @Field({ description: 'Причина отказа (для decline)', nullable: true })
+  @IsOptional()
+  @IsString()
+  reason?: string;
+}
+
+@InputType('BaseExpenseProposalDecisionMetaDocumentInput')
+class BaseExpenseProposalDecisionMetaDocumentInputDTO implements Omit<Action, 'coopname' | 'username' | 'registry_id' | 'block_num' | 'lang' | 'title' | 'generator' | 'version' | 'created_at' | 'timezone' | 'links'> {
+  @Field({ description: 'Хеш сметы расхода' })
+  @IsString()
+  @IsNotEmpty()
+  proposal_hash!: string;
+
+  @Field(() => Int, { description: 'Идентификатор решения совета (повестка) — источник данных голосования' })
+  @IsInt()
+  decision_id!: number;
+
+  @Field(() => ExpenseProposalDecisionHeaderInputDTO, { description: 'Шапка СЗ' })
+  @ValidateNested()
+  @Type(() => ExpenseProposalDecisionHeaderInputDTO)
+  proposal!: ExpenseProposalDecisionHeaderInputDTO;
+
+  @Field(() => [ExpenseProposalDecisionItemInputDTO], { description: 'Позиции расхода' })
+  @IsArray()
+  @ArrayMinSize(1)
+  @ValidateNested({ each: true })
+  @Type(() => ExpenseProposalDecisionItemInputDTO)
+  items!: ExpenseProposalDecisionItemInputDTO[];
+
+  @Field(() => ExpenseProposalDecisionBodyInputDTO, { description: 'Резолюция совета (утвердить / отказать)' })
+  @ValidateNested()
+  @Type(() => ExpenseProposalDecisionBodyInputDTO)
+  resolution!: ExpenseProposalDecisionBodyInputDTO;
+}
+
+/**
+ * Input генерации документа решения по СЗ (registry 2011).
+ */
+@InputType('ExpenseProposalDecisionGenerateDocumentInput')
+export class ExpenseProposalDecisionGenerateDocumentInputDTO extends IntersectionType(
+  BaseExpenseProposalDecisionMetaDocumentInputDTO,
+  OmitType(GenerateMetaDocumentInputDTO, ['registry_id'] as const)
+) {
+  registry_id!: number;
+}
+
+@InputType('ExpenseProposalDecisionSignedMetaDocumentInput')
+export class ExpenseProposalDecisionSignedMetaDocumentInputDTO extends IntersectionType(
+  BaseExpenseProposalDecisionMetaDocumentInputDTO,
+  MetaDocumentInputDTO
+) {}
+
+/**
+ * Подписанный документ-решение по СЗ (registry 2011).
+ */
+@InputType('ExpenseProposalDecisionSignedDocumentInput')
+export class ExpenseProposalDecisionSignedDocumentInputDTO extends SignedDigitalDocumentInputDTO {
+  @Field(() => ExpenseProposalDecisionSignedMetaDocumentInputDTO, {
+    description: 'Метаинформация решения по СЗ',
+  })
+  public readonly meta!: ExpenseProposalDecisionSignedMetaDocumentInputDTO;
+}

components/controller/src/application/document/documents-dto/expense-proposal-statement-document.dto.ts

@@ -0,0 +1,212 @@
+import { InputType, Field, IntersectionType, OmitType, Int } from '@nestjs/graphql';
+import { IsString, IsNotEmpty, IsArray, ValidateNested, ArrayMinSize, IsInt, IsOptional } from 'class-validator';
+import { Type } from 'class-transformer';
+import { Cooperative } from 'cooptypes';
+import { GenerateMetaDocumentInputDTO } from '~/application/document/dto/generate-meta-document-input.dto';
+import { MetaDocumentInputDTO } from '~/application/document/dto/meta-document-input.dto';
+import { SignedDigitalDocumentInputDTO } from '~/application/document/dto/signed-digital-document-input.dto';
+
+type Action = Cooperative.Registry.ExpenseProposalStatement.Action;
+type ItemAction = Cooperative.Registry.ExpenseProposalStatement.IExpenseItem;
+type HeaderAction = Cooperative.Registry.ExpenseProposalStatement.IExpenseProposalHeader;
+
+/**
+ * Позиция-вход генерации СЗ-документа. Приватные поля (имя/реквизиты/назначение)
+ * — это вход для фабрики: сервер сохраняет их off-chain в doc_data и публикует
+ * в meta только `doc_data_hash`. На on-chain эти поля НЕ попадают.
+ */
+@InputType('ExpenseProposalItemInput')
+class ExpenseProposalItemInputDTO {
+  @Field({ description: 'Порядковый номер строки' })
+  @IsString()
+  number!: string;
+
+  @Field({ description: 'Описание расхода' })
+  @IsString()
+  description!: string;
+
+  @Field({ description: 'Сумма строки' })
+  @IsString()
+  amount!: string;
+
+  @Field({ description: 'Тип получателя (SELF / MEMBER / ORG)' })
+  @IsString()
+  recipient_type!: 'SELF' | 'MEMBER' | 'ORG';
+
+  @Field({ description: 'Способ оплаты (ADVANCE / DIRECT)' })
+  @IsString()
+  mechanics!: 'ADVANCE' | 'DIRECT';
+
+  @Field({ description: 'Имя получателя', nullable: true })
+  @IsOptional()
+  @IsString()
+  recipient_name?: string;
+
+  @Field({ description: 'Реквизиты получателя', nullable: true })
+  @IsOptional()
+  @IsString()
+  requisites?: string;
+
+  @Field({ description: 'Назначение платежа — отдельной строкой после реквизитов', nullable: true })
+  @IsOptional()
+  @IsString()
+  payment_purpose?: string;
+
+  @Field({
+    description:
+      'Идентификатор сохранённых реквизитов получателя-пайщика — сервер подставит полные реквизиты в документ.',
+    nullable: true,
+  })
+  @IsOptional()
+  @IsString()
+  payment_method_id?: string;
+
+  @Field({
+    description: 'Имя аккаунта получателя-пайщика (владелец реквизитов).',
+    nullable: true,
+  })
+  @IsOptional()
+  @IsString()
+  recipient_username?: string;
+}
+
+/**
+ * Публичная позиция подписанной meta — ровно то, что публикуется on-chain.
+ * Без имени/реквизитов/назначения платежа (они off-chain в doc_data).
+ */
+@InputType('ExpenseProposalSignedItemInput')
+class ExpenseProposalSignedItemInputDTO implements ItemAction {
+  @Field({ description: 'Порядковый номер строки' })
+  @IsString()
+  number!: string;
+
+  @Field({ description: 'Описание расхода' })
+  @IsString()
+  description!: string;
+
+  @Field({ description: 'Сумма строки' })
+  @IsString()
+  amount!: string;
+
+  @Field({ description: 'Тип получателя (SELF / MEMBER / ORG)' })
+  @IsString()
+  recipient_type!: 'SELF' | 'MEMBER' | 'ORG';
+
+  @Field({ description: 'Способ оплаты (ADVANCE / DIRECT)' })
+  @IsString()
+  mechanics!: 'ADVANCE' | 'DIRECT';
+}
+
+@InputType('ExpenseProposalHeaderInput')
+class ExpenseProposalHeaderInputDTO implements HeaderAction {
+  @Field({ description: 'Описание цели расходов' })
+  @IsString()
+  description!: string;
+
+  @Field({ description: 'Итоговая сумма расходов' })
+  @IsString()
+  total_amount!: string;
+
+  @Field(() => Int, { description: 'Количество позиций' })
+  @IsInt()
+  items_count!: number;
+
+  @Field({ description: 'Кошелёк-источник' })
+  @IsString()
+  source_wallet!: string;
+
+  @Field({ description: 'Срок исполнения («в срок до»), формат DD.MM.YYYY', nullable: true })
+  @IsOptional()
+  @IsString()
+  deadline?: string;
+
+  @Field({
+    description: 'Фонд списания — подставляется сервером из параметров шасси расходов, передавать не нужно',
+    nullable: true,
+  })
+  @IsOptional()
+  @IsString()
+  fund_name?: string;
+}
+
+/**
+ * База ВХОДА генерации — богатые позиции (приватные поля уйдут в doc_data на
+ * сервере). `doc_data_hash` здесь нет: его вычисляет сервер при генерации.
+ */
+@InputType('BaseExpenseProposalStatementGenerateMetaDocumentInput')
+class BaseExpenseProposalStatementGenerateMetaDocumentInputDTO {
+  @Field({ description: 'Хеш сметы расхода (детерминированный)' })
+  @IsString()
+  @IsNotEmpty()
+  proposal_hash!: string;
+
+  @Field(() => ExpenseProposalHeaderInputDTO, { description: 'Шапка СЗ' })
+  @ValidateNested()
+  @Type(() => ExpenseProposalHeaderInputDTO)
+  proposal!: ExpenseProposalHeaderInputDTO;
+
+  @Field(() => [ExpenseProposalItemInputDTO], { description: 'Позиции расхода' })
+  @IsArray()
+  @ArrayMinSize(1)
+  @ValidateNested({ each: true })
+  @Type(() => ExpenseProposalItemInputDTO)
+  items!: ExpenseProposalItemInputDTO[];
+}
+
+/**
+ * База ПОДПИСАННОЙ meta — ровно то, что подписывается и едет on-chain:
+ * публичные позиции + `doc_data_hash` (реквизиты off-chain).
+ */
+@InputType('BaseExpenseProposalStatementSignedMetaDocumentInput')
+class BaseExpenseProposalStatementSignedMetaDocumentInputDTO implements Omit<Action, 'coopname' | 'username' | 'registry_id' | 'block_num' | 'lang' | 'title' | 'generator' | 'version' | 'created_at' | 'timezone' | 'links'> {
+  @Field({ description: 'Хеш сметы расхода (детерминированный)' })
+  @IsString()
+  @IsNotEmpty()
+  proposal_hash!: string;
+
+  @Field(() => ExpenseProposalHeaderInputDTO, { description: 'Шапка СЗ' })
+  @ValidateNested()
+  @Type(() => ExpenseProposalHeaderInputDTO)
+  proposal!: ExpenseProposalHeaderInputDTO;
+
+  @Field(() => [ExpenseProposalSignedItemInputDTO], { description: 'Публичные позиции расхода (без реквизитов)' })
+  @IsArray()
+  @ArrayMinSize(1)
+  @ValidateNested({ each: true })
+  @Type(() => ExpenseProposalSignedItemInputDTO)
+  items!: ExpenseProposalSignedItemInputDTO[];
+
+  @Field({ description: 'Идентификатор приватных данных документа off-chain (реквизиты/имя/назначение)' })
+  @IsString()
+  @IsNotEmpty()
+  doc_data_hash!: string;
+}
+
+/**
+ * Input генерации документа СЗ-заявления (registry 2010).
+ * Backend через factory собирает PDF, возвращает `IGeneratedDocument` (без подписей).
+ */
+@InputType('ExpenseProposalStatementGenerateDocumentInput')
+export class ExpenseProposalStatementGenerateDocumentInputDTO extends IntersectionType(
+  BaseExpenseProposalStatementGenerateMetaDocumentInputDTO,
+  OmitType(GenerateMetaDocumentInputDTO, ['registry_id'] as const)
+) {
+  registry_id!: number;
+}
+
+@InputType('ExpenseProposalStatementSignedMetaDocumentInput')
+export class ExpenseProposalStatementSignedMetaDocumentInputDTO extends IntersectionType(
+  BaseExpenseProposalStatementSignedMetaDocumentInputDTO,
+  MetaDocumentInputDTO
+) {}
+
+/**
+ * Подписанный документ СЗ-заявления (registry 2010).
+ */
+@InputType('ExpenseProposalStatementSignedDocumentInput')
+export class ExpenseProposalStatementSignedDocumentInputDTO extends SignedDigitalDocumentInputDTO {
+  @Field(() => ExpenseProposalStatementSignedMetaDocumentInputDTO, {
+    description: 'Метаинформация СЗ-заявления',
+  })
+  public readonly meta!: ExpenseProposalStatementSignedMetaDocumentInputDTO;
+}

components/controller/src/application/document/documents-dto/membership-exit-application-document.dto.ts

@@ -0,0 +1,46 @@
+import { InputType, Field, IntersectionType, OmitType } from '@nestjs/graphql';
+import { IsBoolean } from 'class-validator';
+import { Cooperative } from 'cooptypes';
+import { GenerateMetaDocumentInputDTO } from '~/application/document/dto/generate-meta-document-input.dto';
+import { MetaDocumentInputDTO } from '~/application/document/dto/meta-document-input.dto';
+import { SignedDigitalDocumentInputDTO } from '~/application/document/dto/signed-digital-document-input.dto';
+import type { ExcludeCommonProps } from '~/application/document/types';
+
+// интерфейс параметров для генерации
+type action = Cooperative.Registry.ParticipantExitApplication.Action;
+
+@InputType(`BaseMembershipExitApplicationMetaDocumentInput`)
+class BaseMembershipExitApplicationMetaDocumentInputDTO implements ExcludeCommonProps<action> {
+  @Field({
+    description:
+      'Флаг пропуска сохранения документа (используется для предварительной генерации и демонстрации пользователю)',
+  })
+  @IsBoolean()
+  skip_save!: boolean;
+}
+
+@InputType(`MembershipExitApplicationGenerateDocumentInput`)
+export class MembershipExitApplicationGenerateDocumentInputDTO
+  extends IntersectionType(
+    BaseMembershipExitApplicationMetaDocumentInputDTO,
+    OmitType(GenerateMetaDocumentInputDTO, ['registry_id'] as const)
+  )
+  implements action
+{
+  registry_id!: number;
+
+  constructor() {
+    super();
+  }
+}
+
+@InputType(`MembershipExitApplicationSignedMetaDocumentInput`)
+export class MembershipExitApplicationSignedMetaDocumentInputDTO
+  extends IntersectionType(BaseMembershipExitApplicationMetaDocumentInputDTO, MetaDocumentInputDTO)
+  implements action {}
+
+@InputType(`MembershipExitApplicationSignedDocumentInput`)
+export class MembershipExitApplicationSignedDocumentInputDTO extends SignedDigitalDocumentInputDTO {
+  @Field(() => MembershipExitApplicationSignedMetaDocumentInputDTO)
+  public readonly meta!: MembershipExitApplicationSignedMetaDocumentInputDTO;
+}

components/controller/src/application/document/documents-dto/membership-exit-decision-document.dto.ts

@@ -0,0 +1,45 @@
+import { InputType, Field, IntersectionType, OmitType } from '@nestjs/graphql';
+import { IsNumber } from 'class-validator';
+import { Cooperative } from 'cooptypes';
+import { GenerateMetaDocumentInputDTO } from '~/application/document/dto/generate-meta-document-input.dto';
+import { MetaDocumentInputDTO } from '~/application/document/dto/meta-document-input.dto';
+import { SignedDigitalDocumentInputDTO } from '~/application/document/dto/signed-digital-document-input.dto';
+import type { ExcludeCommonProps } from '~/application/document/types';
+
+// интерфейс параметров для генерации
+type action = Cooperative.Registry.DecisionOfParticipantExit.Action;
+
+@InputType(`BaseMembershipExitDecisionMetaDocumentInput`)
+class BaseMembershipExitDecisionMetaDocumentInputDTO implements ExcludeCommonProps<action> {
+  @Field({ description: 'Идентификатор протокола решения собрания совета' })
+  @IsNumber()
+  decision_id!: number;
+}
+
+@InputType(`MembershipExitDecisionGenerateDocumentInput`)
+export class MembershipExitDecisionGenerateDocumentInputDTO
+  extends IntersectionType(
+    BaseMembershipExitDecisionMetaDocumentInputDTO,
+    OmitType(GenerateMetaDocumentInputDTO, ['registry_id'] as const)
+  )
+  implements action
+{
+  registry_id!: number;
+
+  constructor() {
+    super();
+  }
+}
+
+@InputType(`MembershipExitDecisionSignedMetaDocumentInput`)
+export class MembershipExitDecisionSignedMetaDocumentInputDTO
+  extends IntersectionType(BaseMembershipExitDecisionMetaDocumentInputDTO, MetaDocumentInputDTO)
+  implements action {}
+
+@InputType(`MembershipExitDecisionSignedDocumentInput`)
+export class MembershipExitDecisionSignedDocumentInputDTO extends SignedDigitalDocumentInputDTO {
+  @Field(() => MembershipExitDecisionSignedMetaDocumentInputDTO, {
+    description: 'Метаинформация решения собрания совета о выходе пайщика',
+  })
+  public readonly meta!: MembershipExitDecisionSignedMetaDocumentInputDTO;
+}

components/controller/src/application/gateway/adapters/gateway-interactor.adapter.ts

@@ -12,6 +12,7 @@ import type {
 } from '~/domain/common/interfaces/pagination.interface';
 import { PaymentDomainEntity } from '~/domain/gateway/entities/payment-domain.entity';
 import { PaymentStatusEnum } from '~/domain/gateway/enums/payment-status.enum';
+import type { PaymentDomainInterface } from '~/domain/gateway/interfaces/payment-domain.interface';
 
 @Injectable()
 export class GatewayInteractorAdapter implements GatewayInteractorPort {
@@ -36,6 +37,14 @@ export class GatewayInteractorAdapter implements GatewayInteractorPort {
     return await this.gatewayInteractor.createWithdraw(data);
   }
 
+  async prepareWithdraw(data: CreateWithdrawInputDomainInterface): Promise<PaymentDomainInterface> {
+    return await this.gatewayInteractor.prepareWithdraw(data);
+  }
+
+  async persistWithdraw(paymentData: PaymentDomainInterface): Promise<PaymentDomainEntity> {
+    return await this.gatewayInteractor.persistWithdraw(paymentData);
+  }
+
   async setPaymentStatus(data: SetPaymentStatusInputDomainInterface): Promise<PaymentDomainEntity> {
     return await this.gatewayInteractor.setPaymentStatus(data);
   }

components/controller/src/application/gateway/dto/payment-file.output.ts

@@ -0,0 +1,65 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql';
+import { PaymentFileKind } from '~/domain/gateway/enums/payment-file-kind.enum';
+import type { IPaymentFileDatabaseData } from '~/domain/gateway/interfaces/payment-file-database.interface';
+
+/**
+ * Output DTO записи о файле платежа (чеке об оплате) в MinIO-бакете.
+ *
+ * `read_url` — короткоживущий HMAC-signed URL (TTL = `defaultUrlTtlSeconds` бакета),
+ * выдаётся после проверки прав; держатель URL может скачать файл до истечения TTL.
+ */
+@ObjectType('PaymentFile', { description: 'Запись о файле, приложенном к платежу (чек об оплате).' })
+export class PaymentFileOutputDTO {
+  @Field(() => Int, { description: 'Внутренний ID записи.' })
+  id!: number;
+
+  @Field(() => String, { description: 'Имя кооператива (scope).' })
+  coopname!: string;
+
+  @Field(() => String, { description: 'Хеш платежа.' })
+  payment_hash!: string;
+
+  @Field(() => PaymentFileKind, { description: 'Назначение файла.' })
+  kind!: PaymentFileKind;
+
+  @Field(() => String, { description: 'SHA-256 содержимого, hex-lowercase.' })
+  checksum_sha256!: string;
+
+  @Field(() => String, { description: 'MIME-тип содержимого.' })
+  mime_type!: string;
+
+  @Field(() => Int, { description: 'Размер файла в байтах.' })
+  size_bytes!: number;
+
+  @Field(() => String, { description: 'MinIO-ключ внутри бакета.' })
+  storage_key!: string;
+
+  @Field(() => String, { nullable: true, description: 'Оригинальное имя загруженного файла.' })
+  original_filename?: string;
+
+  @Field(() => String, { description: 'Кто загрузил (username).' })
+  uploaded_by_username!: string;
+
+  @Field(() => Date, { description: 'Когда загружено.' })
+  uploaded_at!: Date;
+
+  @Field(() => String, { nullable: true, description: 'Короткоживущий URL на скачивание (HMAC-signed).' })
+  read_url?: string;
+
+  static fromDomain(data: IPaymentFileDatabaseData, readUrl?: string): PaymentFileOutputDTO {
+    const dto = new PaymentFileOutputDTO();
+    dto.id = data.id ?? 0;
+    dto.coopname = data.coopname;
+    dto.payment_hash = data.payment_hash;
+    dto.kind = data.kind;
+    dto.checksum_sha256 = data.checksum_sha256;
+    dto.mime_type = data.mime_type;
+    dto.size_bytes = data.size_bytes;
+    dto.storage_key = data.storage_key;
+    dto.original_filename = data.original_filename ?? undefined;
+    dto.uploaded_by_username = data.uploaded_by_username;
+    dto.uploaded_at = data.uploaded_at;
+    dto.read_url = readUrl;
+    return dto;
+  }
+}

components/controller/src/application/gateway/dto/payment-filters-input.dto.ts

@@ -28,4 +28,10 @@ export class PaymentFiltersInputDTO implements PaymentFiltersDomainInterface {
 
   @Field(() => String, { nullable: true, description: 'Хэш платежа' })
   hash?: string;
+
+  @Field(() => String, {
+    nullable: true,
+    description: 'Хэш расхода (служебной записки): вернёт все платежи, связанные с этим расходом',
+  })
+  proposal_hash?: string;
 }

components/controller/src/application/gateway/dto/upload-payment-proof.input.ts

@@ -0,0 +1,47 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { IsBase64, IsIn, IsInt, IsNotEmpty, IsOptional, IsString, Matches, Max, Min } from 'class-validator';
+
+const ALLOWED_MIME = ['image/jpeg', 'image/png', 'image/webp', 'image/heic', 'application/pdf'] as const;
+
+/**
+ * Input для `uploadPaymentProof` — приложить чек об оплате к платежу.
+ *
+ * Привязка по `payment_hash`. MVP-передача: base64-содержимое внутри mutation
+ * (до 20 МБ — хватает для фото/PDF чека). Вид файла всегда PAYMENT_PROOF
+ * (чек об оплате) — поэтому в input не выносится.
+ */
+@InputType('UploadPaymentProofInput')
+export class UploadPaymentProofInputDTO {
+  @Field(() => String, { description: 'Имя кооператива.' })
+  @IsNotEmpty()
+  @IsString()
+  coopname!: string;
+
+  @Field(() => String, { description: 'Хеш платежа, к которому прикладывается чек.' })
+  @IsNotEmpty()
+  @IsString()
+  payment_hash!: string;
+
+  @Field(() => String, { description: 'MIME-тип содержимого.' })
+  @IsIn([...ALLOWED_MIME], { message: 'mime_type должен быть одним из allowed.' })
+  mime_type!: string;
+
+  @Field(() => String, { nullable: true, description: 'Оригинальное имя файла — для отображения и поиска.' })
+  @IsOptional()
+  @IsString()
+  original_filename?: string;
+
+  @Field(() => Number, { description: 'Размер файла в байтах (для серверной валидации).' })
+  @IsInt()
+  @Min(1)
+  @Max(20 * 1024 * 1024)
+  size_bytes!: number;
+
+  @Field(() => String, { description: 'SHA-256 содержимого, hex-lowercase (64 hex-символа).' })
+  @Matches(/^[a-f0-9]{64}$/, { message: 'checksum_sha256 должен быть 64-символьным lowercase hex.' })
+  checksum_sha256!: string;
+
+  @Field(() => String, { description: 'Содержимое файла, base64 без префикса data:.' })
+  @IsBase64()
+  content_base64!: string;
+}

components/controller/src/application/gateway/gateway.module.ts

@@ -1,6 +1,8 @@
 import { Module, forwardRef } from '@nestjs/common';
 import { GatewayResolver } from './resolvers/gateway.resolver';
+import { PaymentFilesResolver } from './resolvers/payment-files.resolver';
 import { GatewayService } from './services/gateway.service';
+import { PaymentFilesService } from './services/payment-files.service';
 import { PaymentNotificationService } from './services/payment-notification.service';
 import { WithdrawAuthorizationListener } from './services/withdraw-authorization.listener';
 import { PaymentController } from './controllers/payment.controller';
@@ -13,6 +15,7 @@ import { SystemModule } from '~/application/system/system.module';
 import { GatewayInfrastructureModule } from '~/infrastructure/gateway/gateway-infrastructure.module';
 import { UserInfrastructureModule } from '~/infrastructure/user/user-infrastructure.module';
 import { RedisModule } from '~/infrastructure/redis/redis.module';
+import { FileStorageInfrastructureModule } from '~/infrastructure/file-storage';
 
 @Module({
   imports: [
@@ -24,16 +27,20 @@ import { RedisModule } from '~/infrastructure/redis/redis.module';
     AccountInfrastructureModule,
     SystemModule,
     RedisModule,
+    // Чек об оплате (gateway:files) — ядровый механизм, бакет по @UseBucket.
+    FileStorageInfrastructureModule.forFeature([PaymentFilesService]),
   ],
   controllers: [PaymentController],
   providers: [
     GatewayResolver,
+    PaymentFilesResolver,
     GatewayService,
+    PaymentFilesService,
     PaymentNotificationService,
     GatewayInteractor,
     GatewayNotificationHandler,
     WithdrawAuthorizationListener,
   ],
-  exports: [GatewayService, PaymentNotificationService, GatewayInteractor],
+  exports: [GatewayService, PaymentNotificationService, GatewayInteractor, PaymentFilesService],
 })
 export class GatewayModule {}

components/controller/src/application/gateway/interactors/gateway.interactor.ts

@@ -26,6 +26,7 @@ import { AccountType } from '~/application/account/enum/account-type.enum';
 import { PaymentMethodRepository, PAYMENT_METHOD_REPOSITORY } from '~/domain/common/repositories/payment-method.repository';
 import type { PaymentDetailsDomainInterface } from '~/domain/gateway/interfaces/payment-domain.interface';
 import { AccountDomainPort, ACCOUNT_DOMAIN_PORT } from '~/domain/account/ports/account-domain.port';
+import { INTER_EXPENSE_CHASSIS, type InterExpenseChassisPort } from '@coopenomics/inter';
 
 /**
  * Интерактор домена gateway для управления платежами (просмотр, изменение статуса и создание)
@@ -54,7 +55,9 @@ export class GatewayInteractor {
     @Inject(ACCOUNT_DOMAIN_SERVICE)
     private readonly accountDomainService: AccountDomainService,
     @Inject(PAYMENT_METHOD_REPOSITORY)
-    private readonly paymentMethodRepository: PaymentMethodRepository
+    private readonly paymentMethodRepository: PaymentMethodRepository,
+    @Inject(INTER_EXPENSE_CHASSIS)
+    private readonly expenseChassis: InterExpenseChassisPort
   ) {}
 
   /**
@@ -185,6 +188,25 @@ export class GatewayInteractor {
           await this.paymentRepository.update(payment.id, { status: PaymentStatusEnum.COMPLETED });
         }
         this.logger.log(`Пользователь ${payment.username} внес паевой взнос на сумму ${blockchainFormattedQuantity}`);
+      } else if (payment.type === PaymentTypeEnum.EXPENSE_RETURN) {
+        // Возврат неиспользованного аванса под отчёт (недорасход): пайщик отчитался
+        // о факте меньше выданного аванса и вернул разницу на расчётный счёт.
+        // Подтверждение приёма средств кассиром проводит on-chain
+        // expense::returnexp (TRANSFER подотчёт → пул на сумму возврата), затем
+        // expense::reportexp закрывает позицию на фактически потраченную часть.
+        // Это НЕ паевой взнос — completeIncome здесь не вызывается (другая ledger2-
+        // семантика). proposal_hash и item_hash — в blockchain_data.
+        const bc = payment.blockchain_data as { proposal_hash?: string; item_hash?: string } | undefined;
+        if (!bc?.proposal_hash || !bc?.item_hash) {
+          throw new Error(`У платежа возврата ${payment.hash} нет proposal_hash/item_hash в blockchain_data`);
+        }
+        const returnAmount = QuantityUtils.formatQuantityForBlockchain(payment.quantity, payment.symbol);
+        await this.expenseChassis.returnItem(payment.coopname, bc.proposal_hash, bc.item_hash, returnAmount);
+        await this.expenseChassis.reportItem(payment.coopname, bc.proposal_hash, bc.item_hash);
+        if (payment.id) {
+          await this.paymentRepository.update(payment.id, { status: PaymentStatusEnum.COMPLETED });
+        }
+        this.logger.log(`Возврат недорасхода ${payment.hash} (СЗ ${bc.proposal_hash}) проведён on-chain (returnexp + reportexp)`);
       }
     } catch (e: any) {
       if (payment.id) {
@@ -246,6 +268,62 @@ export class GatewayInteractor {
       return;
     }
 
+    // Оплата позиции СЗ-расхода: подтверждение кассой проводит on-chain
+    // expense::payexp (ledger2-проводка по механике позиции — аванс/оплата по
+    // счёту). Реквизиты и назначение платежа в чейн не уходят — они живут
+    // только в этом платеже и снимке шасси. proposal_hash — в blockchain_data
+    // (hash платежа = item_hash, его одного payexp недостаточно).
+    if (payment.type === PaymentTypeEnum.EXPENSE) {
+      const proposalHash = (payment.blockchain_data as { proposal_hash?: string } | undefined)?.proposal_hash;
+      try {
+        if (!proposalHash) {
+          throw new Error(`У платежа расхода ${payment.hash} отсутствует proposal_hash в blockchain_data`);
+        }
+        const actualAmount = QuantityUtils.formatQuantityForBlockchain(payment.quantity, payment.symbol);
+        await this.expenseChassis.payItem(payment.coopname, proposalHash, payment.hash, actualAmount);
+        if (payment.id) {
+          await this.paymentRepository.update(payment.id, { status: PaymentStatusEnum.COMPLETED });
+        }
+        this.logger.log(`Оплата позиции расхода ${payment.hash} (СЗ ${proposalHash}) проведена on-chain (payexp)`);
+      } catch (e: any) {
+        const message = e?.message ?? String(e);
+        if (payment.id) {
+          await this.paymentRepository.update(payment.id, { status: PaymentStatusEnum.FAILED, message });
+        }
+        this.logger.error(`Ошибка оплаты позиции расхода ${payment.hash}: ${message}`, e);
+      }
+      return;
+    }
+
+    // Доплата при перерасходе аванса под отчёт: пайщик отчитался о факте больше
+    // выданного аванса, кооператив доплачивает разницу. Подтверждение выплаты
+    // кассиром проводит on-chain expense::overspendexp (TRANSFER пул → подотчёт на
+    // сумму доплаты), затем expense::reportexp закрывает позицию на полный факт.
+    // proposal_hash и item_hash — в blockchain_data (hash платежа уникальный, не
+    // равен item_hash, чтобы не пересекаться с платежом выдачи аванса).
+    if (payment.type === PaymentTypeEnum.EXPENSE_OVERSPEND) {
+      const bc = payment.blockchain_data as { proposal_hash?: string; item_hash?: string } | undefined;
+      try {
+        if (!bc?.proposal_hash || !bc?.item_hash) {
+          throw new Error(`У платежа доплаты ${payment.hash} нет proposal_hash/item_hash в blockchain_data`);
+        }
+        const overspendAmount = QuantityUtils.formatQuantityForBlockchain(payment.quantity, payment.symbol);
+        await this.expenseChassis.overspendItem(payment.coopname, bc.proposal_hash, bc.item_hash, overspendAmount);
+        await this.expenseChassis.reportItem(payment.coopname, bc.proposal_hash, bc.item_hash);
+        if (payment.id) {
+          await this.paymentRepository.update(payment.id, { status: PaymentStatusEnum.COMPLETED });
+        }
+        this.logger.log(`Доплата перерасхода ${payment.hash} (СЗ ${bc.proposal_hash}) проведена on-chain (overspendexp + reportexp)`);
+      } catch (e: any) {
+        const message = e?.message ?? String(e);
+        if (payment.id) {
+          await this.paymentRepository.update(payment.id, { status: PaymentStatusEnum.FAILED, message });
+        }
+        this.logger.error(`Ошибка доплаты перерасхода ${payment.hash}: ${message}`, e);
+      }
+      return;
+    }
+
     try {
       const completeOutcomeData: CompleteOutcomeDomainInterface = {
         coopname: payment.coopname,
@@ -509,9 +587,16 @@ export class GatewayInteractor {
   }
 
   /**
-   * Создать исходящий платеж (withdraw)
+   * Подготовить исходящий платеж (withdraw) к созданию: все валидации + сборка
+   * записи, но БЕЗ записи в БД.
+   *
+   * Вынесено отдельно от персиста, чтобы вызывающий мог сначала провести
+   * валидацию, затем выполнить on-chain транзакцию, и только при её успехе
+   * зафиксировать платёж (см. WalletInteractor.createWithdraw). Иначе при
+   * отклонении транзакции блокчейном (например, недостаточно L3-средств) в
+   * разделе «Платежи» оставался бы фантомный исходящий платёж со статусом FAILED.
    */
-  async createWithdraw(data: CreateWithdrawPaymentInputDomainInterface): Promise<PaymentDomainEntity> {
+  async prepareWithdraw(data: CreateWithdrawPaymentInputDomainInterface): Promise<PaymentDomainInterface> {
     // Обновляем истекшие платежи перед созданием нового
     await this.paymentRepository.expireOutdatedPayments();
 
@@ -580,7 +665,14 @@ export class GatewayInteractor {
       hash: data.payment_hash, // Используем переданный payment_hash
     };
 
-    // Создаем платеж в базе данных
+    return paymentData;
+  }
+
+  /**
+   * Зафиксировать ранее подготовленный исходящий платеж в БД.
+   * Вызывается только после успешной on-chain транзакции.
+   */
+  async persistWithdraw(paymentData: PaymentDomainInterface): Promise<PaymentDomainEntity> {
     const createdPayment = await this.paymentRepository.create(paymentData);
 
     if (!createdPayment.id) {
@@ -588,12 +680,24 @@ export class GatewayInteractor {
     }
 
     this.logger.log(
-      `Создан исходящий платеж ${data.payment_hash} для пользователя ${data.username} на сумму ${data.quantity} ${data.symbol} с платежным методом ${data.method_id}`
+      `Создан исходящий платеж ${paymentData.hash} для пользователя ${paymentData.username} на сумму ${paymentData.quantity} ${paymentData.symbol} с платежным методом ${paymentData.payment_method_id}`
     );
 
     return new PaymentDomainEntity(createdPayment);
   }
 
+  /**
+   * Создать исходящий платеж (withdraw): подготовка + немедленный персист.
+   *
+   * Не использует on-chain проверку — подходит только там, где запись о платеже
+   * в БД должна существовать безусловно. Для возврата паевого взноса используется
+   * связка prepareWithdraw → on-chain транзакция → persistWithdraw.
+   */
+  async createWithdraw(data: CreateWithdrawPaymentInputDomainInterface): Promise<PaymentDomainEntity> {
+    const paymentData = await this.prepareWithdraw(data);
+    return await this.persistWithdraw(paymentData);
+  }
+
   /**
    * Обновить все истекшие платежи в статус EXPIRED
    * Может вызываться периодически или по требованию

components/controller/src/application/gateway/resolvers/payment-files.resolver.ts

@@ -0,0 +1,60 @@
+import { Args, Int, Mutation, Query, Resolver } from '@nestjs/graphql';
+import { UseGuards } from '@nestjs/common';
+import { GqlJwtAuthGuard } from '~/application/auth/guards/graphql-jwt-auth.guard';
+import { RolesGuard } from '~/application/auth/guards/roles.guard';
+import { AuthRoles } from '~/application/auth/decorators/auth.decorator';
+import { CurrentUser } from '~/application/auth/decorators/current-user.decorator';
+import type { MonoAccountDomainInterface } from '~/domain/account/interfaces/mono-account-domain.interface';
+import { PaymentFilesService } from '../services/payment-files.service';
+import { UploadPaymentProofInputDTO } from '../dto/upload-payment-proof.input';
+import { PaymentFileOutputDTO } from '../dto/payment-file.output';
+
+/**
+ * GraphQL для чеков об оплате платежей (ядро gateway).
+ *
+ * - Прикладывает чек кассир (chairman/member) — подтверждение исполненной оплаты.
+ * - Списки и read-URL видят те же роли и пайщик (свой чек). ACL уточнится после E2E.
+ */
+@Resolver(() => PaymentFileOutputDTO)
+export class PaymentFilesResolver {
+  constructor(private readonly paymentFiles: PaymentFilesService) {}
+
+  @Mutation(() => PaymentFileOutputDTO, {
+    name: 'uploadPaymentProof',
+    description: 'Приложить чек об оплате к платежу (бакет gateway:files).',
+  })
+  @UseGuards(GqlJwtAuthGuard, RolesGuard)
+  @AuthRoles(['chairman', 'member'])
+  async uploadPaymentProof(
+    @Args('data', { type: () => UploadPaymentProofInputDTO }) data: UploadPaymentProofInputDTO,
+    @CurrentUser() user: MonoAccountDomainInterface
+  ): Promise<PaymentFileOutputDTO> {
+    const { data: saved, readUrl } = await this.paymentFiles.uploadProof(data, user.username);
+    return PaymentFileOutputDTO.fromDomain(saved, readUrl);
+  }
+
+  @Query(() => PaymentFileOutputDTO, {
+    name: 'paymentFile',
+    description: 'Получить запись о файле платежа + свежий короткоживущий read-URL.',
+  })
+  @UseGuards(GqlJwtAuthGuard, RolesGuard)
+  @AuthRoles(['chairman', 'member', 'user'])
+  async getPaymentFile(@Args('id', { type: () => Int }) id: number): Promise<PaymentFileOutputDTO> {
+    const { data, readUrl } = await this.paymentFiles.getReadUrl(id);
+    return PaymentFileOutputDTO.fromDomain(data, readUrl);
+  }
+
+  @Query(() => [PaymentFileOutputDTO], {
+    name: 'paymentProofs',
+    description: 'Список чеков об оплате платежа (без read-URL — запрос отдельно по id).',
+  })
+  @UseGuards(GqlJwtAuthGuard, RolesGuard)
+  @AuthRoles(['chairman', 'member', 'user'])
+  async listByPayment(
+    @Args('coopname', { type: () => String }) coopname: string,
+    @Args('payment_hash', { type: () => String }) paymentHash: string
+  ): Promise<PaymentFileOutputDTO[]> {
+    const items = await this.paymentFiles.listByPayment(coopname, paymentHash);
+    return items.map((d) => PaymentFileOutputDTO.fromDomain(d));
+  }
+}

components/controller/src/application/gateway/services/payment-files.service.ts

@@ -0,0 +1,151 @@
+import {
+  BadRequestException,
+  ConflictException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { createHash } from 'crypto';
+import type { InterFileStorageBucket } from '@coopenomics/inter';
+import { InjectBucket, UseBucket } from '~/infrastructure/file-storage';
+import { PAYMENT_REPOSITORY, type PaymentRepository } from '~/domain/gateway/repositories/payment.repository';
+import {
+  PAYMENT_FILE_REPOSITORY,
+  type PaymentFileRepository,
+} from '~/domain/gateway/repositories/payment-file.repository';
+import type { IPaymentFileDatabaseData } from '~/domain/gateway/interfaces/payment-file-database.interface';
+import { PaymentFileKind } from '~/domain/gateway/enums/payment-file-kind.enum';
+import { GATEWAY_BUCKET } from '~/domain/gateway/constants/gateway-bucket';
+import { UploadPaymentProofInputDTO } from '../dto/upload-payment-proof.input';
+
+const EXTENSION_BY_MIME: Record<string, string> = {
+  'image/jpeg': 'jpg',
+  'image/png': 'png',
+  'image/webp': 'webp',
+  'image/heic': 'heic',
+  'application/pdf': 'pdf',
+};
+
+/**
+ * Ядровый сервис файлов платежей: чек об оплате исходящего платежа.
+ *
+ * «Культура денег»: входящие подтверждаем, исходящие сопровождаем чеком.
+ * Привязка по `payment_hash` — единый ключ любого платежа, поэтому механизм
+ * один на все исходящие (возврат паевого/withdrawal/registration-refund/аванс
+ * расхода) и переиспользуется расширениями. Контроль мягкий: статус платежа не
+ * трогаем (деньги уже ушли on-chain), но зеркалим число чеков в
+ * `blockchain_data.proof_count` — реестр по нему рисует «чек приложен / нет».
+ *
+ * Ключ MinIO детерминирован: `{coopname}/gateway/{payment_hash}/{kind}/{checksum}.{ext}`.
+ * Повторная загрузка того же содержимого идемпотентна на бакете, в БД защищаемся
+ * явным `findByChecksum` (409 при дубле).
+ */
+@UseBucket(GATEWAY_BUCKET)
+@Injectable()
+export class PaymentFilesService {
+  constructor(
+    @InjectBucket() private readonly bucket: InterFileStorageBucket,
+    @Inject(PAYMENT_FILE_REPOSITORY) private readonly files: PaymentFileRepository,
+    @Inject(PAYMENT_REPOSITORY) private readonly payments: PaymentRepository
+  ) {}
+
+  async uploadProof(
+    input: UploadPaymentProofInputDTO,
+    uploadedByUsername: string
+  ): Promise<{ data: IPaymentFileDatabaseData; readUrl: string }> {
+    const body = Buffer.from(input.content_base64, 'base64');
+    if (body.byteLength !== input.size_bytes) {
+      throw new BadRequestException(
+        `size_bytes (${input.size_bytes}) не совпадает с фактическим размером base64-контента (${body.byteLength}).`
+      );
+    }
+    const actualChecksum = createHash('sha256').update(body).digest('hex');
+    if (actualChecksum !== input.checksum_sha256.toLowerCase()) {
+      throw new BadRequestException(`checksum_sha256 не совпадает с реальным SHA-256 содержимого.`);
+    }
+
+    const payment = await this.payments.findByHash(input.payment_hash);
+    if (!payment) {
+      throw new NotFoundException(`Платёж ${input.payment_hash} не найден.`);
+    }
+
+    const existing = await this.files.findByChecksum(input.coopname, actualChecksum);
+    if (existing) {
+      throw new ConflictException(
+        `Файл с таким SHA-256 уже зарегистрирован в этом кооперативе (id=${existing.id}).`
+      );
+    }
+
+    const storageKey = this.buildKey({
+      coopname: input.coopname,
+      paymentHash: input.payment_hash,
+      kind: PaymentFileKind.PAYMENT_PROOF,
+      checksum: actualChecksum,
+      mimeType: input.mime_type,
+    });
+
+    await this.bucket.put(storageKey, new Uint8Array(body), { contentType: input.mime_type });
+
+    const saved = await this.files.create({
+      coopname: input.coopname,
+      payment_hash: input.payment_hash.toLowerCase(),
+      kind: PaymentFileKind.PAYMENT_PROOF,
+      checksum_sha256: actualChecksum,
+      mime_type: input.mime_type,
+      size_bytes: body.byteLength,
+      storage_key: storageKey,
+      original_filename: input.original_filename ?? null,
+      uploaded_by_username: uploadedByUsername,
+      uploaded_at: new Date(),
+    });
+
+    await this.syncProofMark(saved.coopname, saved.payment_hash);
+
+    const readUrl = await this.bucket.getReadUrl(storageKey);
+    return { data: saved, readUrl };
+  }
+
+  async getReadUrl(fileId: number): Promise<{ data: IPaymentFileDatabaseData; readUrl: string }> {
+    const file = await this.files.findById(fileId);
+    if (!file) throw new NotFoundException(`Файл платежа #${fileId} не найден.`);
+    const readUrl = await this.bucket.getReadUrl(file.storage_key);
+    return { data: file, readUrl };
+  }
+
+  async listByPayment(coopname: string, paymentHash: string): Promise<IPaymentFileDatabaseData[]> {
+    return this.files.findByPayment(coopname, paymentHash.toLowerCase());
+  }
+
+  async deleteFile(fileId: number): Promise<void> {
+    const file = await this.files.findById(fileId);
+    if (!file) throw new NotFoundException(`Файл платежа #${fileId} не найден.`);
+    await this.bucket.delete(file.storage_key);
+    await this.files.delete(fileId);
+    await this.syncProofMark(file.coopname, file.payment_hash);
+  }
+
+  /**
+   * Зеркалит число приложенных чеков в платёж (`blockchain_data.proof_count`) —
+   * реестр показывает по нему «чек приложен / не приложен», не дёргая хранилище
+   * файлов на каждую строку. Статус платежа не трогаем (им управляет gateway).
+   */
+  private async syncProofMark(coopname: string, paymentHash: string): Promise<void> {
+    const payment = await this.payments.findByHash(paymentHash);
+    if (!payment?.id) return;
+    const proofs = await this.files.findByPayment(coopname, paymentHash);
+    await this.payments.update(payment.id, {
+      blockchain_data: { ...(payment.blockchain_data ?? {}), proof_count: proofs.length },
+    });
+  }
+
+  private buildKey(params: {
+    coopname: string;
+    paymentHash: string;
+    kind: PaymentFileKind;
+    checksum: string;
+    mimeType: string;
+  }): string {
+    const ext = EXTENSION_BY_MIME[params.mimeType] ?? 'bin';
+    return `${params.coopname}/gateway/${params.paymentHash.toLowerCase()}/${params.kind}/${params.checksum}.${ext}`;
+  }
+}

components/controller/src/application/gateway/services/payment-notification.service.ts

@@ -55,9 +55,10 @@ export class PaymentNotificationService implements OnModuleInit {
       // Получаем отображаемое имя пользователя
       const userName = await this.accountPort.getDisplayName(payment.username);
 
-      // Выбираем workflow по статусу И направлению платежа: исходящий PAID — это
-      // возврат взноса пайщику, у него своё уведомление «Возврат выполнен», а не
-      // «Платёж принят» (иначе пайщик при возврате получает письмо как на приём).
+      // Выбираем workflow по статусу И направлению — но БЕЗ привязки к типу платежа
+      // (мы не всегда знаем, это возврат взноса, аванс под отчёт или доплата).
+      // Исходящий PAID → пайщик получил деньги → «Платёж выполнен»; входящий PAID →
+      // кооператив принял платёж пайщика → «Платёж принят». Оба текста универсальны.
       const isOutgoing = payment.direction === PaymentDirectionEnum.OUTGOING;
       const workflowId =
         payment.status === PaymentStatusEnum.PAID

components/controller/src/application/membership-exit/dto/create-membership-exit-input.dto.ts

@@ -0,0 +1,31 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { IsString, ValidateNested, IsNotEmpty } from 'class-validator';
+import { Type } from 'class-transformer';
+import type { CreateMembershipExitInputDomainInterface } from '~/domain/account/interfaces/create-membership-exit-input.interface';
+import { MembershipExitApplicationSignedDocumentInputDTO } from '~/application/document/documents-dto/membership-exit-application-document.dto';
+
+/**
+ * DTO подачи заявления на выход пайщика из кооператива.
+ */
+@InputType('CreateMembershipExitInput')
+export class CreateMembershipExitInputDTO implements CreateMembershipExitInputDomainInterface {
+  @Field(() => String, { description: 'Имя аккаунта кооператива' })
+  @IsString()
+  coopname!: string;
+
+  @Field(() => String, { description: 'Имя пайщика, выходящего из кооператива' })
+  @IsString()
+  username!: string;
+
+  @Field(() => String, { description: 'Хеш процесса выхода (генерируется на клиенте)' })
+  @IsString()
+  exit_hash!: string;
+
+  @Field(() => MembershipExitApplicationSignedDocumentInputDTO, {
+    description: 'Подписанное пайщиком заявление о выходе из кооператива',
+  })
+  @ValidateNested()
+  @IsNotEmpty({ message: 'Поле "statement" обязательно для заполнения.' })
+  @Type(() => MembershipExitApplicationSignedDocumentInputDTO)
+  statement!: MembershipExitApplicationSignedDocumentInputDTO;
+}

components/controller/src/application/membership-exit/dto/membership-exit-result.dto.ts

@@ -0,0 +1,16 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { MembershipExitStatus } from '../enums/membership-exit-status.enum';
+
+/**
+ * Результат подачи заявления на выход из кооператива.
+ */
+@ObjectType('MembershipExitResult')
+export class MembershipExitResultDTO {
+  @Field(() => String, { description: 'Хеш созданного процесса выхода' })
+  exit_hash!: string;
+
+  @Field(() => MembershipExitStatus, {
+    description: 'Статус процесса выхода после подачи (ожидает подтверждения по ссылке из письма)',
+  })
+  status!: MembershipExitStatus;
+}

components/controller/src/application/membership-exit/dto/membership-exit-return-preview.dto.ts

@@ -0,0 +1,20 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+
+/**
+ * Предварительный расчёт суммы возврата паевого взноса при выходе.
+ *
+ * Считается по L3-балансам ledger2 на момент запроса. Итоговую сумму при
+ * одобрении совет фиксирует контракт (registrator::confirmexit), поэтому это
+ * ориентир для пайщика, а не обязательство.
+ */
+@ObjectType('MembershipExitReturnPreview')
+export class MembershipExitReturnPreviewDTO {
+  @Field(() => String, { description: 'Итоговая сумма к возврату (минимальный + целевой паевой)' })
+  total!: string;
+
+  @Field(() => String, { description: 'Целевой паевой взнос пайщика' })
+  share_contribution!: string;
+
+  @Field(() => String, { description: 'Минимальный паевой взнос пайщика' })
+  minimum_contribution!: string;
+}

components/controller/src/application/membership-exit/dto/membership-exit.dto.ts

@@ -0,0 +1,28 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { PaymentStatusEnum } from '~/domain/gateway/enums/payment-status.enum';
+import { MembershipExitStatus } from '../enums/membership-exit-status.enum';
+
+/**
+ * Текущий процесс выхода пайщика из кооператива (если активен).
+ */
+@ObjectType('MembershipExit')
+export class MembershipExitDTO {
+  @Field(() => String, { description: 'Хеш процесса выхода' })
+  exit_hash!: string;
+
+  @Field(() => MembershipExitStatus, { description: 'Статус процесса выхода' })
+  status!: MembershipExitStatus;
+
+  @Field(() => String, { description: 'Сумма к возврату (фиксируется советом при одобрении; до одобрения — 0)' })
+  quantity!: string;
+
+  @Field(() => PaymentStatusEnum, {
+    nullable: true,
+    description:
+      'Статус исходящего платежа возврата паевого взноса в реестре кассира. Создаётся при одобрении советом; null — платёж ещё не заведён.',
+  })
+  payment_status?: PaymentStatusEnum;
+
+  @Field(() => String, { description: 'Дата подачи заявления на выход' })
+  created_at!: string;
+}

components/controller/src/application/membership-exit/enums/membership-exit-status.enum.ts

@@ -0,0 +1,23 @@
+import { registerEnumType } from '@nestjs/graphql';
+
+/**
+ * Статус процесса выхода пайщика из кооператива (registrator::exits.status).
+ */
+export enum MembershipExitStatus {
+  // Заявление подписано и принято, но в блокчейн ещё не отправлено —
+  // ожидает подтверждения пайщиком по ссылке из письма (off-chain фаза).
+  AWAITING_CONFIRMATION = 'awaiting_confirmation',
+  // Заявление подано в блокчейн, ожидает решения совета.
+  PENDING = 'pending',
+  // Совет одобрил, идёт возврат паевого взноса (зарезервирован, исходящий платёж).
+  AUTHORIZED = 'authorized',
+  // Выход завершён: возврат оплачен, аккаунт заблокирован, пайщик вышел.
+  // exits-строка на цепи уже стёрта (терминал=erase) — статус восстанавливаем
+  // по blocked-аккаунту и завершённому MEMBERSHIP_EXIT-платежу.
+  COMPLETED = 'completed',
+}
+
+registerEnumType(MembershipExitStatus, {
+  name: 'MembershipExitStatus',
+  description: 'Статус процесса выхода пайщика из кооператива',
+});

components/controller/src/application/membership-exit/membership-exit.module.ts

@@ -0,0 +1,35 @@
+import { Module, forwardRef } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { MembershipExitResolver } from './resolvers/membership-exit.resolver';
+import { MembershipExitService } from './services/membership-exit.service';
+import { MembershipExitAuthorizationListener } from './services/membership-exit-authorization.listener';
+import { ParticipantModule } from '../participant/participant.module';
+import { TokenApplicationModule } from '../token/token-application.module';
+import { NotificationModule } from '../notification/notification.module';
+import { SystemModule } from '../system/system.module';
+import { UserDomainModule } from '~/domain/user/user-domain.module';
+import { EventsInfrastructureModule } from '~/infrastructure/events/events.module';
+import { MembershipExitRequestEntity } from '~/infrastructure/database/typeorm/entities/membership-exit-request.entity';
+
+/**
+ * Модуль выхода пайщика из кооператива: генерация документов выхода (200/201),
+ * подача заявления с подтверждением по email (off-chain черновик → токен →
+ * письмо → confirm → registrator::exitcoop) и предрасчёт суммы возврата паевого.
+ *
+ * Порты ACCOUNT_BLOCKCHAIN_PORT / BLOCKCHAIN_PORT / USER_WALLET_REPOSITORY
+ * предоставляются глобальными модулями (blockchain.module, typeorm.module).
+ */
+@Module({
+  imports: [
+    ParticipantModule,
+    TypeOrmModule.forFeature([MembershipExitRequestEntity]),
+    forwardRef(() => TokenApplicationModule),
+    forwardRef(() => NotificationModule),
+    SystemModule,
+    UserDomainModule,
+    EventsInfrastructureModule,
+  ],
+  providers: [MembershipExitResolver, MembershipExitService, MembershipExitAuthorizationListener],
+  exports: [MembershipExitService],
+})
+export class MembershipExitModule {}

components/controller/src/application/membership-exit/resolvers/membership-exit.resolver.ts

@@ -0,0 +1,133 @@
+import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
+import { ForbiddenException, UseGuards } from '@nestjs/common';
+import { Throttle } from '@nestjs/throttler';
+import { GqlJwtAuthGuard } from '~/application/auth/guards/graphql-jwt-auth.guard';
+import { RolesGuard } from '~/application/auth/guards/roles.guard';
+import { AuthRoles } from '~/application/auth/decorators/auth.decorator';
+import { CurrentUser } from '~/application/auth/decorators/current-user.decorator';
+import { MonoAccountDomainInterface } from '~/domain/account/interfaces/mono-account-domain.interface';
+import { GeneratedDocumentDTO } from '~/application/document/dto/generated-document.dto';
+import { GenerateDocumentOptionsInputDTO } from '~/application/document/dto/generate-document-options-input.dto';
+import { MembershipExitApplicationGenerateDocumentInputDTO } from '~/application/document/documents-dto/membership-exit-application-document.dto';
+import { MembershipExitDecisionGenerateDocumentInputDTO } from '~/application/document/documents-dto/membership-exit-decision-document.dto';
+import { MembershipExitService } from '../services/membership-exit.service';
+import { CreateMembershipExitInputDTO } from '../dto/create-membership-exit-input.dto';
+import { MembershipExitResultDTO } from '../dto/membership-exit-result.dto';
+import { MembershipExitReturnPreviewDTO } from '../dto/membership-exit-return-preview.dto';
+import { MembershipExitDTO } from '../dto/membership-exit.dto';
+
+/**
+ * GraphQL резолвер выхода пайщика из кооператива.
+ */
+@Resolver()
+export class MembershipExitResolver {
+  constructor(private readonly membershipExitService: MembershipExitService) {}
+
+  @Mutation(() => GeneratedDocumentDTO, {
+    name: 'generateMembershipExitApplication',
+    description: 'Сгенерировать документ заявления о выходе из кооператива.',
+  })
+  @Throttle({ default: { limit: 3, ttl: 60000 } })
+  @UseGuards(GqlJwtAuthGuard)
+  async generateMembershipExitApplication(
+    @Args('data', { type: () => MembershipExitApplicationGenerateDocumentInputDTO })
+    data: MembershipExitApplicationGenerateDocumentInputDTO,
+    @Args('options', { type: () => GenerateDocumentOptionsInputDTO, nullable: true })
+    options: GenerateDocumentOptionsInputDTO
+  ): Promise<GeneratedDocumentDTO> {
+    return this.membershipExitService.generateMembershipExitApplication(data, options);
+  }
+
+  @Mutation(() => GeneratedDocumentDTO, {
+    name: 'generateMembershipExitDecision',
+    description: 'Сгенерировать документ решения собрания совета о выходе пайщика.',
+  })
+  @Throttle({ default: { limit: 3, ttl: 60000 } })
+  @UseGuards(GqlJwtAuthGuard, RolesGuard)
+  @AuthRoles(['chairman', 'member'])
+  async generateMembershipExitDecision(
+    @Args('data', { type: () => MembershipExitDecisionGenerateDocumentInputDTO })
+    data: MembershipExitDecisionGenerateDocumentInputDTO,
+    @Args('options', { type: () => GenerateDocumentOptionsInputDTO, nullable: true })
+    options: GenerateDocumentOptionsInputDTO
+  ): Promise<GeneratedDocumentDTO> {
+    return this.membershipExitService.generateMembershipExitDecision(data, options);
+  }
+
+  @Mutation(() => MembershipExitResultDTO, {
+    name: 'createMembershipExit',
+    description:
+      'Подать подписанное заявление на выход из кооператива. Запускает рассмотрение советом и последующий возврат паевого взноса.',
+  })
+  @Throttle({ default: { limit: 3, ttl: 60000 } })
+  @UseGuards(GqlJwtAuthGuard)
+  async createMembershipExit(
+    @CurrentUser() currentUser: MonoAccountDomainInterface,
+    @Args('data', { type: () => CreateMembershipExitInputDTO }) data: CreateMembershipExitInputDTO
+  ): Promise<MembershipExitResultDTO> {
+    return this.membershipExitService.createMembershipExit(data, currentUser);
+  }
+
+  @Mutation(() => MembershipExitResultDTO, {
+    name: 'confirmMembershipExit',
+    description:
+      'Подтвердить выход из кооператива по ссылке из письма. Проверяет токен и отправляет ранее подписанное заявление в блокчейн.',
+  })
+  @Throttle({ default: { limit: 5, ttl: 60000 } })
+  async confirmMembershipExit(
+    @Args('token', { type: () => String }) token: string
+  ): Promise<MembershipExitResultDTO> {
+    return this.membershipExitService.confirmMembershipExit(token);
+  }
+
+  @Mutation(() => Boolean, {
+    name: 'cancelMembershipExit',
+    description: 'Отменить заявление на выход до подтверждения по email.',
+  })
+  @Throttle({ default: { limit: 5, ttl: 60000 } })
+  @UseGuards(GqlJwtAuthGuard)
+  async cancelMembershipExit(
+    @CurrentUser() currentUser: MonoAccountDomainInterface,
+    @Args('coopname', { type: () => String }) coopname: string,
+    @Args('username', { type: () => String }) username: string
+  ): Promise<boolean> {
+    return this.membershipExitService.cancelMembershipExit(coopname, username, currentUser);
+  }
+
+  @Query(() => MembershipExitDTO, {
+    name: 'membershipExit',
+    nullable: true,
+    description:
+      'Текущий процесс выхода пайщика из кооператива (статус заявления и планируемая сумма возврата). null — активного выхода нет.',
+  })
+  @UseGuards(GqlJwtAuthGuard)
+  async membershipExit(
+    @CurrentUser() currentUser: MonoAccountDomainInterface,
+    @Args('coopname', { type: () => String }) coopname: string,
+    @Args('username', { type: () => String }) username: string
+  ): Promise<MembershipExitDTO | null> {
+    const isOperator = currentUser.role === 'chairman' || currentUser.role === 'member';
+    if (!isOperator && username !== currentUser.username) {
+      throw new ForbiddenException('Доступен только собственный статус выхода');
+    }
+    return this.membershipExitService.getMembershipExit(coopname, username);
+  }
+
+  @Query(() => MembershipExitReturnPreviewDTO, {
+    name: 'membershipExitReturnPreview',
+    description:
+      'Предварительный расчёт суммы возврата паевого взноса при выходе пайщика (минимальный + целевой паевой). Ориентир для пайщика; итог фиксирует совет.',
+  })
+  @UseGuards(GqlJwtAuthGuard)
+  async membershipExitReturnPreview(
+    @CurrentUser() currentUser: MonoAccountDomainInterface,
+    @Args('coopname', { type: () => String }) coopname: string,
+    @Args('username', { type: () => String }) username: string
+  ): Promise<MembershipExitReturnPreviewDTO> {
+    const isOperator = currentUser.role === 'chairman' || currentUser.role === 'member';
+    if (!isOperator && username !== currentUser.username) {
+      throw new ForbiddenException('Доступен только собственный расчёт возврата');
+    }
+    return this.membershipExitService.getReturnPreview(coopname, username);
+  }
+}

components/controller/src/application/membership-exit/services/membership-exit-authorization.listener.ts

@@ -0,0 +1,152 @@
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { RegistratorContract } from 'cooptypes';
+import { PAYMENT_REPOSITORY, type PaymentRepository } from '~/domain/gateway/repositories/payment.repository';
+import { PAYMENT_METHOD_REPOSITORY, type PaymentMethodRepository } from '~/domain/common/repositories/payment-method.repository';
+import { ACCOUNT_BLOCKCHAIN_PORT, type AccountBlockchainPort } from '~/domain/account/interfaces/account-blockchain.port';
+import { SYSTEM_DOMAIN_PORT, type SystemDomainPort } from '~/domain/system/interfaces/system-domain.port';
+import { PaymentStatusEnum } from '~/domain/gateway/enums/payment-status.enum';
+import { PaymentTypeEnum, PaymentDirectionEnum, VAT_EXEMPT_NOTE } from '~/domain/gateway/enums/payment-type.enum';
+import type {
+  PaymentDomainInterface,
+  PaymentDetailsDomainInterface,
+} from '~/domain/gateway/interfaces/payment-domain.interface';
+import type { ActionDomainInterface } from '~/domain/parser/interfaces/action-domain.interface';
+import { generateUniqueHash } from '~/utils/generate-hash.util';
+
+// confirmexit — callback-экшен совета (одобрение повестки leavecoop). В cooptypes
+// SDK-обёртки нет (не подаётся клиентом), поэтому имя экшена — как в контракте.
+const REGISTRATOR = RegistratorContract.contractName.production;
+const CONFIRM_EXIT_EVENT = `action::${REGISTRATOR}::confirmexit`;
+
+/**
+ * Заводит исходящий платёж-возврат паевого взноса при одобрении советом выхода
+ * пайщика из кооператива.
+ *
+ * On-chain registrator::confirmexit (одобрение повестки leavecoop) сам считает
+ * сумму возврата по L3-балансам (минимальный + целевой паевой), резервирует её
+ * (o.wal.wthreq) и создаёт исходящий объект в gateway через createoutpay с
+ * confirm-callback completexit. Но платёж в реестре gateway, который УВИДИТ
+ * кассир, on-chain не создаётся — заводим его здесь по реквизитам пайщика.
+ *
+ * Подтверждение кассиром проводит on-chain завершение: default-ветка
+ * gateway.interactor.processOutgoingPayment вызывает completeOutcome →
+ * gateway::outcomplete → registrator::completexit (списание Дт80/Кт51 +
+ * блокировка аккаунта). Поэтому hash платежа = exit_hash (= outcome_hash
+ * on-chain объекта), иначе completeOutcome не найдёт объект.
+ *
+ * Реквизиты обязательны на момент подачи заявления (гейт в
+ * MembershipExitService.createMembershipExit); здесь берём метод по умолчанию.
+ */
+@Injectable()
+export class MembershipExitAuthorizationListener {
+  private readonly logger = new Logger(MembershipExitAuthorizationListener.name);
+
+  constructor(
+    @Inject(PAYMENT_REPOSITORY) private readonly paymentRepository: PaymentRepository,
+    @Inject(PAYMENT_METHOD_REPOSITORY) private readonly paymentMethodRepository: PaymentMethodRepository,
+    @Inject(ACCOUNT_BLOCKCHAIN_PORT) private readonly accountBlockchainPort: AccountBlockchainPort,
+    @Inject(SYSTEM_DOMAIN_PORT) private readonly systemDomainPort: SystemDomainPort
+  ) {}
+
+  @OnEvent(CONFIRM_EXIT_EVENT)
+  async onConfirmExit(action: ActionDomainInterface): Promise<void> {
+    const coopname = action?.data?.coopname as string | undefined;
+    const exitHashFromAction = action?.data?.exit_hash as string | undefined;
+    if (!coopname || !exitHashFromAction) return;
+
+    // exit_hash на входе confirmexit есть, но username и итоговую сумму берём из
+    // таблицы (контракт сам посчитал quantity и перевёл статус в authorized).
+    const exit = await this.accountBlockchainPort.getExitByHash(coopname, exitHashFromAction);
+    if (!exit) {
+      // Запись могла быть стёрта контрактом — это штатно при total_return == 0
+      // (возвращать нечего, выход финализирован без платежа).
+      this.logger.debug(`confirmexit: запись выхода по exit_hash=${exitHashFromAction} не найдена — пропуск`);
+      return;
+    }
+
+    const status = String(exit.status);
+    if (status !== 'authorized') {
+      this.logger.debug(`confirmexit: выход ${exit.exit_hash} в статусе "${status}" (не authorized) — пропуск`);
+      return;
+    }
+
+    const exitHash = String(exit.exit_hash);
+    const username = String(exit.username);
+
+    // Идемпотентность: повторный приход события (replay/форк) не плодит платежи.
+    const existing = await this.paymentRepository.findByHash(exitHash);
+    if (existing) {
+      this.logger.debug(`confirmexit: платёж возврата по выходу ${exitHash} уже создан (${existing.id}) — пропуск`);
+      return;
+    }
+
+    // quantity на чейне — asset-строка вида "300.0000 RUB".
+    const [amountStr, symbol] = String(exit.quantity).split(' ');
+    const quantity = Number(amountStr);
+    if (!symbol || !(quantity > 0)) {
+      this.logger.warn(`confirmexit: нулевая/некорректная сумма возврата (${exit.quantity}) по выходу ${exitHash} — платёж не создаём`);
+      return;
+    }
+
+    // Метод по умолчанию (или первый) — на момент подачи заявления реквизиты были
+    // обязательны (гейт createMembershipExit). Если пайщик удалил их после подачи
+    // — платёж создать не из чего, логируем ошибку (вырожденный случай).
+    const methods = await this.paymentMethodRepository.list({
+      username,
+      page: 1,
+      limit: 100,
+      sortOrder: 'DESC',
+    });
+    const method = methods.items.find((m) => m.is_default) ?? methods.items[0];
+    if (!method) {
+      this.logger.error(
+        `confirmexit: у пайщика ${username} нет реквизитов — невозможно создать возврат паевого по выходу ${exitHash}`
+      );
+      return;
+    }
+
+    const settings = await this.systemDomainPort.getSettings();
+    const now = new Date();
+
+    const paymentDetails: PaymentDetailsDomainInterface = {
+      data: method.data,
+      // Для исходящих платежей комиссия не применяется.
+      amount_plus_fee: quantity.toString(),
+      amount_without_fee: quantity.toString(),
+      fee_amount: '0',
+      fee_percent: 0,
+      fact_fee_percent: 0,
+      tolerance_percent: 0,
+    };
+
+    const payment: PaymentDomainInterface = {
+      id: '',
+      coopname,
+      username,
+      quantity,
+      symbol,
+      type: PaymentTypeEnum.MEMBERSHIP_EXIT,
+      direction: PaymentDirectionEnum.OUTGOING,
+      // Совет уже одобрил (confirmexit) — повторная авторизация не нужна, платёж
+      // сразу готов к выплате кассиром (PENDING виден кассиру с кнопкой «Подтвердить»).
+      status: PaymentStatusEnum.PENDING,
+      provider: settings.provider_name,
+      payment_method_id: method.method_id,
+      payment_details: paymentDetails,
+      memo: `Возврат паевого взноса при выходе из кооператива №${exitHash.slice(0, 8)}. ${VAT_EXEMPT_NOTE}`,
+      secret: generateUniqueHash(),
+      // hash = exit_hash = outcome_hash on-chain объекта (createoutpay в confirmexit),
+      // чтобы completeOutcome при подтверждении кассой вызвал completexit.
+      hash: exitHash,
+      expired_at: undefined, // бессрочный — как и прочие исходящие платежи
+      created_at: now,
+      updated_at: now,
+    };
+
+    const created = await this.paymentRepository.create(payment);
+    this.logger.log(
+      `confirmexit: создан возврат паевого взноса ${created.id} для ${username} на ${quantity} ${symbol} (выход ${exitHash})`
+    );
+  }
+}

components/controller/src/application/membership-exit/services/membership-exit.service.ts

@@ -0,0 +1,335 @@
+import { BadRequestException, ForbiddenException, Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Cooperative, Ledger2 } from 'cooptypes';
+import { Workflows } from '@coopenomics/notifications';
+import { config } from '~/config';
+import { ParticipantInteractor } from '~/application/participant/interactors/participant.interactor';
+import { TokenApplicationService } from '~/application/token/services/token-application.service';
+import { NotificationSenderService } from '~/application/notification/services/notification-sender.service';
+import { GeneratedDocumentDTO } from '~/application/document/dto/generated-document.dto';
+import { ACCOUNT_BLOCKCHAIN_PORT, type AccountBlockchainPort } from '~/domain/account/interfaces/account-blockchain.port';
+import { USER_WALLET_REPOSITORY, type UserWalletRepository } from '~/domain/wallet/repositories/user-wallet.repository';
+import { BLOCKCHAIN_PORT, type BlockchainPort } from '~/domain/common/ports/blockchain.port';
+import { USER_DOMAIN_SERVICE, type UserDomainService } from '~/domain/user/services/user-domain.service';
+import { MonoAccountDomainInterface } from '~/domain/account/interfaces/mono-account-domain.interface';
+import { PAYMENT_METHOD_REPOSITORY, type PaymentMethodRepository } from '~/domain/common/repositories/payment-method.repository';
+import { PAYMENT_REPOSITORY, type PaymentRepository } from '~/domain/gateway/repositories/payment.repository';
+import { PaymentTypeEnum } from '~/domain/gateway/enums/payment-type.enum';
+import { MembershipExitRequestEntity } from '~/infrastructure/database/typeorm/entities/membership-exit-request.entity';
+import { tokenTypes } from '~/types/token.types';
+import { CreateMembershipExitInputDTO } from '../dto/create-membership-exit-input.dto';
+import { MembershipExitResultDTO } from '../dto/membership-exit-result.dto';
+import { MembershipExitReturnPreviewDTO } from '../dto/membership-exit-return-preview.dto';
+import { MembershipExitDTO } from '../dto/membership-exit.dto';
+import { MembershipExitStatus } from '../enums/membership-exit-status.enum';
+
+@Injectable()
+export class MembershipExitService {
+  private readonly logger = new Logger(MembershipExitService.name);
+
+  constructor(
+    private readonly participantInteractor: ParticipantInteractor,
+    private readonly tokenApplicationService: TokenApplicationService,
+    private readonly notificationSenderService: NotificationSenderService,
+    @Inject(ACCOUNT_BLOCKCHAIN_PORT)
+    private readonly accountBlockchainPort: AccountBlockchainPort,
+    @Inject(USER_WALLET_REPOSITORY)
+    private readonly userWalletRepository: UserWalletRepository,
+    @Inject(BLOCKCHAIN_PORT)
+    private readonly blockchainPort: BlockchainPort,
+    @Inject(USER_DOMAIN_SERVICE)
+    private readonly userDomainService: UserDomainService,
+    @Inject(PAYMENT_METHOD_REPOSITORY)
+    private readonly paymentMethodRepository: PaymentMethodRepository,
+    @Inject(PAYMENT_REPOSITORY)
+    private readonly paymentRepository: PaymentRepository,
+    @InjectRepository(MembershipExitRequestEntity)
+    private readonly exitRequestRepository: Repository<MembershipExitRequestEntity>
+  ) {}
+
+  async generateMembershipExitApplication(
+    data: Cooperative.Registry.ParticipantExitApplication.Action,
+    options: Cooperative.Document.IGenerationOptions
+  ): Promise<GeneratedDocumentDTO> {
+    const document = await this.participantInteractor.generateMembershipExitApplication(data, options);
+    return document as unknown as GeneratedDocumentDTO;
+  }
+
+  async generateMembershipExitDecision(
+    data: Cooperative.Registry.DecisionOfParticipantExit.Action,
+    options: Cooperative.Document.IGenerationOptions
+  ): Promise<GeneratedDocumentDTO> {
+    const document = await this.participantInteractor.generateMembershipExitDecision(data, options);
+    return document as unknown as GeneratedDocumentDTO;
+  }
+
+  /**
+   * Подача заявления на выход. Заявление подписывается пайщиком на клиенте и
+   * сразу принимается: сохраняется off-chain и требует подтверждения по ссылке
+   * из письма. В блокчейн (registrator::exitcoop) отправляется только после
+   * перехода по ссылке — см. confirmMembershipExit. Это двойное подтверждение
+   * необратимого действия (закрытие аккаунта). Пайщик подаёт выход за себя;
+   * председатель/член совета — за любого пайщика (операторская подача).
+   */
+  async createMembershipExit(
+    data: CreateMembershipExitInputDTO,
+    currentUser: MonoAccountDomainInterface
+  ): Promise<MembershipExitResultDTO> {
+    const isOperator = currentUser.role === 'chairman' || currentUser.role === 'member';
+    if (!isOperator && data.username !== currentUser.username) {
+      throw new ForbiddenException('Подать заявление на выход можно только за себя');
+    }
+
+    // Гард повторного выхода: вышедший пайщик заблокирован on-chain (completexit →
+    // status=blocked + удалён из участников). Контракт exitcoop его уже не пропустит
+    // (get_participant_or_fail), но отсекаем раньше — чтобы не плодить off-chain
+    // черновик и не доводить пайщика до провала на шаге подтверждения по ссылке.
+    const account = await this.accountBlockchainPort.getUserAccount(data.username);
+    if (String(account?.status) === 'blocked') {
+      throw new BadRequestException('Вы уже вышли из кооператива — повторный выход невозможен.');
+    }
+
+    // Гейт реквизитов: выход нельзя запускать, пока у пайщика нет реквизитов для
+    // получения возврата паевого взноса — иначе при одобрении совета исходящий
+    // платёж возврата некуда будет создать (см. MembershipExitAuthorizationListener).
+    const methods = await this.paymentMethodRepository.list({
+      username: data.username,
+      page: 1,
+      limit: 1,
+      sortOrder: 'DESC',
+    });
+    if (!methods || methods.items.length === 0) {
+      throw new BadRequestException(
+        'Для выхода из кооператива установите реквизиты для получения возврата паевого взноса.'
+      );
+    }
+
+    // Уже идёт выход on-chain?
+    const onchain = await this.accountBlockchainPort.getExit(data.coopname, data.username);
+    if (onchain) {
+      throw new BadRequestException('Процесс выхода уже запущен и отправлен в блокчейн');
+    }
+
+    // Уже есть заявление, ожидающее подтверждения по email?
+    const existing = await this.exitRequestRepository.findOne({
+      where: { coopname: data.coopname, username: data.username },
+    });
+    if (existing) {
+      throw new BadRequestException(
+        'Заявление на выход уже подано и ожидает подтверждения по ссылке из письма'
+      );
+    }
+
+    const user = await this.userDomainService.getUserByUsername(data.username);
+    const confirmToken = await this.tokenApplicationService.generateConfirmExitToken(user.id);
+
+    await this.exitRequestRepository.save(
+      this.exitRequestRepository.create({
+        coopname: data.coopname,
+        username: data.username,
+        exit_hash: data.exit_hash,
+        statement: data.statement as unknown as Record<string, any>,
+        token: confirmToken,
+      })
+    );
+
+    const confirmationUrl = `${config.frontend_url}/${config.coopname}/user/membership-exit/confirm?token=${confirmToken}`;
+    this.logger.debug(`Ссылка подтверждения выхода (${data.username}): ${confirmationUrl}`);
+
+    // Письмо — не критично для приёма заявления: черновик уже сохранён, и если
+    // провайдер писем недоступен, пайщик не теряет заявление (можно отменить).
+    try {
+      await this.notificationSenderService.sendNotificationToUser(
+        data.username,
+        Workflows.MembershipExitConfirmation.id,
+        { confirmationUrl }
+      );
+    } catch (e: any) {
+      this.logger.error(
+        `Не удалось отправить письмо с подтверждением выхода (${data.username}): ${e?.message ?? e}`
+      );
+    }
+
+    this.logger.log(
+      `Принято заявление на выход (ожидает email-подтверждения): ${data.exit_hash} (username=${data.username})`
+    );
+
+    return { exit_hash: data.exit_hash, status: MembershipExitStatus.AWAITING_CONFIRMATION };
+  }
+
+  /**
+   * Подтверждение выхода по ссылке из письма. Проверяет токен, берёт сохранённое
+   * подписанное заявление и только теперь отправляет его в блокчейн
+   * (registrator::exitcoop ключом кооператива). Запись-черновик удаляется —
+   * далее источником истины служит on-chain registrator::exits.
+   */
+  async confirmMembershipExit(token: string): Promise<MembershipExitResultDTO> {
+    await this.tokenApplicationService.verifyToken({ token, types: [tokenTypes.CONFIRM_EXIT] });
+
+    const request = await this.exitRequestRepository.findOne({ where: { token } });
+    if (!request) {
+      throw new NotFoundException('Заявление на выход не найдено или уже подтверждено');
+    }
+
+    await this.accountBlockchainPort.exitCoop({
+      coopname: request.coopname,
+      username: request.username,
+      exit_hash: request.exit_hash,
+      statement: request.statement as any,
+    });
+
+    await this.exitRequestRepository.delete({ id: request.id });
+    await this.tokenApplicationService.findOneAndDelete(token, tokenTypes.CONFIRM_EXIT);
+
+    this.logger.log(
+      `Выход подтверждён и отправлен в блокчейн: ${request.exit_hash} (username=${request.username})`
+    );
+
+    return { exit_hash: request.exit_hash, status: MembershipExitStatus.PENDING };
+  }
+
+  /**
+   * Отмена заявления на выход до подтверждения по email. Удаляет черновик и
+   * аннулирует токен подтверждения. Доступно пайщику (за себя) и оператору.
+   */
+  async cancelMembershipExit(
+    coopname: string,
+    username: string,
+    currentUser: MonoAccountDomainInterface
+  ): Promise<boolean> {
+    const isOperator = currentUser.role === 'chairman' || currentUser.role === 'member';
+    if (!isOperator && username !== currentUser.username) {
+      throw new ForbiddenException('Отменить выход можно только за себя');
+    }
+
+    const request = await this.exitRequestRepository.findOne({ where: { coopname, username } });
+    if (!request) {
+      throw new BadRequestException('Нет заявления на выход, ожидающего подтверждения');
+    }
+
+    await this.exitRequestRepository.delete({ id: request.id });
+    await this.tokenApplicationService.findOneAndDelete(request.token, tokenTypes.CONFIRM_EXIT);
+
+    this.logger.log(`Заявление на выход отменено до подтверждения (username=${username})`);
+    return true;
+  }
+
+  /**
+   * Текущий процесс выхода пайщика (если активен) — для блокировки кабинета и
+   * отображения статуса заявления и планируемой суммы возврата. null — выхода нет.
+   */
+  async getMembershipExit(coopname: string, username: string): Promise<MembershipExitDTO | null> {
+    const exit = await this.accountBlockchainPort.getExit(coopname, username);
+    if (exit) {
+      // Статус исходящего платежа возврата (заводится при одобрении советом —
+      // см. MembershipExitAuthorizationListener). hash платежа = exit_hash.
+      const payment = await this.paymentRepository.findByHash(exit.exit_hash);
+      return {
+        exit_hash: exit.exit_hash,
+        status: exit.status as MembershipExitStatus,
+        quantity: exit.quantity,
+        payment_status: payment?.status,
+        created_at: exit.created_at,
+      };
+    }
+
+    // Off-chain фаза: заявление подписано, но ещё не подтверждено по email.
+    const pending = await this.exitRequestRepository.findOne({ where: { coopname, username } });
+    if (pending) {
+      return {
+        exit_hash: pending.exit_hash,
+        status: MembershipExitStatus.AWAITING_CONFIRMATION,
+        quantity: '',
+        created_at: pending.created_at.toISOString(),
+      };
+    }
+
+    // Терминальная фаза: выход завершён on-chain. После completexit строка
+    // registrator::exits СТЁРТА (терминал=erase), аккаунт переведён в blocked.
+    // exits-строки уже нет — источник терминального состояния: blocked-аккаунт +
+    // персистентный MEMBERSHIP_EXIT-платёж в gateway (сумма возврата + «оплачено»).
+    // Так кабинет остаётся заблокированным экраном «вы вышли» и после стирания
+    // exits, и при следующих входах (blocked-статус живёт on-chain).
+    const account = await this.accountBlockchainPort.getUserAccount(username);
+    if (String(account?.status) === 'blocked') {
+      const payment = await this.paymentRepository.findLatestByUsernameAndType(
+        username,
+        PaymentTypeEnum.MEMBERSHIP_EXIT
+      );
+      if (payment) {
+        const precision = config.blockchain.root_govern_precision ?? 4;
+        return {
+          exit_hash: payment.hash,
+          status: MembershipExitStatus.COMPLETED,
+          quantity: `${payment.quantity.toFixed(precision)} ${payment.symbol}`,
+          payment_status: payment.status,
+          created_at: (payment.completed_at ?? payment.created_at).toISOString(),
+        };
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Предварительный расчёт суммы возврата паевого взноса при выходе пайщика.
+   *
+   * Считается обходом сета паевых кошельков Ledger2.EXIT_REFUND_WALLET_NAMES
+   * (w.reg.minshr + w.wal.share + w.cap.blago) по L3-балансам — тот же сет, что
+   * обходит контракт `confirmexit` при одобрении выхода советом, поэтому preview
+   * совпадает с суммой, которую реально вернёт контракт.
+   */
+  async getReturnPreview(coopname: string, username: string): Promise<MembershipExitReturnPreviewDTO> {
+    const wallets = Ledger2.EXIT_REFUND_WALLET_NAMES;
+    const rows = await Promise.all(
+      wallets.map((wallet) => this.userWalletRepository.findByWalletAndUsername(coopname, wallet, username)),
+    );
+
+    // available учитываем только для существующих (present) кошельков
+    const balances = rows.map((row) => (row?.present !== false ? row?.available : undefined));
+
+    const template = await this.resolveAssetTemplate(coopname, balances.find((b) => !!b));
+    const zero = this.zeroAssetLike(template);
+
+    const assets = balances.map((b) => b ?? zero);
+    const total = assets.reduce((acc, a) => this.sumAssets(acc, a), zero);
+
+    // индивидуальные паевые отдаём для информации; фронт показывает total
+    const balanceOf = (wallet: string): string => {
+      const idx = wallets.indexOf(wallet);
+      return idx >= 0 ? assets[idx] : zero;
+    };
+
+    return {
+      total,
+      share_contribution: balanceOf(Ledger2.SHARE_WALLET_NAME),
+      minimum_contribution: balanceOf(Ledger2.MIN_SHARE_WALLET_NAME),
+    };
+  }
+
+  /** Сумма двух asset-строк одного символа («100.0000 RUB»). */
+  private sumAssets(a: string, b: string): string {
+    const [amountA, sym] = a.split(' ');
+    const [amountB] = b.split(' ');
+    const precision = (amountA.split('.')[1] || '').length;
+    const total = Number(amountA) + Number(amountB);
+    return `${total.toFixed(precision)} ${sym}`;
+  }
+
+  /** Нулевой asset в символе/точности образца. */
+  private zeroAssetLike(template: string): string {
+    const [amount, sym] = template.split(' ');
+    const precision = (amount.split('.')[1] || '').length;
+    return `${(0).toFixed(precision)} ${sym}`;
+  }
+
+  /** Образец asset для нулей — из имеющегося баланса либо из настроек кооператива. */
+  private async resolveAssetTemplate(coopname: string, sample?: string): Promise<string> {
+    if (sample) return sample;
+    const coop = await this.blockchainPort.getCooperative(coopname);
+    const precision = config.blockchain.root_govern_precision ?? 4;
+    const symbol = config.blockchain.root_govern_symbol ?? 'RUB';
+    return (coop?.initial as string | undefined) ?? `${(0).toFixed(precision)} ${symbol}`;
+  }
+}

components/controller/src/application/notification-center/channels/email-channel.adapter.ts

@@ -11,22 +11,39 @@ import type {
 import { renderTemplate, resolveTemplate } from '../template.util';
 
 /**
- * Канал «Почта» (SMTP/nodemailer) — реализация {@link EmailChannelPort}.
+ * Канал «Почта» — реализация {@link EmailChannelPort}.
  *
- * Если SMTP-креды не заданы (`SMTP_HOST` пуст) — канал `disabled`: возвращает
- * провал с пояснением и **не** лезет на дефолтный SMTP (NFR11). Тело письма
- * рендерится из шаблона типа уведомления (каталог `@coopenomics/notifications`).
+ * Два транспорта:
+ *  - **relay** (`EMAIL_RELAY_URL` задан): письмо уходит POST'ом на HTTP→SMTP
+ *    релей (`@coopenomics/email-relay`). Нужен там, где хостинг кооператива
+ *    режет исходящий SMTP — релей стоит на сервере с открытыми портами.
+ *  - **smtp** (релей не задан, но `SMTP_HOST` есть): прямой nodemailer.
+ *
+ * Если не задан ни релей, ни `SMTP_HOST` — канал `disabled`: возвращает провал
+ * с пояснением и **не** лезет на дефолтный SMTP (NFR11). Тело письма рендерится
+ * из шаблона типа уведомления (каталог `@coopenomics/notifications`).
  */
 @Injectable()
 export class EmailChannelAdapter implements EmailChannelPort {
   private readonly logger = new Logger(EmailChannelAdapter.name);
   private readonly transporter: Transporter | null;
+  private readonly relayUrl: string;
+  private readonly relayToken: string;
 
   constructor() {
+    this.relayUrl = config.email.relay.url;
+    this.relayToken = config.email.relay.token;
+
+    if (this.relayUrl) {
+      this.transporter = null;
+      this.logger.log(`email-канал в режиме relay → ${this.relayUrl}`);
+      return;
+    }
+
     const smtp = config.email.smtp;
     if (!smtp.host) {
       this.transporter = null;
-      this.logger.warn('SMTP_HOST не задан — email-канал отключён, письма не отправляются');
+      this.logger.warn('SMTP_HOST и EMAIL_RELAY_URL не заданы — email-канал отключён, письма не отправляются');
       return;
     }
     this.transporter = nodemailer.createTransport({
@@ -38,9 +55,6 @@ export class EmailChannelAdapter implements EmailChannelPort {
   }
 
   async send(message: ChannelMessage): Promise<ChannelDeliveryResult> {
-    if (!this.transporter) {
-      return { delivered: false, error: 'email channel disabled (SMTP not configured)' };
-    }
     if (!message.recipient.email) {
       return { delivered: false, error: 'recipient has no email' };
     }
@@ -53,16 +67,44 @@ export class EmailChannelAdapter implements EmailChannelPort {
     const subject = renderTemplate(template.subject, message);
     const html = renderTemplate(template.body, message);
 
+    if (this.relayUrl) {
+      return this.sendViaRelay(message.recipient.email, subject, html);
+    }
+    return this.sendViaSmtp(message.recipient.email, subject, html);
+  }
+
+  private async sendViaSmtp(to: string, subject: string, html: string): Promise<ChannelDeliveryResult> {
+    if (!this.transporter) {
+      return { delivered: false, error: 'email channel disabled (SMTP not configured)' };
+    }
     try {
-      const info = await this.transporter.sendMail({
-        from: config.email.from,
-        to: message.recipient.email,
-        subject,
-        html,
-      });
+      const info = await this.transporter.sendMail({ from: config.email.from, to, subject, html });
       return { delivered: true, providerResponse: info.messageId };
     } catch (error: any) {
-      this.logger.error(`Ошибка отправки письма на ${message.recipient.email}: ${error.message}`);
+      this.logger.error(`Ошибка отправки письма на ${to}: ${error.message}`);
+      return { delivered: false, error: error.message };
+    }
+  }
+
+  private async sendViaRelay(to: string, subject: string, html: string): Promise<ChannelDeliveryResult> {
+    try {
+      const response = await fetch(this.relayUrl, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+          ...(this.relayToken ? { authorization: `Bearer ${this.relayToken}` } : {}),
+        },
+        body: JSON.stringify({ from: config.email.from, to, subject, html }),
+      });
+      const payload = (await response.json().catch(() => ({}))) as { messageId?: string; error?: string };
+      if (!response.ok) {
+        const reason = payload.error || `HTTP ${response.status}`;
+        this.logger.error(`Релей отклонил письмо на ${to}: ${reason}`);
+        return { delivered: false, error: reason };
+      }
+      return { delivered: true, providerResponse: payload.messageId };
+    } catch (error: any) {
+      this.logger.error(`Ошибка обращения к email-релею для ${to}: ${error.message}`);
       return { delivered: false, error: error.message };
     }
   }

components/controller/src/application/notification-center/channels/web-push-channel.adapter.ts

@@ -55,6 +55,9 @@ export class WebPushChannelAdapter implements WebPushChannelPort {
     const title = renderTemplate(template?.subject, message) || 'Уведомление';
     const body = renderTemplate(template?.body, message);
 
+    // info-уровень: видно сколько эндпоинтов адресуем (диагностика «push не пришёл»).
+    this.logger.log(`web-push → '${username}': ${subscriptions.length} активн. подписк(а), workflow=${message.workflowId}`);
+
     let anyDelivered = false;
     for (const subscription of subscriptions) {
       const dto = new WebPushSubscriptionDto(new WebPushSubscriptionDomainEntity(subscription));

components/controller/src/application/notification-center/outbox-worker.service.ts

@@ -142,7 +142,8 @@ export class OutboxWorkerService implements OnModuleInit {
       row.status = NotificationOutboxStatus.CANCELED;
       row.lastError = result.error;
       await this.outboxRepository.save(row);
-      this.logger.debug(`Канал пропущен (неприменим к получателю): ${ctx}: ${result.error}`);
+      // info-уровень: председатель/оператор должен видеть, что и почему не ушло.
+      this.logger.log(`Канал пропущен (неприменим к получателю): ${ctx}: ${result.error}`);
       return;
     }
 
@@ -164,7 +165,8 @@ export class OutboxWorkerService implements OnModuleInit {
     if (result.delivered) {
       row.status = NotificationOutboxStatus.SENT;
       row.lastError = undefined;
-      this.logger.debug(`Доставлено: ${ctx}`);
+      // info-уровень: каждая успешная доставка видна в логах без рытья в БД.
+      this.logger.log(`Доставлено: ${ctx}${result.providerResponse ? ` (${result.providerResponse})` : ''}`);
     } else if (row.attempts >= row.maxAttempts) {
       // Попытки исчерпаны — терминальный failed (виден/переотправляем на столе председателя).
       row.status = NotificationOutboxStatus.FAILED;

components/controller/src/application/participant/interactors/participant.interactor.ts

@@ -73,6 +73,22 @@ export class ParticipantInteractor {
     return await this.documentDomainService.generateDocument({ data, options });
   }
 
+  async generateMembershipExitApplication(
+    data: Cooperative.Registry.ParticipantExitApplication.Action,
+    options: Cooperative.Document.IGenerationOptions
+  ): Promise<DocumentDomainEntity> {
+    data.registry_id = Cooperative.Registry.ParticipantExitApplication.registry_id;
+    return await this.documentDomainService.generateDocument({ data, options });
+  }
+
+  async generateMembershipExitDecision(
+    data: Cooperative.Registry.DecisionOfParticipantExit.Action,
+    options: Cooperative.Document.IGenerationOptions
+  ): Promise<DocumentDomainEntity> {
+    data.registry_id = Cooperative.Registry.DecisionOfParticipantExit.registry_id;
+    return await this.documentDomainService.generateDocument({ data, options });
+  }
+
   /**
    * Проверяет подпись документа
    * @private

components/controller/src/application/payment-method/dto/bank-account-details.dto.ts

@@ -12,6 +12,10 @@ export class BankAccountDetailsDTO {
   @IsString()
   corr: string;
 
+  // TODO: удалить после 1 августа — legacy-поле, оставлено только чтобы старые клиенты не падали на GraphQL-валидации
+  @Field(() => String, { nullable: true, description: 'КПП (устар.)' })
+  kpp?: string;
+
   constructor(details: { bik: string; corr: string }) {
     this.bik = details.bik;
     this.corr = details.corr;

components/controller/src/application/system/interactors/install.interactor.ts

@@ -25,6 +25,42 @@ import { Workflows } from '@coopenomics/notifications';
 import { TokenApplicationService } from '~/application/token/services/token-application.service';
 import { normalizeUserEmail } from '~/utils/normalize-user-email';
 
+/** Минимум членов совета — как MIN_SOVIET_MEMBERS_COUNT в контракте soviet (3 prod / 1 dev). */
+const MIN_SOVIET_MEMBERS_COUNT = config.min_soviet_members_count;
+
+function councilRoleLabel(index: number, role?: string): string {
+  if (role === 'chairman' || index === 0) return 'председателя совета';
+  return `члена совета №${index + 1}`;
+}
+
+function assertSovietMemberComplete(
+  member: InstallInputDomainInterface['soviet'][number],
+  index: number,
+): void {
+  const data = member?.individual_data;
+  const label = councilRoleLabel(index, member?.role);
+  const email = typeof data?.email === 'string' ? data.email.trim() : '';
+
+  if (!email) {
+    throw new BadRequestException(`Не указан email для ${label}`);
+  }
+
+  const requiredStringFields: Array<[keyof Cooperative.Users.IIndividualData, string]> = [
+    ['last_name', 'фамилия'],
+    ['first_name', 'имя'],
+    ['full_address', 'адрес регистрации'],
+    ['birthdate', 'дата рождения'],
+    ['phone', 'телефон'],
+  ];
+
+  for (const [field, humanName] of requiredStringFields) {
+    const value = data?.[field];
+    if (typeof value !== 'string' || !value.trim()) {
+      throw new BadRequestException(`Не заполнено поле «${humanName}» для ${label}`);
+    }
+  }
+}
+
 @Injectable()
 export class InstallInteractor {
   constructor(
@@ -118,14 +154,32 @@ export class InstallInteractor {
 
   async install(data: InstallInputDomainInterface): Promise<void> {
     const status = await this.monoStatusRepository.getStatus();
+    const savedVars = await this.varsRepository.get();
+    const isIncompleteInstallMaintenance =
+      status === SystemStatus.maintenance && !savedVars?.name;
 
-    // Разрешаем установку ТОЛЬКО если система в статусе 'initialized' (после initSystem)
-    if (status !== SystemStatus.initialized) {
+    // Разрешаем установку если:
+    // - initialized (нормальный прогон)
+    // - maintenance без сохранённых vars (прерванная установка, можно повторить)
+    if (status !== SystemStatus.initialized && !isIncompleteInstallMaintenance) {
       throw new BadRequestException(
         `Установка невозможна. Текущий статус: ${status}. Требуется статус: ${SystemStatus.initialized}`
       );
     }
 
+    if (data.soviet.length < MIN_SOVIET_MEMBERS_COUNT) {
+      throw new BadRequestException(
+        `Количество членов совета должно быть не менее ${MIN_SOVIET_MEMBERS_COUNT}`
+      );
+    }
+
+    data.soviet.forEach((member, index) => assertSovietMemberComplete(member, index));
+
+    // Повтор после прерванной установки: снимаем maintenance, дальше — обычный прогон.
+    if (isIncompleteInstallMaintenance) {
+      await this.monoStatusRepository.setStatus(SystemStatus.initialized);
+    }
+
     const info = await this.blockchainPort.getInfo();
     const coop = await this.blockchainPort.getCooperative(config.coopname);
 

components/controller/src/application/token/services/token-application.service.ts

@@ -61,6 +61,15 @@ export class TokenApplicationService {
     return this.tokenDomainService.generateVerifyEmailToken(userId);
   }
 
+  /**
+   * Генерирует токен подтверждения выхода из кооператива
+   * @param userId - ID пользователя
+   * @returns Токен подтверждения выхода
+   */
+  async generateConfirmExitToken(userId: string): Promise<string> {
+    return this.tokenDomainService.generateConfirmExitToken(userId);
+  }
+
   /**
    * Верифицирует токен
    * @param input - данные для верификации

components/controller/src/application/wallet/interactors/wallet.interactor.ts

@@ -19,7 +19,6 @@ import type { CreateWithdrawInputDomainInterface } from '~/domain/wallet/interfa
 import { GATEWAY_INTERACTOR_PORT, GatewayInteractorPort } from '~/domain/wallet/ports/gateway-interactor.port';
 import type { CreateDepositPaymentInputDomainInterface } from '~/domain/gateway/interfaces/create-deposit-payment-input-domain.interface';
 import { PaymentDomainEntity } from '~/domain/gateway/entities/payment-domain.entity';
-import { PaymentStatusEnum } from '~/domain/gateway/enums/payment-status.enum';
 import type { ProgramWalletFilterInputDTO } from '../dto/program-wallet-filter-input.dto';
 import { PaginationResult, PaginationInputDTO } from '~/application/common/dto/pagination.dto';
 import { getProgramId, getProgramType } from '~/domain/wallet/enums/program-type.enum';
@@ -85,22 +84,25 @@ export class WalletInteractor {
     // Используем payment_hash из параметров вместо генерации нового
     const withdraw_hash = data.payment_hash;
 
-    let createdPayment: PaymentDomainEntity | null = null;
+    // 1. Валидируем и подготавливаем платёж БЕЗ записи в БД. Все проверки
+    //    (символ, дубликат hash, наличие платёжного метода) выполняются здесь,
+    //    до блокчейна, чтобы не создать on-chain заявку без записи о платеже.
+    const preparedPayment = await this.gatewayInteractorPort.prepareWithdraw({
+      coopname: data.coopname,
+      username: data.username,
+      quantity: data.quantity,
+      symbol: data.symbol,
+      method_id: data.method_id,
+      statement: data.statement,
+      payment_hash: data.payment_hash,
+    });
 
+    // 2. Создаём withdraw в wallet контракте. Если средств на L3 недостаточно
+    //    (или иная on-chain ошибка) — упадёт здесь, и НИ ОДНОЙ записи о платеже
+    //    в БД не появится. Раньше платёж писался до блокчейна и оставался висеть
+    //    в разделе «Платежи» со статусом FAILED при отклонении транзакцией.
+    //    wallet контракт автоматически создаст outcome в gateway контракте.
     try {
-      // 1. Создаем исходящий платеж в gateway для отслеживания
-      createdPayment = await this.gatewayInteractorPort.createWithdraw({
-        coopname: data.coopname,
-        username: data.username,
-        quantity: data.quantity,
-        symbol: data.symbol,
-        method_id: data.method_id,
-        statement: data.statement,
-        payment_hash: data.payment_hash,
-      });
-
-      // 2. Создаем withdraw в wallet контракте
-      // wallet контракт автоматически создаст outcome в gateway контракте
       await this.walletBlockchainPort.createWithdraw({
         coopname: data.coopname,
         username: data.username,
@@ -108,30 +110,28 @@ export class WalletInteractor {
         quantity: `${data.quantity} ${data.symbol}`,
         statement: data.statement,
       });
-
-      this.logger.log(`Создан withdraw в wallet: ${withdraw_hash}, outcome будет создан автоматически в gateway`);
-
-      return { withdraw_hash };
     } catch (error: any) {
-      this.logger.error(`Ошибка при создании withdraw: ${error.message}`, error);
-
-      // Если платеж был создан, но произошла ошибка при создании withdraw в блокчейне
-      if (createdPayment?.id) {
-        try {
-          // Обновляем статус платежа на FAILED с сообщением об ошибке
-          await this.gatewayInteractorPort.setPaymentStatus({
-            id: createdPayment.id,
-            status: PaymentStatusEnum.FAILED,
-          });
-
-          this.logger.log(`Платеж ${createdPayment.id} помечен как FAILED из-за ошибки создания withdraw`);
-        } catch (updateError: any) {
-          this.logger.error(`Ошибка при обновлении статуса платежа: ${updateError.message}`, updateError);
-        }
-      }
-
+      this.logger.error(`Ошибка при создании withdraw в блокчейне (платёж не зафиксирован): ${error.message}`, error);
       throw error;
     }
+
+    // 3. Только после успешной on-chain заявки фиксируем платёж в БД для
+    //    отслеживания кассиром и последующего перехода статусов.
+    try {
+      await this.gatewayInteractorPort.persistWithdraw(preparedPayment);
+    } catch (error: any) {
+      // Редкий случай: on-chain заявка прошла, но запись в БД не удалась (например,
+      // недоступна БД). On-chain withdraw существует — требуется ручная сверка.
+      this.logger.error(
+        `КРИТИЧНО: on-chain withdraw ${withdraw_hash} создан, но не удалось зафиксировать платёж в БД: ${error.message}`,
+        error
+      );
+      throw error;
+    }
+
+    this.logger.log(`Создан withdraw в wallet: ${withdraw_hash}, платёж зафиксирован в gateway`);
+
+    return { withdraw_hash };
   }
 
   /**

components/controller/src/config/config.ts

@@ -76,6 +76,10 @@ const envVarsSchema = z.object({
   SMTP_USERNAME: z.string().default(''), // Пустая строка для необязательного значения
   SMTP_PASSWORD: z.string().default(''), // Пустая строка для необязательного значения
   EMAIL_FROM: z.string().default(''), // Пустая строка для необязательного значения
+  // HTTP→SMTP релей (@coopenomics/email-relay). Если URL задан — письма уходят
+  // POST'ом на релей вместо прямого SMTP (хостинг кооператива может резать порты).
+  EMAIL_RELAY_URL: z.string().default(''),
+  EMAIL_RELAY_TOKEN: z.string().default(''),
   COOPNAME: z.string().min(1, { message: 'Не должно быть пустым' }).default('voskhod'), // Задаём дефолтное значение, пустая строка невалидна
   TIMEZONE: z.string().min(1, { message: 'Не должно быть пустым' }).default('Europe/Moscow'), // Пустая строка невалидна
   GRAPHQL_SERVICE: z
@@ -185,6 +189,10 @@ const envVarsSchema = z.object({
     .string()
     .optional()
     .describe('База публичного URL контроллера для read-URL; пусто — берётся BACKEND_URL'),
+  MIN_SOVIET_MEMBERS_COUNT: z
+    .string()
+    .optional()
+    .describe('Минимум членов совета при install; пусто — 3 на production, 1 на development/test'),
 });
 
 const envInput = isSchemaGeneration ? { ...SCHEMA_GEN_ENV_DEFAULTS, ...process.env } : process.env;
@@ -250,8 +258,17 @@ export default {
       },
     },
     from: envVars.data.EMAIL_FROM,
+    relay: {
+      url: envVars.data.EMAIL_RELAY_URL,
+      token: envVars.data.EMAIL_RELAY_TOKEN,
+    },
   },
   coopname: envVars.data.COOPNAME,
+  min_soviet_members_count: envVars.data.MIN_SOVIET_MEMBERS_COUNT
+    ? parseInt(envVars.data.MIN_SOVIET_MEMBERS_COUNT, 10)
+    : envVars.data.NODE_ENV === 'production'
+      ? 3
+      : 1,
   graphql_service: envVars.data.GRAPHQL_SERVICE,
   provider_base_url: envVars.data.PROVIDER_BASE_URL,
   union: {

components/controller/src/domain/account/interfaces/account-blockchain.port.ts

@@ -1,6 +1,17 @@
 import type { RegistratorContract, SovietContract } from 'cooptypes';
 import type { BlockchainAccountInterface } from '~/types/shared';
 import type { CandidateDomainInterface } from '../interfaces/candidate-domain.interface';
+import type { ISignedDocumentDomainInterface } from '~/domain/document/interfaces/signed-document-domain.interface';
+
+/**
+ * Входные данные подачи заявления на выход пайщика из кооператива (registrator::exitcoop).
+ */
+export interface ExitCoopDomainInterface {
+  coopname: string;
+  username: string;
+  exit_hash: string;
+  statement: ISignedDocumentDomainInterface;
+}
 
 export interface AccountBlockchainPort {
   getBlockchainAccount(username: string): Promise<BlockchainAccountInterface | null>;
@@ -12,6 +23,13 @@ export interface AccountBlockchainPort {
   getUserAccount(username: string): Promise<RegistratorContract.Tables.Accounts.IAccount | null>;
   addParticipantAccount(data: RegistratorContract.Actions.AddUser.IAddUser): Promise<void>;
   registerBlockchainAccount(candidate: CandidateDomainInterface): Promise<void>;
+  // Подача заявления на выход пайщика из кооператива (registrator::exitcoop)
+  exitCoop(data: ExitCoopDomainInterface): Promise<void>;
+  // Текущий процесс выхода пайщика (registrator::exits), либо null
+  getExit(coopname: string, username: string): Promise<RegistratorContract.Tables.Exits.IExit | null>;
+  // Процесс выхода по exit_hash (registrator::exits): on-chain confirmexit отдаёт
+  // только coopname+exit_hash, username и сумму возврата берём из таблицы по хэшу.
+  getExitByHash(coopname: string, exit_hash: string): Promise<RegistratorContract.Tables.Exits.IExit | null>;
 }
 
 export const ACCOUNT_BLOCKCHAIN_PORT = Symbol('AccountBlockchainPort');

components/controller/src/domain/account/interfaces/create-membership-exit-input.interface.ts

@@ -0,0 +1,11 @@
+import type { ISignedDocumentDomainInterface } from '~/domain/document/interfaces/signed-document-domain.interface';
+
+/**
+ * Входные данные подачи заявления на выход пайщика из кооператива.
+ */
+export interface CreateMembershipExitInputDomainInterface {
+  coopname: string;
+  username: string;
+  exit_hash: string;
+  statement: ISignedDocumentDomainInterface;
+}

components/controller/src/domain/document/aggregators/document-package-v1.aggregator.spec.ts

@@ -0,0 +1,163 @@
+import { getActions } from '~/utils/getFetch';
+import { DocumentPackageV1Aggregator } from './document-package-v1.aggregator';
+
+jest.mock('~/utils/getFetch', () => ({
+  getActions: jest.fn(),
+}));
+
+const mockedGetActions = getActions as unknown as jest.Mock;
+
+/**
+ * Регрессия: программная оферта ЦПП уходит на цепь через wallet::signagree
+ * (program_id > 0), а не через soviet::sndagreement. Агрегатор повестки обязан
+ * находить такое приложение к заявлению и не терять его (раньше искал только
+ * soviet::newagreement и оферта молча выпадала из links).
+ */
+describe('DocumentPackageV1Aggregator — приложения к заявлению (links)', () => {
+  const STATEMENT_HASH = 'AAAA';
+  const OFFER_HASH = 'BBBB'; // программная оферта — подписана через wallet::signagree
+  const PLATFORM_HASH = 'CCCC'; // платформенное соглашение — soviet::newagreement
+
+  // Документы существуют в реестре документов независимо от пути подписи.
+  const documentByHash: Record<string, any> = {
+    [STATEMENT_HASH]: { hash: STATEMENT_HASH, meta: { links: [OFFER_HASH, PLATFORM_HASH] } },
+    [OFFER_HASH]: { hash: OFFER_HASH, meta: {} },
+    [PLATFORM_HASH]: { hash: PLATFORM_HASH, meta: {} },
+  };
+
+  const documentPackageUtils = {
+    getDocumentByHash: jest.fn(async (hash: string) => documentByHash[String(hash).toUpperCase()] ?? null),
+  };
+
+  // Возвращаем маркер с doc_hash и подписями, чтобы проверить источник приложения.
+  const documentAggregator = {
+    buildDocumentAggregate: jest.fn(async (signedDoc: any) => ({
+      doc_hash: signedDoc.doc_hash,
+      signatures: signedDoc.signatures,
+    })),
+  };
+
+  const accountDomainService = {
+    getPrivateAccount: jest.fn(async () => ({ username: 'alice' })),
+  };
+
+  const userCertificateService = {
+    createCertificateFromUserData: jest.fn(() => ({})),
+  };
+
+  const aggregator = new DocumentPackageV1Aggregator(
+    documentAggregator as any,
+    documentPackageUtils as any,
+    accountDomainService as any,
+    userCertificateService as any
+  );
+
+  beforeEach(() => {
+    mockedGetActions.mockReset();
+    // Маршрутизация по содержимому фильтра: имитируем explorer get-actions.
+    mockedGetActions.mockImplementation(async (_path: string, params: any) => {
+      const filter = JSON.parse(params.filter);
+      const docHash = filter['data.document.doc_hash'];
+
+      // Платформенное соглашение зарегистрировано в реестре совета.
+      if (filter.name === 'newagreement' && docHash === PLATFORM_HASH) {
+        return {
+          results: [
+            {
+              data: {
+                document: {
+                  meta_hash: 'META_PLATFORM',
+                  meta: JSON.stringify({ title: 'Политика' }),
+                  signatures: [{ id: 'platform-sig' }],
+                },
+              },
+            },
+          ],
+        };
+      }
+
+      // Программная оферта подписана через wallet::signagree, soviet::newagreement по ней НЕТ.
+      if (filter.name === 'signagree' && docHash === OFFER_HASH) {
+        return {
+          results: [
+            {
+              data: {
+                document: {
+                  meta_hash: 'META_OFFER',
+                  meta: JSON.stringify({ title: 'Оферта Генератор' }),
+                  signatures: [{ id: 'offer-sig' }],
+                },
+              },
+            },
+          ],
+        };
+      }
+
+      // Всё прочее (newagreement по оферте, newdecision, newact, newlink) — пусто.
+      return { results: [] };
+    });
+  });
+
+  it('включает программную оферту (wallet::signagree) в приложения к заявлению', async () => {
+    const rawAction = {
+      data: {
+        package: 'PACKAGE1',
+        username: 'alice',
+        document: {
+          hash: STATEMENT_HASH,
+          doc_hash: STATEMENT_HASH,
+          meta_hash: 'META_STATEMENT',
+          version: '1',
+          signatures: [{ id: 'statement-sig' }],
+        },
+      },
+    } as any;
+
+    const result = await aggregator.buildDocumentPackageAggregateV1(rawAction);
+
+    const linkHashes = result.links.map((l: any) => l.doc_hash);
+    expect(linkHashes).toContain(OFFER_HASH);
+    expect(linkHashes).toContain(PLATFORM_HASH);
+
+    const offerLink = result.links.find((l: any) => l.doc_hash === OFFER_HASH) as any;
+    expect(offerLink.signatures).toEqual([{ id: 'offer-sig' }]);
+  });
+
+  it('ищет soviet::newagreement раньше, чем wallet::signagree', async () => {
+    const rawAction = {
+      data: {
+        package: 'PACKAGE1',
+        username: 'alice',
+        document: {
+          hash: STATEMENT_HASH,
+          doc_hash: STATEMENT_HASH,
+          meta_hash: 'META_STATEMENT',
+          version: '1',
+          signatures: [{ id: 'statement-sig' }],
+        },
+      },
+    } as any;
+
+    await aggregator.buildDocumentPackageAggregateV1(rawAction);
+
+    const callNames = mockedGetActions.mock.calls.map(([, params]) => JSON.parse(params.filter).name);
+    const offerNewagreementIdx = mockedGetActions.mock.calls.findIndex(
+      ([, params]) => {
+        const f = JSON.parse(params.filter);
+        return f.name === 'newagreement' && f['data.document.doc_hash'] === OFFER_HASH;
+      }
+    );
+    const offerSignagreeIdx = mockedGetActions.mock.calls.findIndex(
+      ([, params]) => {
+        const f = JSON.parse(params.filter);
+        return f.name === 'signagree' && f['data.document.doc_hash'] === OFFER_HASH;
+      }
+    );
+
+    expect(callNames).toContain('newagreement');
+    expect(callNames).toContain('signagree');
+    // По одному и тому же хэшу soviet проверяется до wallet-фолбэка.
+    expect(offerNewagreementIdx).toBeGreaterThanOrEqual(0);
+    expect(offerSignagreeIdx).toBeGreaterThan(offerNewagreementIdx);
+  });
+});

components/controller/src/domain/document/aggregators/document-package-v1.aggregator.ts

@@ -6,7 +6,7 @@ import {
   UserCertificateDomainService,
   USER_CERTIFICATE_DOMAIN_SERVICE,
 } from '~/domain/user/services/user-certificate-domain.service';
-import { Cooperative, SovietContract } from 'cooptypes';
+import { Cooperative, SovietContract, WalletContract } from 'cooptypes';
 import { getActions } from '~/utils/getFetch';
 import type { DocumentPackageAggregateDomainInterface } from '../interfaces/document-package-aggregate-domain.interface';
 import type { StatementDetailAggregateDomainInterface } from '../interfaces/statement-detail-aggregate-domain.interface';
@@ -79,37 +79,9 @@ export class DocumentPackageV1Aggregator {
 
     if (mainDocument?.meta?.links && Array.isArray(mainDocument.meta.links)) {
       for (const linkHash of mainDocument.meta.links) {
-        const linkedDoc = await this.documentPackageUtils.getDocumentByHash(linkHash);
-        if (linkedDoc) {
-          // поиск соглашения по документу
-          const rawAgreement = await getActions(`${process.env.SIMPLE_EXPLORER_API}/get-actions`, {
-            filter: JSON.stringify({
-              account: SovietContract.contractName.production,
-              name: SovietContract.Actions.Registry.NewAgreement.actionName,
-              receiver: process.env.COOPNAME,
-              'data.document.doc_hash': String(linkHash.toUpperCase()),
-            }),
-            page: 1,
-            limit: 1,
-          });
-
-          const agreement: SovietContract.Actions.Registry.NewAgreement.INewAgreement = rawAgreement?.results?.[0]?.data;
-
-          if (agreement) {
-            const signedLinkedDoc: ISignedDocumentDomainInterface = {
-              version: rawData.document.version,
-              hash: linkedDoc.hash,
-              doc_hash: linkedDoc.hash,
-              meta_hash: agreement.document.meta_hash,
-              meta: JSON.parse(agreement.document.meta),
-              signatures: agreement.document.signatures || [],
-            };
-
-            const linkAggregate = await this.documentAggregator.buildDocumentAggregate(signedLinkedDoc);
-            if (linkAggregate) {
-              links.push(linkAggregate);
-            }
-          }
+        const linkAggregate = await this.buildLinkedAggregate(linkHash, rawData.document.version);
+        if (linkAggregate) {
+          links.push(linkAggregate);
         }
       }
     }
@@ -184,37 +156,9 @@ export class DocumentPackageV1Aggregator {
 
     if (decisionDocument?.meta?.links && Array.isArray(decisionDocument.meta.links)) {
       for (const linkHash of decisionDocument.meta.links) {
-        const linkedDoc = await this.documentPackageUtils.getDocumentByHash(linkHash);
-        if (linkedDoc) {
-          // поиск соглашения по документу
-          const rawAgreement = await getActions(`${process.env.SIMPLE_EXPLORER_API}/get-actions`, {
-            filter: JSON.stringify({
-              account: SovietContract.contractName.production,
-              name: SovietContract.Actions.Registry.NewAgreement.actionName,
-              receiver: process.env.COOPNAME,
-              'data.document.doc_hash': String(linkHash.toUpperCase()),
-            }),
-            page: 1,
-            limit: 1,
-          });
-
-          const agreement: SovietContract.Actions.Registry.NewAgreement.INewAgreement = rawAgreement?.results?.[0]?.data;
-
-          if (agreement) {
-            const signedLinkedDoc: ISignedDocumentDomainInterface = {
-              version: decisionAction.data?.document?.version,
-              hash: linkedDoc.hash,
-              doc_hash: linkedDoc.hash,
-              meta_hash: agreement.document.meta_hash,
-              meta: JSON.parse(agreement.document.meta),
-              signatures: agreement.document.signatures || [],
-            };
-
-            const linkAggregate = await this.documentAggregator.buildDocumentAggregate(signedLinkedDoc);
-            if (linkAggregate) {
-              links.push(linkAggregate);
-            }
-          }
+        const linkAggregate = await this.buildLinkedAggregate(linkHash, decisionAction.data?.document?.version);
+        if (linkAggregate) {
+          links.push(linkAggregate);
         }
       }
     }
@@ -282,37 +226,9 @@ export class DocumentPackageV1Aggregator {
 
       if (actDocument?.meta?.links && Array.isArray(actDocument.meta.links)) {
         for (const linkHash of actDocument.meta.links) {
-          const linkedDoc = await this.documentPackageUtils.getDocumentByHash(linkHash);
-          if (linkedDoc) {
-            // поиск соглашения по документу
-            const rawAgreement = await getActions(`${process.env.SIMPLE_EXPLORER_API}/get-actions`, {
-              filter: JSON.stringify({
-                account: SovietContract.contractName.production,
-                name: SovietContract.Actions.Registry.NewAgreement.actionName,
-                receiver: process.env.COOPNAME,
-                'data.document.doc_hash': String(linkHash.toUpperCase()),
-              }),
-              page: 1,
-              limit: 1,
-            });
-
-            const agreement: SovietContract.Actions.Registry.NewAgreement.INewAgreement = rawAgreement?.results?.[0]?.data;
-
-            if (agreement) {
-              const signedLinkedDoc: ISignedDocumentDomainInterface = {
-                version: actAction.data?.document?.version,
-                hash: linkedDoc.hash,
-                doc_hash: linkedDoc.hash,
-                meta_hash: agreement.document.meta_hash,
-                meta: JSON.parse(agreement.document.meta),
-                signatures: agreement.document.signatures || [],
-              };
-
-              const linkAggregate = await this.documentAggregator.buildDocumentAggregate(signedLinkedDoc);
-              if (linkAggregate) {
-                links.push(linkAggregate);
-              }
-            }
+          const linkAggregate = await this.buildLinkedAggregate(linkHash, actAction.data?.document?.version);
+          if (linkAggregate) {
+            links.push(linkAggregate);
           }
         }
       }
@@ -341,6 +257,87 @@ export class DocumentPackageV1Aggregator {
     return actsDetails;
   }
 
+  /**
+   * Строит агрегат связанного с заявлением документа (приложения) по его хэшу.
+   *
+   * Подписанный носитель соглашения ищется в двух источниках, потому что
+   * соглашения уходят на цепь двумя путями:
+   *   - непрограммные (program_id == 0) — через soviet::sndagreement,
+   *     создавая действие реестра soviet::newagreement;
+   *   - программные оферты ЦПП (program_id > 0, Эпик 2) — через wallet::signagree,
+   *     которое пишет в wallet::users.programs[] и НЕ создаёт soviet::newagreement.
+   *
+   * Раньше все соглашения шли через soviet::sndagreement, поэтому агрегатор искал
+   * приложение только в soviet::newagreement. После перевода программных оферт на
+   * wallet::signagree они перестали находиться и молча выпадали из приложений к
+   * заявлению на повестке совета. Фолбэк на wallet::signagree восстанавливает связь.
+   *
+   * @returns агрегат документа либо null, если документ или носитель подписи не найдены
+   */
+  private async buildLinkedAggregate(
+    linkHash: string,
+    version: string
+  ): Promise<DocumentDomainAggregate | null> {
+    const linkedDoc = await this.documentPackageUtils.getDocumentByHash(linkHash);
+    if (!linkedDoc) return null;
+
+    const agreementDocument = await this.findLinkedAgreementDocument(linkHash);
+    if (!agreementDocument) return null;
+
+    const signedLinkedDoc: ISignedDocumentDomainInterface = {
+      version,
+      hash: linkedDoc.hash,
+      doc_hash: linkedDoc.hash,
+      meta_hash: agreementDocument.meta_hash,
+      meta: typeof agreementDocument.meta === 'string' ? JSON.parse(agreementDocument.meta) : agreementDocument.meta,
+      signatures: agreementDocument.signatures || [],
+    };
+
+    return this.documentAggregator.buildDocumentAggregate(signedLinkedDoc);
+  }
+
+  /**
+   * Находит on-chain действие-носитель подписанного связанного документа по doc_hash.
+   * Сначала ищет в реестре соглашений совета (soviet::newagreement), затем —
+   * в программных подписях кошелька (wallet::signagree). Возвращает поле document
+   * найденного действия либо null.
+   */
+  private async findLinkedAgreementDocument(
+    linkHash: string
+  ): Promise<{ meta_hash: string; meta: string; signatures: any[] } | null> {
+    const docHashFilter = String(linkHash.toUpperCase());
+
+    const sovietAgreement = await getActions(`${process.env.SIMPLE_EXPLORER_API}/get-actions`, {
+      filter: JSON.stringify({
+        account: SovietContract.contractName.production,
+        name: SovietContract.Actions.Registry.NewAgreement.actionName,
+        receiver: process.env.COOPNAME,
+        'data.document.doc_hash': docHashFilter,
+      }),
+      page: 1,
+      limit: 1,
+    });
+
+    const sovietDocument = sovietAgreement?.results?.[0]?.data?.document;
+    if (sovietDocument) return sovietDocument;
+
+    const walletAgreement = await getActions(`${process.env.SIMPLE_EXPLORER_API}/get-actions`, {
+      filter: JSON.stringify({
+        account: WalletContract.contractName.production,
+        name: WalletContract.Actions.SignAgreement.actionName,
+        receiver: process.env.COOPNAME,
+        'data.document.doc_hash': docHashFilter,
+      }),
+      page: 1,
+      limit: 1,
+    });
+
+    const walletDocument = walletAgreement?.results?.[0]?.data?.document;
+    if (walletDocument) return walletDocument;
+
+    return null;
+  }
+
   /**
    * Собирает связанные документы (Links) для версии 1+
    * @param rawData Данные действия

components/controller/src/domain/document/ports/generator.port.ts

@@ -16,6 +16,10 @@ export interface GeneratorPort {
   list<T = any>(collection: string, filter?: Record<string, any>): Promise<Cooperative.Document.IGetResponse<T>>;
   getHistory<T = any>(collection: string, filter: Record<string, any>): Promise<T[]>;
   search(query: string): Promise<ISearchResult[]>;
+
+  saveDocData<P extends Record<string, unknown>>(payload: P, registry_id: number): Promise<{ hash: string }>;
+
+  getDocData<P = Record<string, unknown>>(hash: string): Promise<P | null>;
 }
 
 export const GENERATOR_PORT = Symbol('GeneratorPort');

components/controller/src/domain/document/services/document-domain.service.ts

@@ -22,9 +22,37 @@ export class DocumentDomainService {
   ) {}
 
   public async generateDocument(data: GenerateDocumentDomainInterfaceWithOptions): Promise<DocumentDomainEntity> {
+    const documentData = data.data as Cooperative.Document.IGenerate & {
+      doc_data?: Record<string, unknown>;
+      doc_data_hash?: string;
+    };
+
+    if (documentData.doc_data) {
+      const { doc_data, ...publicDocumentData } = documentData;
+      const { hash } = documentData.doc_data_hash
+        ? { hash: documentData.doc_data_hash }
+        : await this.saveDocData(doc_data, documentData.registry_id);
+
+      return await this.generatorInfrastructureService.generateDocument({
+        ...data,
+        data: {
+          ...publicDocumentData,
+          doc_data_hash: hash,
+        } as Cooperative.Document.IGenerate,
+      });
+    }
+
     return await this.generatorInfrastructureService.generateDocument(data);
   }
 
+  public async saveDocData<P extends Record<string, unknown>>(payload: P, registry_id: number): Promise<{ hash: string }> {
+    return await this.generatorInfrastructureService.saveDocData(payload, registry_id);
+  }
+
+  public async getDocData<P = Record<string, unknown>>(hash: string): Promise<P | null> {
+    return await this.generatorInfrastructureService.getDocData<P>(hash);
+  }
+
   public async getDocumentByHash(hash: string): Promise<DocumentDomainEntity | null> {
     const document = await this.documentRepository.findByHash(hash);
     return document;

components/controller/src/domain/gateway/constants/gateway-bucket.ts

@@ -0,0 +1,23 @@
+/**
+ * Spec MinIO-бакета `gateway:files` — ядровое хранилище файлов платежей.
+ *
+ * Содержимое: чеки об оплате (PAYMENT_PROOF) по исходящим платежам — единая
+ * «культура денег» (входящие подтверждаем, исходящие сопровождаем чеком).
+ * Привязка по `payment_hash`; переиспользуется всеми расширениями.
+ *
+ * Ключ объекта: `{coopname}/gateway/{payment_hash}/{kind}/{checksum}.{ext}`.
+ */
+export const GATEWAY_BUCKET = {
+  name: 'gateway:files',
+  maxBytes: 20 * 1024 * 1024,
+  allowedMime: [
+    'image/jpeg',
+    'image/png',
+    'image/webp',
+    'image/heic',
+    'application/pdf',
+  ] as const,
+  defaultUrlTtlSeconds: 600,
+} as const;
+
+export type GatewayBucketAllowedMime = (typeof GATEWAY_BUCKET.allowedMime)[number];

components/controller/src/domain/gateway/entities/payment-domain.entity.ts

@@ -113,6 +113,10 @@ export class PaymentDomainEntity implements PaymentDomainInterface {
       [PaymentTypeEnum.DEPOSIT]: 'Паевой взнос',
       [PaymentTypeEnum.WITHDRAWAL]: 'Возврат взноса',
       [PaymentTypeEnum.REGISTRATION_REFUND]: 'Возврат вступит. и мин.паевого взноса',
+      [PaymentTypeEnum.MEMBERSHIP_EXIT]: 'Возврат паевого взноса при выходе из кооператива',
+      [PaymentTypeEnum.EXPENSE]: 'Оплата расхода по служебной записке',
+      [PaymentTypeEnum.EXPENSE_RETURN]: 'Возврат неиспользованного аванса под отчёт',
+      [PaymentTypeEnum.EXPENSE_OVERSPEND]: 'Доплата по перерасходу аванса',
     };
     return typeLabels[this.type] || this.type;
   }

components/controller/src/domain/gateway/enums/payment-file-kind.enum.ts

@@ -0,0 +1,20 @@
+import { registerEnumType } from '@nestjs/graphql';
+
+/**
+ * Назначение файла, приложенного к платежу (бакет `gateway:files`).
+ *
+ * Ядровая «культура денег»: каждый ИСХОДЯЩИЙ платёж сопровождается чеком об
+ * оплате (подтверждающий документ — для кассира «чем оплатил», для пайщика «на
+ * что»). Сейчас единственный вид — PAYMENT_PROOF; enum оставлен расширяемым.
+ */
+export enum PaymentFileKind {
+  PAYMENT_PROOF = 'PAYMENT_PROOF',
+}
+
+registerEnumType(PaymentFileKind, {
+  name: 'PaymentFileKind',
+  description: 'Тип файла, приложенного к платежу.',
+  valuesMap: {
+    PAYMENT_PROOF: { description: 'Чек об оплате — подтверждающий документ по исполненному платежу.' },
+  },
+});

components/controller/src/domain/gateway/enums/payment-type.enum.ts

@@ -9,6 +9,24 @@ export enum PaymentTypeEnum {
   // Исходящий возврат вступительного и мин. паевого взносов при отказе совета
   // в приёме. Отдельный тип, не WITHDRAWAL — чтобы не путать с возвратом паевого.
   REGISTRATION_REFUND = 'registration_refund',
+  // Исходящий возврат всего паевого взноса при выходе пайщика из кооператива.
+  // Отдельный тип, не WITHDRAWAL — это полный выход с блокировкой аккаунта,
+  // а не частичный возврат паевого действующему пайщику.
+  MEMBERSHIP_EXIT = 'membership_exit',
+  // Исходящая оплата позиции служебной записки-сметы (шасси expense). Создаётся
+  // автоматически после авторизации СЗ советом; подтверждение кассиром проводит
+  // on-chain оплату expense::payexp по позиции.
+  EXPENSE = 'expense',
+  // Входящий возврат неиспользованного аванса под отчёт (недорасход). Создаётся,
+  // когда пайщик отчитался о факте меньше выданного аванса: он возвращает разницу
+  // на расчётный счёт кооператива; подтверждение кассиром (приём средств)
+  // проводит on-chain expense::returnexp и закрывает позицию expense::reportexp.
+  EXPENSE_RETURN = 'expense_return',
+  // Исходящая доплата при перерасходе аванса под отчёт. Создаётся, когда пайщик
+  // отчитался о факте больше выданного аванса: кооператив доплачивает разницу;
+  // подтверждение кассиром (выплата) проводит on-chain expense::overspendexp и
+  // закрывает позицию expense::reportexp.
+  EXPENSE_OVERSPEND = 'expense_overspend',
 }
 
 /**
@@ -27,6 +45,10 @@ export const PAYMENT_TYPE_LABELS: Record<PaymentTypeEnum, string> = {
   [PaymentTypeEnum.DEPOSIT]: 'Паевой взнос',
   [PaymentTypeEnum.WITHDRAWAL]: 'Возврат паевого взноса',
   [PaymentTypeEnum.REGISTRATION_REFUND]: 'Возврат вступит. и мин.паевого взноса',
+  [PaymentTypeEnum.MEMBERSHIP_EXIT]: 'Возврат паевого взноса при выходе из кооператива',
+  [PaymentTypeEnum.EXPENSE]: 'Оплата расхода по служебной записке',
+  [PaymentTypeEnum.EXPENSE_RETURN]: 'Возврат неиспользованного аванса под отчёт',
+  [PaymentTypeEnum.EXPENSE_OVERSPEND]: 'Доплата по перерасходу аванса',
 };
 
 /**
@@ -49,17 +71,25 @@ export const PAYMENT_DIRECTION_LABELS: Record<PaymentDirectionEnum, string> = {
  * Определяет направление платежа по его типу
  */
 export function getPaymentDirection(type: PaymentTypeEnum): PaymentDirectionEnum {
-  const incomingTypes = [PaymentTypeEnum.REGISTRATION, PaymentTypeEnum.DEPOSIT];
-
-  return incomingTypes.includes(type) ? PaymentDirectionEnum.INCOMING : PaymentDirectionEnum.OUTGOING;
+  return INCOMING_PAYMENT_TYPES.includes(type) ? PaymentDirectionEnum.INCOMING : PaymentDirectionEnum.OUTGOING;
 }
 
 /**
  * Входящие типы платежей
  */
-export const INCOMING_PAYMENT_TYPES = [PaymentTypeEnum.REGISTRATION, PaymentTypeEnum.DEPOSIT];
+export const INCOMING_PAYMENT_TYPES = [
+  PaymentTypeEnum.REGISTRATION,
+  PaymentTypeEnum.DEPOSIT,
+  PaymentTypeEnum.EXPENSE_RETURN,
+];
 
 /**
  * Исходящие типы платежей
  */
-export const OUTGOING_PAYMENT_TYPES = [PaymentTypeEnum.WITHDRAWAL, PaymentTypeEnum.REGISTRATION_REFUND];
+export const OUTGOING_PAYMENT_TYPES = [
+  PaymentTypeEnum.WITHDRAWAL,
+  PaymentTypeEnum.REGISTRATION_REFUND,
+  PaymentTypeEnum.MEMBERSHIP_EXIT,
+  PaymentTypeEnum.EXPENSE,
+  PaymentTypeEnum.EXPENSE_OVERSPEND,
+];

components/controller/src/domain/gateway/interfaces/payment-file-database.interface.ts

@@ -0,0 +1,24 @@
+import { PaymentFileKind } from '../enums/payment-file-kind.enum';
+
+/**
+ * Запись о файле, приложенном к платежу (чек об оплате). Сам бинарь лежит в
+ * MinIO-бакете `gateway:files`; в блокчейне файла нет — это чистая БД-сущность,
+ * для проверки целостности используется `checksum_sha256`.
+ *
+ * Привязка — по `payment_hash` (единый ключ любого платежа). Ключ MinIO:
+ * `{coopname}/gateway/{payment_hash}/{kind}/{checksum}.{ext}`.
+ */
+export interface IPaymentFileDatabaseData {
+  id?: number;
+  coopname: string;
+  payment_hash: string;
+  kind: PaymentFileKind;
+  checksum_sha256: string;
+  mime_type: string;
+  size_bytes: number;
+  storage_key: string;
+  /** Оригинальное имя загруженного файла — для отображения и поиска */
+  original_filename?: string | null;
+  uploaded_by_username: string;
+  uploaded_at: Date;
+}

components/controller/src/domain/gateway/interfaces/payment-filters-domain.interface.ts

@@ -13,6 +13,7 @@ export interface PaymentFiltersDomainInterface {
   direction?: PaymentDirectionEnum;
   provider?: string;
   hash?: string;
+  proposal_hash?: string;
 }
 
 /**

components/controller/src/domain/gateway/repositories/payment-file.repository.ts

@@ -0,0 +1,16 @@
+import type { IPaymentFileDatabaseData } from '../interfaces/payment-file-database.interface';
+
+/**
+ * Реестр файлов, приложенных к платежам (чеки об оплате). Файл — чистая БД-сущность
+ * (MinIO + метаданные), блокчейна за ним нет, поэтому интерфейс не наследует
+ * sync-репозиторий.
+ */
+export interface PaymentFileRepository {
+  create(data: IPaymentFileDatabaseData): Promise<IPaymentFileDatabaseData>;
+  findById(id: number): Promise<IPaymentFileDatabaseData | null>;
+  findByChecksum(coopname: string, checksum: string): Promise<IPaymentFileDatabaseData | null>;
+  findByPayment(coopname: string, paymentHash: string): Promise<IPaymentFileDatabaseData[]>;
+  delete(id: number): Promise<void>;
+}
+
+export const PAYMENT_FILE_REPOSITORY = Symbol('PaymentFileRepository');

components/controller/src/domain/process-registry/config/process-hash-locator.ts

@@ -119,6 +119,16 @@ export const PROCESS_HASH_LOCATOR: Readonly<Record<string, HashLocation[]>> = Ob
   // Сущностная таблица — `capital::prgwithdraws.withdraw_hash`.
   'p.cap.wthcap': [{ code: 'capital', table: 'prgwithdraws', field: 'withdraw_hash' }],
 
+  // p.cap.pgexp — пополнение пула программных расходов (o.cap.pgtop, ISSUE
+  // w.cap.pgexp). Одноактовый, process_hash синтетический (sha256 в контракте) —
+  // entity-таблицы нет, данные из blockchain_actions.
+  'p.cap.pgexp': [],
+
+  // p.exp.expns — расход по СЗ (шасси expense): o.exp.blgadv/blgdir (оплата) +
+  // опц. o.exp.over + o.exp.advrpt (отчёт) + опц. o.exp.advret (возврат).
+  // Анкер процесса — proposal_hash в `expense::proposals`.
+  'p.exp.expns': [{ code: 'expense', table: 'proposals', field: 'proposal_hash' }],
+
   // marketplace::requests.hash — поле так и называется `hash`.
   'p.mkt.reqst': [{ code: 'marketplace', table: 'requests', field: 'hash' }],
 

components/controller/src/domain/token/services/token-domain.service.ts

@@ -190,6 +190,22 @@ export class TokenDomainService {
     return verifyEmailToken;
   }
 
+  /**
+   * Генерирует токен подтверждения выхода из кооператива (ссылка в письме).
+   * Срок жизни — как у верификации email (это тоже подтверждение по почте).
+   */
+  async generateConfirmExitToken(userId: string): Promise<string> {
+    const expires = moment().add(config.jwt.verifyEmailExpirationMinutes, 'minutes');
+    const confirmExitToken = this.generateToken({
+      userId,
+      expires: expires.toDate(),
+      type: tokenTypes.CONFIRM_EXIT,
+    });
+
+    await this.saveToken(confirmExitToken, userId, expires.toDate(), tokenTypes.CONFIRM_EXIT);
+    return confirmExitToken;
+  }
+
   /**
    * Удаляет токены по критериям
    */

components/controller/src/domain/wallet/ports/gateway-interactor.port.ts

@@ -9,6 +9,7 @@ import type {
 } from '~/domain/common/interfaces/pagination.interface';
 import { PaymentDomainEntity } from '~/domain/gateway/entities/payment-domain.entity';
 import { PaymentStatusEnum } from '~/domain/gateway/enums/payment-status.enum';
+import type { PaymentDomainInterface } from '~/domain/gateway/interfaces/payment-domain.interface';
 
 export interface GatewayInteractorPort {
   getPayments(
@@ -18,6 +19,20 @@ export interface GatewayInteractorPort {
   createInitialPayment(data: CreateInitialPaymentInputDomainInterface): Promise<PaymentDomainEntity>;
   createDeposit(data: CreateDepositPaymentInputDomainInterface): Promise<PaymentDomainEntity>;
   createWithdraw(data: CreateWithdrawInputDomainInterface): Promise<PaymentDomainEntity>;
+
+  /**
+   * Подготовить (с валидацией) исходящий платеж к созданию БЕЗ записи в БД.
+   * Парный метод к persistWithdraw — даёт вызывающему провести on-chain
+   * транзакцию между валидацией и фиксацией платежа.
+   */
+  prepareWithdraw(data: CreateWithdrawInputDomainInterface): Promise<PaymentDomainInterface>;
+
+  /**
+   * Зафиксировать в БД ранее подготовленный исходящий платеж.
+   * Вызывается только после успешной on-chain транзакции.
+   */
+  persistWithdraw(paymentData: PaymentDomainInterface): Promise<PaymentDomainEntity>;
+
   setPaymentStatus(data: SetPaymentStatusInputDomainInterface): Promise<PaymentDomainEntity>;
 
   /**

components/controller/src/extensions/capital/application/dto/contract_management/config-output.dto.ts

@@ -76,6 +76,18 @@ export class StateOutputDTO extends BaseOutputDTO {
   })
   global_available_invest_pool!: string;
 
+  @Field(() => String, {
+    nullable: true,
+    description: 'Пул программных расходов — средства, переведённые под целевые расходы программы',
+  })
+  program_expense_pool?: string;
+
+  @Field(() => String, {
+    nullable: true,
+    description: 'Зарезервировано в пуле программных расходов под активные расходы (служебные записки в работе)',
+  })
+  program_expense_reserved?: string;
+
   @Field(() => String, {
     description: 'Общая сумма членских взносов по программе',
   })

components/controller/src/extensions/capital/application/dto/onboarding.dto.ts

@@ -68,6 +68,9 @@ export class CapitalOnboardingStateDTO {
   @Field(() => String, { nullable: true })
   onboarding_blagorost_offer_template_hash?: string | null;
 
+  @Field(() => String, { nullable: true })
+  capital_program_doc_data_hash?: string | null;
+
   @Field(() => String)
   onboarding_init_at!: string;
 

components/controller/src/extensions/capital/application/dto/program_expenses/create-program-expense.input.ts

@@ -0,0 +1,47 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { ArrayMinSize, IsArray, IsNotEmpty, IsString, ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+import { ExpenseItemInputDTO } from '~/extensions/expenses/application/dto/expense-item.input';
+import { ExpenseProposalStatementSignedDocumentInputDTO } from '~/application/document/documents-dto/expense-proposal-statement-document.dto';
+
+/**
+ * Создание программного расхода капитала через шасси `expense`.
+ * Capital резервирует `program_expense_pool` на сумму items и шлёт inline
+ * action `expense::createexp` с callback `{capital, onpgexpdone}`. Дальше
+ * lifecycle обслуживает шасси; capital получает callback на финализацию.
+ */
+@InputType('CapitalCreateProgramExpenseInput')
+export class CreateProgramExpenseInputDTO {
+  @Field(() => String, { description: 'Имя кооператива.' })
+  @IsNotEmpty()
+  @IsString()
+  coopname!: string;
+
+  @Field(() => String, { description: 'Хэш СЗ-расхода (детерминированный, из UI). Он же станет proposal_hash в шасси.' })
+  @IsNotEmpty()
+  @IsString()
+  expense_hash!: string;
+
+  @Field(() => String, { description: 'Имя пайщика-создателя СЗ (председатель).' })
+  @IsNotEmpty()
+  @IsString()
+  creator!: string;
+
+  @Field(() => [ExpenseItemInputDTO], { description: 'Строки расхода. Способ оплаты (аванс под отчёт / оплата по счёту) задаётся на каждой строке отдельно.' })
+  @IsArray()
+  @ArrayMinSize(1)
+  @ValidateNested({ each: true })
+  @Type(() => ExpenseItemInputDTO)
+  items!: ExpenseItemInputDTO[];
+
+  @Field(() => String, { description: 'Описание программного расхода.' })
+  @IsString()
+  description!: string;
+
+  @Field(() => ExpenseProposalStatementSignedDocumentInputDTO, {
+    description: 'Подписанная СЗ-смета (document2, registry 2010).',
+  })
+  @ValidateNested()
+  @Type(() => ExpenseProposalStatementSignedDocumentInputDTO)
+  statement!: ExpenseProposalStatementSignedDocumentInputDTO;
+}

components/controller/src/extensions/capital/application/dto/program_expenses/program-expense.output.ts

@@ -0,0 +1,51 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { ExpenseProposalStatus } from '~/extensions/expenses/domain/enums/expense-proposal-status.enum';
+import { ExpenseMechanics } from '~/extensions/expenses/domain/enums/expense-mechanics.enum';
+import { ExpenseRecipientType } from '~/extensions/expenses/domain/enums/expense-recipient-type.enum';
+import { ExpenseItemStatus } from '~/extensions/expenses/domain/enums/expense-item-status.enum';
+
+/** Owner-callback из шасси (зеркало InterExpenseCallbackHandler). */
+@ObjectType('CapitalProgramExpenseCallback')
+export class ProgramExpenseCallbackOutputDTO {
+  @Field(() => String) contract!: string;
+  @Field(() => String) action!: string;
+  @Field(() => String) data!: string;
+}
+
+/** Item в выводе (зеркало InterExpenseItem). */
+@ObjectType('CapitalProgramExpenseItem')
+export class ProgramExpenseItemOutputDTO {
+  @Field(() => String) item_hash!: string;
+  @Field(() => ExpenseMechanics) mechanics!: ExpenseMechanics;
+  @Field(() => ExpenseRecipientType) recipient_type!: ExpenseRecipientType;
+  @Field(() => String) recipient!: string;
+  @Field(() => String, { description: 'Имя получателя (ФИО пайщика или название организации)' })
+  recipient_name!: string;
+  @Field(() => String) description!: string;
+  @Field(() => String) planned_amount!: string;
+  @Field(() => String) actual_amount!: string;
+  @Field(() => ExpenseItemStatus) status!: ExpenseItemStatus;
+}
+
+/**
+ * Программный расход в проекции Капитала — те же данные шасси, спроецированные
+ * под consumer-extension. Capital НЕ хранит свой mirror items/total — берёт через
+ * inter-порт INTER_EXPENSE_CHASSIS.
+ */
+@ObjectType('CapitalProgramExpense')
+export class ProgramExpenseOutputDTO {
+  @Field(() => String) coopname!: string;
+  @Field(() => String) expense_hash!: string;
+  @Field(() => String) creator!: string;
+  @Field(() => String, { description: 'Имя инициатора (ФИО пайщика или название организации)' })
+  creator_name!: string;
+  @Field(() => String) source_wallet!: string;
+  @Field(() => ExpenseProposalStatus) status!: ExpenseProposalStatus;
+  @Field(() => ProgramExpenseCallbackOutputDTO, { nullable: true })
+  callback?: ProgramExpenseCallbackOutputDTO;
+  @Field(() => [ProgramExpenseItemOutputDTO]) items!: ProgramExpenseItemOutputDTO[];
+  @Field(() => String) total_planned!: string;
+  @Field(() => String) total_actual!: string;
+  @Field(() => String) created_at!: string;
+  @Field(() => String) updated_at!: string;
+}

components/controller/src/extensions/capital/application/dto/program_expenses/topup-program-expense.input.ts

@@ -0,0 +1,19 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { IsNotEmpty, IsString } from 'class-validator';
+
+/**
+ * Пополнение пула программных расходов кооператива (председатель).
+ * Перевод суммы из `global_available_invest_pool` в `program_expense_pool`.
+ */
+@InputType('CapitalTopupProgramExpenseInput')
+export class TopupProgramExpenseInputDTO {
+  @Field(() => String, { description: 'Имя кооператива.' })
+  @IsNotEmpty()
+  @IsString()
+  coopname!: string;
+
+  @Field(() => String, { description: 'Сумма пополнения (asset, eg "10000.0000 RUB").' })
+  @IsNotEmpty()
+  @IsString()
+  amount!: string;
+}

components/controller/src/extensions/capital/application/listeners/program-share-registration-on-project-delta.listener.ts

@@ -0,0 +1,65 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { CapitalContract } from 'cooptypes';
+import config from '~/config/config';
+import type { IDelta } from '~/types/common';
+import { ProjectStatus } from '../../domain/enums/project-status.enum';
+import { ProgramShareRegistrationService } from '../services/program-share-registration.service';
+
+/**
+ * Слушатель дельт `capital::projects`. Как только проект (в т.ч. компонент)
+ * оказывается в статусе active — СРАЗУ регистрирует доли всех активных пайщиков
+ * Благороста в нём, не дожидаясь периодического scheduler'а. В pending не
+ * заводим: заход только в активные проекты (решение пользователя 2026-06-16);
+ * при переходе pending→active придёт новая дельта со status=active.
+ *
+ * Why: окно между созданием проекта и его переводом в `result` может быть
+ * минутами. Контракт `regshare` принимает только pending|active, а отката
+ * `result → active` нет — пайщики, не успевшие попасть до закрытия окна, теряют
+ * долю в компоненте безвозвратно (инцидент voskhod, компонент 011bcd92…,
+ * 2026-06-16). Событие закрывает это окно. Зеркалит
+ * `ProgramShareRegistrationOnUserWalletDeltaListener` (тот реагирует на
+ * изменение баланса, этот — на появление проекта).
+ *
+ * Неблокирующий: обработчик получает событие и неспешно обходит пайщиков;
+ * на dispatch-pipeline/парсер не влияет (EventEmitter2.emit — fire-and-forget).
+ * Промахи (downtime/потеря события) подбирает периодический scheduler-бэкстоп.
+ */
+@Injectable()
+export class ProgramShareRegistrationOnProjectDeltaListener {
+  private readonly logger = new Logger(ProgramShareRegistrationOnProjectDeltaListener.name);
+
+  constructor(
+    private readonly programShareRegistrationService: ProgramShareRegistrationService
+  ) {}
+
+  @OnEvent(`delta::${CapitalContract.contractName.production}::${CapitalContract.Tables.Projects.tableName}`)
+  async handleProjectDelta(delta: IDelta): Promise<void> {
+    if (!delta.present) return;
+    if (delta.scope !== config.coopname) return;
+
+    const value = delta.value as CapitalContract.Tables.Projects.IProject | undefined;
+    if (!value?.project_hash) return;
+
+    // Заводим доли только в active-проектах: pending ещё не готов к заходу
+    // (решение пользователя 2026-06-16). При переходе pending→active придёт
+    // новая дельта со status=active — на ней и зайдём.
+    const status = String(value.status);
+    if (status !== ProjectStatus.ACTIVE) return;
+
+    const project_hash = String(value.project_hash);
+    try {
+      await this.programShareRegistrationService.syncProgramSharesForProject(
+        delta.scope,
+        project_hash
+      );
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      const stack = error instanceof Error ? error.stack : undefined;
+      this.logger.warn(
+        `regshare event-driven (project) sync не выполнен: coop=${delta.scope} project=${project_hash}: ${message}`,
+        stack
+      );
+    }
+  }
+}

components/controller/src/extensions/capital/application/resolvers/program-expenses.resolver.ts

@@ -0,0 +1,80 @@
+import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
+import { UseGuards } from '@nestjs/common';
+import { GqlJwtAuthGuard } from '~/application/auth/guards/graphql-jwt-auth.guard';
+import { RolesGuard } from '~/application/auth/guards/roles.guard';
+import { AuthRoles } from '~/application/auth/decorators/auth.decorator';
+import { TransactionDTO } from '~/application/common/dto/transaction-result-response.dto';
+import {
+  createPaginationResult,
+  PaginationInputDTO,
+  PaginationResult,
+} from '~/application/common/dto/pagination.dto';
+import { ProgramExpensesManagementService } from '../services/program-expenses-management.service';
+import { CreateProgramExpenseInputDTO } from '../dto/program_expenses/create-program-expense.input';
+import { TopupProgramExpenseInputDTO } from '../dto/program_expenses/topup-program-expense.input';
+import { ProgramExpenseOutputDTO } from '../dto/program_expenses/program-expense.output';
+
+const paginatedProgramExpensesResult = createPaginationResult(
+  ProgramExpenseOutputDTO,
+  'PaginatedCapitalProgramExpenses',
+);
+
+/**
+ * GraphQL-резолвер программных расходов капитала. Председатель/совет.
+ * Write → on-chain capital; read → шасси через inter-порт.
+ */
+@Resolver()
+export class ProgramExpensesResolver {
+  constructor(private readonly service: ProgramExpensesManagementService) {}
+
+  @Mutation(() => TransactionDTO, {
+    name: 'capitalCreateProgramExpense',
+    description: 'Создание программного расхода капитала через шасси expense.',
+  })
+  @UseGuards(GqlJwtAuthGuard, RolesGuard)
+  @AuthRoles(['chairman', 'member'])
+  async createProgramExpense(
+    @Args('data', { type: () => CreateProgramExpenseInputDTO }) data: CreateProgramExpenseInputDTO,
+  ): Promise<TransactionDTO> {
+    return this.service.createProgramExpense(data);
+  }
+
+  @Mutation(() => TransactionDTO, {
+    name: 'capitalTopupProgramExpensePool',
+    description: 'Пополнение пула программных расходов капитала из инвестиционного пула.',
+  })
+  @UseGuards(GqlJwtAuthGuard, RolesGuard)
+  @AuthRoles(['chairman'])
+  async topupProgramExpense(
+    @Args('data', { type: () => TopupProgramExpenseInputDTO }) data: TopupProgramExpenseInputDTO,
+  ): Promise<TransactionDTO> {
+    return this.service.topupProgramExpense(data);
+  }
+
+  @Query(() => paginatedProgramExpensesResult, {
+    name: 'capitalProgramExpenses',
+    description: 'Список программных расходов капитала (через шасси expense).',
+  })
+  @UseGuards(GqlJwtAuthGuard, RolesGuard)
+  @AuthRoles(['chairman', 'member'])
+  async listProgramExpenses(
+    @Args('coopname', { type: () => String }) coopname: string,
+    @Args('options', { type: () => PaginationInputDTO, nullable: true }) options?: PaginationInputDTO,
+  ): Promise<PaginationResult<ProgramExpenseOutputDTO>> {
+    return this.service.listProgramExpenses(coopname, options);
+  }
+
+  @Query(() => ProgramExpenseOutputDTO, {
+    name: 'capitalProgramExpense',
+    description: 'Программный расход по expense_hash.',
+    nullable: true,
+  })
+  @UseGuards(GqlJwtAuthGuard, RolesGuard)
+  @AuthRoles(['chairman', 'member'])
+  async getProgramExpense(
+    @Args('coopname') coopname: string,
+    @Args('expense_hash') expenseHash: string,
+  ): Promise<ProgramExpenseOutputDTO | null> {
+    return this.service.getProgramExpense(coopname, expenseHash);
+  }
+}

components/controller/src/extensions/capital/application/services/onboarding.service.ts

@@ -29,6 +29,10 @@ type OnboardingHashKey =
   | 'onboarding_blagorost_provision_hash'
   | 'onboarding_blagorost_offer_template_hash';
 
+type CapitalOnboardingConfig = IConfig &
+  Partial<Record<OnboardingFlagKey, boolean>> &
+  Partial<Record<OnboardingHashKey | 'onboarding_init_at' | 'onboarding_expire_at' | 'capital_program_doc_data_hash', string>>;
+
 @Injectable()
 export class CapitalOnboardingService {
   constructor(
@@ -88,10 +92,40 @@ export class CapitalOnboardingService {
     }
   }
 
-  private async loadPlugin(): Promise<ExtensionDomainEntity<IConfig & Record<string, any>>> {
+  private isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null;
+  }
+
+  private getMetaString(meta: unknown, key: string): string | undefined {
+    if (!this.isRecord(meta)) return undefined;
+    const value = meta[key];
+    return typeof value === 'string' ? value : undefined;
+  }
+
+  private isSignatureInfo(value: unknown): value is ISignedDocumentDomainInterface['signatures'][number] {
+    if (!this.isRecord(value)) return false;
+
+    return (
+      typeof value.id === 'number' &&
+      typeof value.signed_hash === 'string' &&
+      typeof value.signer === 'string' &&
+      typeof value.public_key === 'string' &&
+      typeof value.signature === 'string' &&
+      typeof value.signed_at === 'string' &&
+      typeof value.meta === 'string'
+    );
+  }
+
+  private getMetaSignatures(meta: unknown): ISignedDocumentDomainInterface['signatures'] {
+    if (!this.isRecord(meta)) return [];
+    const value = meta.signatures;
+    return Array.isArray(value) ? value.filter((item) => this.isSignatureInfo(item)) : [];
+  }
+
+  private async loadPlugin(): Promise<ExtensionDomainEntity<CapitalOnboardingConfig>> {
     const plugin = await this.extensionRepository.findByName('capital');
     if (!plugin) throw new Error('Конфигурация расширения capital не найдена');
-    const pluginConfig = { ...plugin.config } as IConfig & Record<string, any>;
+    const pluginConfig: CapitalOnboardingConfig = { ...plugin.config };
 
     let needUpdate = false;
     if (!pluginConfig.onboarding_init_at) {
@@ -113,7 +147,7 @@ export class CapitalOnboardingService {
     return { ...plugin, config: pluginConfig };
   }
 
-  private buildState(pluginConfig: IConfig & Record<string, any>): CapitalOnboardingStateDTO {
+  private buildState(pluginConfig: CapitalOnboardingConfig): CapitalOnboardingStateDTO {
     return {
       generator_program_template_done: !!pluginConfig.onboarding_generator_program_template_done,
       onboarding_generator_program_template_hash: pluginConfig.onboarding_generator_program_template_hash || null,
@@ -125,6 +159,7 @@ export class CapitalOnboardingService {
       onboarding_blagorost_provision_hash: pluginConfig.onboarding_blagorost_provision_hash || null,
       blagorost_offer_template_done: !!pluginConfig.onboarding_blagorost_offer_template_done,
       onboarding_blagorost_offer_template_hash: pluginConfig.onboarding_blagorost_offer_template_hash || null,
+      capital_program_doc_data_hash: pluginConfig.capital_program_doc_data_hash || null,
       onboarding_init_at: pluginConfig.onboarding_init_at || '',
       onboarding_expire_at: pluginConfig.onboarding_expire_at || '',
     };
@@ -141,7 +176,7 @@ export class CapitalOnboardingService {
     const hashKey = this.mapStepToHash(data.step);
     const normalizedTitle = data.title?.trim().substring(0, 200) || undefined;
 
-    if ((plugin.config as any)[flagKey]) {
+    if (plugin.config[flagKey]) {
       return this.buildState(plugin.config);
     }
     const project_id = uuid();
@@ -168,12 +203,12 @@ export class CapitalOnboardingService {
 
     // Публикуем проект решения в блокчейн сразу после генерации
     const documentForPublish: ISignedDocumentDomainInterface = {
-      version: (generatedDoc.meta as any)?.version || '1.0',
+      version: this.getMetaString(generatedDoc.meta, 'version') || '1.0',
       hash: generatedDoc.hash,
-      doc_hash: (generatedDoc.meta as any)?.doc_hash || generatedDoc.hash,
-      meta_hash: (generatedDoc.meta as any)?.meta_hash || generatedDoc.hash,
+      doc_hash: this.getMetaString(generatedDoc.meta, 'doc_hash') || generatedDoc.hash,
+      meta_hash: this.getMetaString(generatedDoc.meta, 'meta_hash') || generatedDoc.hash,
       meta: generatedDoc.meta,
-      signatures: (generatedDoc.meta as any)?.signatures || [],
+      signatures: this.getMetaSignatures(generatedDoc.meta),
     };
 
     await this.freeDecisionPort.publishProjectOfFreeDecision({